viewpointparams.h

Go to the documentation of this file.

//************************************************************************
//                                                                      *
//           Copyright (C)  2004                                        *
//     University Corporation for Atmospheric Research                  *
//           All Rights Reserved                                        *
//                                                                      *
//************************************************************************/
//                  
//  File:       viewpointparams.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       August 2004
//
//  Description:    Defines the ViewpointParams class
//      This class contains the parameters associated with viewpoint and lights
//
#ifndef VIEWPOINTPARAMS_H
#define VIEWPOINTPARAMS_H

#include <qwidget.h>
#include "params.h"

#include "viewpoint.h"

class VizTab;

namespace VAPoR {
class ExpatParseMgr;
class MainForm;
class RegionParams;
class PanelCommand;
class XmlNode;
class ParamNode;
class PARAMS_API ViewpointParams : public Params {
    
public: 
    ViewpointParams(int winnum);
    virtual ~ViewpointParams();
    

    static float getMaxStretchedCubeSide() {return maxStretchedCubeSide;}

    static float* getMinStretchedCubeCoords() {return minStretchedCubeCoord;}

    static bool getStereoUserPref() { return _stereoUserPref; }

    int getNumLights() { return numLights;}
    
    float getExponent() {return specularExp;}

    float* getCameraPosLocal() {return currentViewpoint->getCameraPosLocal();}

    float* getViewDir() {return currentViewpoint->getViewDir();}

    float* getUpVec() {return currentViewpoint->getUpVec();}

    float* getRotationCenterLocal(){return currentViewpoint->getRotationCenterLocal();}

#ifndef DOXYGEN_SKIP_THIS
    static ParamsBase* CreateDefaultInstance() {return new ViewpointParams(-1);}
    const std::string& getShortName() {return _shortName;}
    virtual Params* deepCopy(ParamNode* n = 0);
    //Note that all calls to get camera pos and get rot center return values
    //in local coordinates, not in lat/lon.  When the viewpoint params is in
    //latlon mode, it is necessary to perform convertLocalFromLonLat and convertLocalToLonLat
    //to keep the local coords current with latlons.  This conversion must occur whenever
    //the coordinates change (from the gui or the manip), 
    //and when the time step changes, whenever
    //there is a change between latlon and local mode, and whenever a new
    //data set is loaded
    //When setCameraPos or setRotCenter is called in latlon mode, the new local values
    //must be converted to latlon values.
    
    float getCameraPosLocal(int coord) {return currentViewpoint->getCameraPosLocal()[coord];}
    
    void setCameraPosLocal(float* val,int timestep ) {
        currentViewpoint->setCameraPosLocal(val);
        if (useLatLon) convertLocalToLonLat(timestep);
    }
    
    void setViewDir(int i, float val) { currentViewpoint->setViewDir(i,val);}
    void setViewDir(float* val) {currentViewpoint->setViewDir(val);}
    
    void setUpVec(int i, float val) { currentViewpoint->setUpVec(i,val);}
    void setUpVec(float* val) {currentViewpoint->setUpVec(val);}
    bool hasPerspective(){return currentViewpoint->hasPerspective();}
    void setPerspective(bool on) {currentViewpoint->setPerspective(on);}

    // Stereo support as provide by the graphics card
    static void setStereoUserPref(bool pref) {_stereoUserPref = pref;}
    void setStereoNotSupported() {_stereoSupported=0;}
    void setStereoSupported() {_stereoSupported=1;}
    bool getStereoSupported() {return _stereoSupported;}
       
    // Stereo mode settings as applied by the user (on/off) 
    int getStereoMode(){ return stereoMode;}
    void setStereoMode(int mode) {stereoMode = mode;}
    float getStereoSeparation() {return stereoSeparation;}
    void setStereoSeparation(float angle){stereoSeparation = angle;}
    float getStereoConvergence() {return stereoConvergence;}
    void setStereoConvergence(float conv) {stereoConvergence = conv;}
    
    void setNumLights(int nlights) {numLights = nlights;}
    const float* getLightDirection(int lightNum){return lightDirection[lightNum];}
    void setLightDirection(int lightNum,int dir, float val){
        lightDirection[lightNum][dir] = val;
    }
    float getDiffuseCoeff(int lightNum) {return diffuseCoeff[lightNum];}
    float getSpecularCoeff(int lightNum) {return specularCoeff[lightNum];}
    
    float getAmbientCoeff() {return ambientCoeff;}
    void setDiffuseCoeff(int lightNum, float val) {diffuseCoeff[lightNum]=val;}
    void setSpecularCoeff(int lightNum, float val) {specularCoeff[lightNum]=val;}
    void setExponent(float val) {specularExp=val;}
    void setAmbientCoeff(float val) {ambientCoeff=val;}
    Viewpoint* getCurrentViewpoint() { return currentViewpoint;}
    void setCurrentViewpoint(Viewpoint* newVP){
        if (currentViewpoint) delete currentViewpoint;
        currentViewpoint = newVP;
    }
    Viewpoint* getHomeViewpoint() { return homeViewpoint;}
    void setHomeViewpoint(Viewpoint* newVP){
        if (homeViewpoint) delete homeViewpoint;
        homeViewpoint = newVP;
    }
    
    //Set to default viewpoint for specified region
    void centerFullRegion(int timestep);
    
    float* getRotCenterLatLon(){return currentViewpoint->getRotCenterLatLon();}
    float getRotationCenterLocal(int i){ return currentViewpoint->getRotationCenterLocal(i);}
    float* getCamPosLatLon() {return currentViewpoint->getCamPosLatLon();}
    
    void setRotationCenterLocal(float* vec, int timestep){
        currentViewpoint->setRotationCenterLocal(vec);
        if (useLatLon) convertLocalToLonLat(timestep);
    }
    void setCamPosLatLon(float x, float y) {currentViewpoint->setCamPosLatLon(x,y);}
    void setRotCenterLatLon(float x, float y) {currentViewpoint->setRotCenterLatLon(x,y);}
    bool isLatLon() {return useLatLon;}
    void setLatLon(bool val){useLatLon = val;}
    
    void rescale(float scaleFac[3], int timestep);

    bool convertLocalToLonLat(int timestep);
    bool convertLocalFromLonLat(int timestep);
    //determine far and near distance to region based on current viewpoint
    void getFarNearDist(float* boxFar, float* boxNear);
    
    //Reset viewpoint when new session is started:
    virtual bool reinit(bool doOverride);
    virtual void restart();
    
    static void setDefaultPrefs();
    //Transformations to convert world coords to (unit)render cube and back
    //
    
    static void localToStretchedCube(const float fromCoords[3], float toCoords[3]);
    
    static void localToStretchedCube(const double fromCoords[3], double toCoords[3]);

    
    static void localFromStretchedCube(float fromCoords[3], float toCoords[3]);
    static void setCoordTrans();
    
    //Maintain the OpenGL Model Matrices, since they can be shared between visualizers
    
    const double* getModelViewMatrix() {return modelViewMatrix;}

    //Rotate a 3-vector based on current modelview matrix
    void transform3Vector(const float vec[3], float resvec[3]);
    
    void setModelViewMatrix(double* mtx){
        for (int i = 0; i<16; i++) modelViewMatrix[i] = mtx[i];
    }
    bool elementStartHandler(ExpatParseMgr*, int /* depth*/ , std::string& /*tag*/, const char ** /*attribs*/);
    bool elementEndHandler(ExpatParseMgr*, int /*depth*/ , std::string& /*tag*/);
    ParamNode* buildNode();
    static const float* getDefaultViewDir(){return defaultViewDir;}
    static const float* getDefaultUpVec(){return defaultUpVec;}
    static const float* getDefaultLightDirection(int lightNum){return defaultLightDirection[lightNum];}
    static float getDefaultAmbientCoeff(){return defaultAmbientCoeff;}
    static float getDefaultSpecularExp(){return defaultSpecularExp;}
    static int getDefaultNumLights(){return defaultNumLights;}
    static const float* getDefaultDiffuseCoeff() {return defaultDiffuseCoeff;}
    static const float* getDefaultSpecularCoeff() {return defaultSpecularCoeff;}
    static void setDefaultLightDirection(int lightNum, float val[3]){
        for (int i = 0; i<3; i++) defaultLightDirection[lightNum][i] = val[i];
    }
    static void setDefaultUpVec(float val[3]){
        for (int i = 0; i<3; i++) defaultUpVec[i] = val[i];
    }
    static void setDefaultViewDir(float val[3]){
        for (int i = 0; i<3; i++) defaultViewDir[i] = val[i];
    }
    static void setDefaultSpecularCoeff(float val[3]){
        for (int i = 0; i<3; i++) defaultSpecularCoeff[i] = val[i];
    }
    static void setDefaultDiffuseCoeff(float val[3]){
        for (int i = 0; i<3; i++) defaultDiffuseCoeff[i] = val[i];
    }
    static void setDefaultAmbientCoeff(float val){ defaultAmbientCoeff = val;}
    static void setDefaultSpecularExp(float val){ defaultSpecularExp = val;}
    static void setDefaultNumLights(int val){ defaultNumLights = val;}
    static const string _stereoUserPrefAttr;


protected:

    

    static const string _shortName;
    static const string _latLonAttr;
    static const string _currentViewTag;
    static const string _homeViewTag;
    static const string _lightTag;
    static const string _lightDirectionAttr;
    static const string _lightNumAttr;
    static const string _diffuseLightAttr;
    static const string _ambientLightAttr;
    static const string _specularLightAttr;
    static const string _specularExponentAttr;
    static const string _stereoModeAttr;
    static const string _stereoSeparationAttr;
    static const string _stereoConvergenceAttr; 
    
    Viewpoint* currentViewpoint;
    Viewpoint* homeViewpoint;
    static bool _stereoSupported;
    static bool _stereoUserPref;
    float stereoSeparation;
    float stereoConvergence;
    int stereoMode;
    bool useLatLon;
    int numLights;
    int parsingLightNum;
    float lightDirection[3][4];
    float diffuseCoeff[3];
    float specularCoeff[3];
    float specularExp;
    float ambientCoeff;

    //Static coeffs for affine coord conversion:
    //
    static float minStretchedCubeCoord[3];
    static float maxStretchedCubeCoord[3];
    
    static float maxStretchedCubeSide;
    //defaults:
    static float defaultViewDir[3];
    static float defaultUpVec[3];
    static float defaultLightDirection[3][3];
    static float defaultDiffuseCoeff[3];
    static float defaultSpecularCoeff[3];
    static float defaultAmbientCoeff;
    static float defaultSpecularExp;
    static int defaultNumLights;
    //Max sides
    
    //GL state saved here since it may be shared...
    //
    double modelViewMatrix[16];
#endif //DOXYGEN_SKIP_THIS
};
};
#endif //VIEWPOINTPARAMS_H