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.

#ifndef Visualizer_H
#define Visualizer_H

#include <map>
#include <jpeglib.h>
#include "params.h"
#include "renderparams.h"
#include <vapor/MyBase.h>
#include <vapor/common.h>
#include "datastatus.h"
#include "mousemodeparams.h"


namespace VAPoR {
typedef bool (*renderCBFcn)(int winnum, bool newCoords);

class ViewpointParams;
class RegionParams;
class AnimationParams;
class VizFeatureParams;
class VizFeatureRenderer;
class Renderer;
class Trackball;
class TranslateStretchManip;
class TextObject;


class RENDER_API Visualizer : public MyBase
{
public:
   
    Visualizer( int winnum);
    ~Visualizer();

    ViewpointParams* getActiveViewpointParams();

    RegionParams* getActiveRegionParams(); 

    AnimationParams* getActiveAnimationParams();

    VizFeatureParams* getActiveVizFeatureParams();
    
    
    void initializeGL();

    Trackball* GetTrackball();

    void SetTrackballCoordsChanged(bool val){
        _tBallChanged = val;
    }
    
    int paintEvent();

    void resizeGL( int w, int h );

    int getWindowNum() {return _winNum;}

    void resetTrackball();

    void resetNearFar(ViewpointParams* vpParams);

    bool projectPointToWin(double userCoords[3], double winCoords[2]);

    int pointIsOnBox(double corners[8][3], double pickPt[2]);

    bool pixelToVector(double winCoords[2], const vector<double> cameraPos, double dirVec[3]);

    //void draw3DCursor(const double position[3]);

    Renderer* getRenderer(int i) {return _renderer[i];}

    int getNumRenderers(){return _renderer.size();}

    Renderer* getRenderer(RenderParams* p);

    VizFeatureRenderer* getVizFeatureRenderer() {return _vizFeatures;}
    
    int insertSortedRenderer(RenderParams* p, Renderer* ren){return insertRenderer(p, ren, 5);}
    
    bool removeRenderer(RenderParams* p);  

    void removeAllRenderers();
    
    void removeDisabledRenderers();  

    TranslateStretchManip* getManip(const std::string& paramTag){
        int mode = MouseModeParams::getModeFromParams(paramTag);
        return _manipHolder[mode];
    }
    double getPixelSize();

    static void setActiveWinNum(int winnum) {_activeWindowNum = winnum;}

    static void setRegionShareFlag(bool regionIsShared){_regionShareFlag = regionIsShared;}
    
    int getWidth() {return _width;}

    int getHeight() {return _height;}

    double* getModelViewMatrix();

    void setImageCaptureEnabled(bool onOff, string filename){
        _imageCaptureEnabled = onOff;
        if (onOff) _captureImageFile = filename;
        else _captureImageFile = "";
    }

    

private:
    int captureImage(string filename);

    void renderManip();

    void paintSetup(int timeStep);

    bool pointIsOnQuad(double cor1[3],double cor2[3],double cor3[3],double cor4[3], double pickPt[2]);

    int insertRenderer(RenderParams* p, Renderer* ren, int order);

    //The Visualizer keeps track of the renderers with an ordered list of them
    //as well as with a map from renderparams to renderer
    void mapRenderer(RenderParams* rp, Renderer* ren){_rendererMapping[rp] = ren;}
    
    bool windowIsActive(){return (_winNum == _activeWindowNum);}

    static bool activeWinSharesRegion() {return _regionShareFlag;}

    const double* getProjectionMatrix() { return _projectionMatrix;}    
    
    const int* getViewport() {return _viewport;}

    enum OGLVendorType {
        UNKNOWN = 0,
        MESA,
        NVIDIA,
        ATI,
        INTEL
    };

    static OGLVendorType GetVendor();

    void setUpViewport(int width, int height);

    void renderText();

    void placeLights();
    
    void saveGLMatrix(int timestep, ViewpointParams*);

    bool getPixelData(unsigned char* data);

    class RenderListElt {
        public:
        Renderer* ren;
        float camDist;
        Params::ParamsBaseType renType;
    };

#ifndef DOXYGEN_SKIP_THIS
    vector<TranslateStretchManip*> _manipHolder;
    static Trackball* _globalTrackball;
    Trackball* _localTrackball;
    bool _tBallChanged;
    bool _imageCaptureEnabled;
    string _captureImageFile;
    int _winNum;
    int _width, _height;
    int _previousTimeStep;
    int _previousFrameNum;
    VizFeatureRenderer* _vizFeatures;
    
    vector<Renderer*> _renderer;
    vector<int>_renderOrder;
    
    //Map params to renderer
    std::map<RenderParams*,Renderer*> _rendererMapping;
    
    float _farDist, _nearDist;
    
    int _viewport[4];
    double _projectionMatrix[16];

    static int _activeWindowNum;
    //This flag is true if the active window is sharing the region.
    //If the current window is not active, it will still share the region, if
    //the region is shared, and the active region is shared.
    static bool _regionShareFlag;
    
#endif //DOXYGEN_SKIP_THIS
};

};

#endif // Visualizer_H