Visualizer.h

Go to the documentation of this file.

//************************************************************************
//                                  *
//           Copyright (C)  2004                *
//     University Corporation for Atmospheric Research          *
//           All Rights Reserved                *
//                                  *
//************************************************************************/
//
//  File:       Visualizer.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       September 2013
//
//  Description:  Definition of Visualizer class:
//  A Visualizer object is associated with each visualization window.  It contains
//  information required for rendering, performs
//  navigation and resize, and defers drawing to the viz window's list of
//  registered renderers.
 
#pragma once
 
#include <map>
#include <vapor/DataStatus.h>
#include <vapor/ParamsMgr.h>
#include <vapor/Renderer.h>
#include <vapor/AnnotationRenderer.h>
#include <vapor/Framebuffer.h>
 
namespace VAPoR {
 
 
class RENDER_API Visualizer : public MyBase {
public:
    Visualizer(const ParamsMgr *pm, const DataStatus *dataStatus, string winName);
    ~Visualizer();
 
    ViewpointParams *getActiveViewpointParams() const;
 
    RegionParams *getActiveRegionParams() const;
 
    AnnotationParams *getActiveAnnotationParams() const;
 
    int InitializeGL(GLManager *glManager);
 
    int paintEvent(bool fast);
 
    int resizeGL(int w, int h);
 
    string GetWindowName() const { return _winName; }
 
    int GetNumRenderers() const { return _renderers.size(); }
 
    //
    int CreateRenderer(string dataSetName, string renderType, string renderName);
 
    //
    void DestroyRenderer(string renderType, string renderName, bool hasOpenGLContext);
 
    //
    void DestroyAllRenderers(bool hasOpenGLContext);
 
    bool HasRenderer(string renderType, string renderName) const;
 
    void MoveRendererToFront(string renderType, string renderName);
    void MoveRenderersOfTypeToFront(const std::string &type);
 
    double getPixelSize() const;
 
    int SetImageCaptureEnabled(bool onOff, string filename)
    {
        if (_animationCaptureEnabled) {
            SetErrMsg("Image capture concurrent with Animation Capture\n");
            return -1;
        }
        _imageCaptureEnabled = onOff;
        if (onOff)
            _captureImageFile = filename;
        else
            _captureImageFile = "";
        return 0;
    }
 
    int SetAnimationCaptureEnabled(bool onOff, string filename)
    {
        if (_imageCaptureEnabled) {
            SetErrMsg("Image capture concurrent with Animation Capture\n");
            return -1;
        }
        if (_animationCaptureEnabled == onOff) {
            SetErrMsg("Animation capture in incorrect state\n");
            return -1;
        }
        _animationCaptureEnabled = onOff;
        if (onOff)
            _captureImageFile = filename;
        else
            _captureImageFile = "";
        return 0;
    }
 
    //
    void DrawText(string text, int x, int y, int size, float color[3], int type = 0) { _vizFeatures->AddText(text, x, y, size, color, type); }
 
    void DrawTextNormalizedCoords(string text, float x, float y, int size, float color[3], int type = 0) { _vizFeatures->AddTextNormalizedCoords(text, x, y, size, color, type); }
 
    void ClearText() { _vizFeatures->ClearText(); }
 
    //
    void ClearRenderCache();
    
    void ClearRenderCache(const string &inst);
 
private:
    void _renderColorbars(int timeStep);
 
    int _captureImage(std::string path);
 
    void _loadMatricesFromViewpointParams();
 
    enum GLVendorType { UNKNOWN = 0, MESA, NVIDIA, ATI, INTEL };
 
    static GLVendorType GetVendor();
 
    int _configureLighting();
 
    bool _getPixelData(unsigned char *data) const;
 
    void _deleteFlaggedRenderers();
    int  _initializeNewRenderers();
    void _clearActiveFramebuffer(float r, float g, float b) const;
    void _applyDatasetTransformsForRenderer(Renderer *r);
 
    int _getCurrentTimestep() const;
 
    static void _incrementPath(string &s);
 
    Renderer *_getRenderer(string type, string instance) const;
 
    const ParamsMgr *   _paramsMgr;
    const DataStatus *  _dataStatus;
    string              _winName;
    GLManager *         _glManager;
    AnnotationRenderer *_vizFeatures;
 
    bool _insideGLContext;    // This is only to make sure we don't call certain functions when they are not supposed to be called. In some situations this variable will be set to true incorrectly. In
                              // those cases there is already some other error so it doesn't matter.
    bool   _imageCaptureEnabled;
    bool   _animationCaptureEnabled;
    string _captureImageFile;
 
    vector<Renderer *> _renderers;
    vector<Renderer *> _renderersToDestroy;
 
    Framebuffer  _framebuffer;
    unsigned int _screenQuadVAO = 0;
    unsigned int _screenQuadVBO = 0;
};
 
};    // namespace VAPoR