Renderer.h

Go to the documentation of this file.

 
//************************************************************************
//                                  *
//           Copyright (C)  2004                *
//     University Corporation for Atmospheric Research          *
//           All Rights Reserved                *
//                                  *
//************************************************************************/
//  File:       Renderer.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       September 2004
//
//  Description:    Defines the Renderer class.
//      A pure virtual class that is implemented for each renderer.
//      Methods are called by the visualizer class as needed.
//
 
#ifndef RENDERER_H
#define RENDERER_H
 
#include <vapor/MyBase.h>
#include <vapor/ParamsMgr.h>
#include <vapor/RenderParams.h>
 
namespace VAPoR {
 
class ShaderProgram;
struct GLManager;
 
class RENDER_API RendererBase : public MyBase {
public:
    RendererBase(const ParamsMgr *pm, string winName, string dataSetName, string paramsType, string classType, string instName, DataMgr *dataMgr);
    virtual ~RendererBase();
    virtual int initializeGL(GLManager *glManager);
 
    string GetVisualizer() { return _winName; }
 
    string GetMyName() const { return (_instName); };
    string GetInstanceName() const { return GetMyName(); }
 
    string GetMyType() const { return (_classType); };
 
    string GetMyParamsType() const { return (_paramsType); };
 
    string GetMyDatasetName() const { return (_dataSetName); };
 
    bool IsGLInitialized() const { return (_glInitialized); }
 
protected:
    const ParamsMgr *_paramsMgr;
    string           _winName;
    string           _dataSetName;
    string           _paramsType;
    string           _classType;
    string           _instName;
    DataMgr *        _dataMgr;
 
    GLManager *_glManager;
 
    virtual int _initializeGL() = 0;
 
public:
    void FlagForDeletion();
    bool IsFlaggedForDeletion() const;
 
    RendererBase() {}
 
private:
    bool _glInitialized;
    bool _flaggedForDeletion;
};
 
class RENDER_API Renderer : public RendererBase {
public:
    //
    Renderer(const ParamsMgr *pm, string winName, string dataSetName, string paramsType, string classType, string instName, DataMgr *dataMgr);
 
    virtual ~Renderer();
 
    double GetDefaultZ(DataMgr *dataMgr, size_t ts) const;
 
    virtual int paintGL(bool fast);
 
    //
    void ClearCache() { _clearCache(); };
 
#ifdef VAPOR3_0_0_ALPHA
#endif
 
#ifdef VAPOR3_0_0_ALPHA
    void setBypass(int timestep)
    {
        if (_currentRenderParams) _currentRenderParams->setBypass(timestep);
    }
 
    void setPartialBypass(int timestep)
    {
        if (_currentRenderParams) _currentRenderParams->setPartialBypass(timestep);
    }
 
    void setAllBypass(bool val)
    {
        if (_currentRenderParams) _currentRenderParams->setAllBypass(val);
    }
 
    bool doBypass(int timestep) { return (_currentRenderParams && _currentRenderParams->doBypass(timestep)); }
 
    bool doAlwaysBypass(int timestep) { return (_currentRenderParams && _currentRenderParams->doAlwaysBypass(timestep)); }
 
    virtual void setAllDataDirty() { return; }
#endif
 
#ifdef VAPOR3_0_0_ALPHA
    static void SetControlExec(ControlExec *ce) { _controlExec = ce; }
 
 
    static void UndoRedo(bool isUndo, int instance, Params *beforeP, Params *afterP, Params *auxPrev = 0, Params *auxNext = 0);
 
#endif
 
#ifdef VAPOR3_0_0_ALPHA
    void buildLocal2DTransform(int dataOrientation, float a[2], float b[2], float *constVal, int mappedDims[3]);
#endif
 
#ifdef VAPOR3_0_0_ALPHA
 
    void getLocalContainingRegion(float regMin[3], float regMax[3]);
#endif
 
    void renderColorbar();
 
 
    RenderParams *GetActiveParams() const { return (_paramsMgr->GetRenderParams(_winName, _dataSetName, _paramsType, _instName)); }
 
    ViewpointParams *GetViewpointParams() const { return _paramsMgr->GetViewpointParams(_winName); }
 
    AnnotationParams *GetAnnotationParams() const { return _paramsMgr->GetAnnotationParams(_winName); }
 
    Transform *GetDatasetTransform() const { return GetViewpointParams()->GetTransform(_dataSetName); }
 
    static void ApplyTransform(GLManager *gl, const Transform *dataset, const Transform *renderer);
 
    static void ApplyDatasetTransform(GLManager *gl, const Transform *dataset);
 
protected:
    Renderer() {}
 
    virtual std::string _getColorbarVariableName() const;
 
    virtual int _paintGL(bool fast) = 0;
 
    void EnableClipToBox(ShaderProgram *shader, float haloFrac = 0.0) const;
 
    //
    void DisableClippingPlanes();
 
    void GetClippingPlanes(float planes[24]) const;
 
    //
    virtual bool VariableExists(size_t ts, std::vector<string> &varnames, int level, int lod, bool zeroOK) const;
 
    virtual void _clearCache() = 0;
 
    static const int _imgHgt;
    static const int _imgWid;
    unsigned char *  _colorbarTexture;
    string           _fontName;
 
private:
    size_t _timestep;
 
#ifdef VAPOR3_0_0_ALPHA
    static ControlExec *_controlExec;
#endif
};
 
//
// RendererFactory Class
//
 
class RENDER_API RendererFactory {
public:
    static RendererFactory *Instance();
 
    void RegisterFactoryFunction(string myName, string myParamsName, function<Renderer *(const ParamsMgr *, string, string, string, string, DataMgr *)> classFactoryFunction);
 
    Renderer *(CreateInstance(const ParamsMgr *pm, string winName, string dataSetName, string classType, string instName, DataMgr *dataMgr));
 
    string              GetRenderClassFromParamsClass(string paramsClass) const;
    string              GetParamsClassFromRenderClass(string renderClass) const;
    std::vector<string> GetFactoryNames() const;
 
private:
    map<string, function<Renderer *(const ParamsMgr *, string, string, string, string, DataMgr *)>> _factoryFunctionRegistry;
    map<string, string>                                                                             _factoryMapRegistry;
 
    RendererFactory();
    RendererFactory(const RendererFactory &);
    RendererFactory &operator=(const RendererFactory &);
};
 
//
// RendererRegistrar Class
//
// Register RendererBase derived class with:
//
//  static RendererRegistrar<RendererClass>
//      registrar("myclassname", "myparamsclassname");
//
// where 'RendererClass' is a class derived from 'Renderer', and
// "myclassname" is the name of the class
//
 
template<class T> class RENDER_API RendererRegistrar {
public:
    RendererRegistrar(string classType, string paramsClassType)
    {
        // register the class factory function
        //
        RendererFactory::Instance()->RegisterFactoryFunction(classType, paramsClassType,
                                                             [](const ParamsMgr *pm, string winName, string dataSetName, string classType, string instName, DataMgr *dataMgr) -> Renderer * {
                                                                 return new T(pm, winName, dataSetName, instName, dataMgr);
                                                             });
    }
};
 
};    // namespace VAPoR
 
#endif    // RENDERER_H