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 "params.h"
#include "viewpoint.h"
#include "command.h"

class VizTab;

namespace VAPoR {
class ExpatParseMgr;
class RegionParams;
class XmlNode;
class ParamNode;
class PARAMS_API ViewpointParams : public Params {
    
public: 
    ViewpointParams(XmlNode* parent, int winnum);
    virtual ~ViewpointParams();
    static ParamsBase* CreateDefaultInstance() {return new ViewpointParams(0,-1);}
    const std::string getShortName() {return _shortName;}
    
    void rescale(vector<double> scaleFac);

    void getFarNearDist(float* boxFar, float* boxNear);
    
    virtual void Validate(int type);

    virtual void restart();
    
    const double* getModelViewMatrix() {return _modelViewMatrix;}
    const double* getProjectionMatrix() {return _projectionMatrix;}
    void setProjectionMatrix(const double* mtx){
        for (int i = 0; i<16; i++) _projectionMatrix[i] = mtx[i];
    }
    void setModelViewMatrix(const double* mtx){
        for (int i = 0; i<16; i++) _modelViewMatrix[i] = mtx[i];
    }


    int getNumLights() { 
        vector<long> defNumLights(_defaultNumLights,1);
        return (GetValueLong(_numLightsTag,defNumLights));
    }
    
    double getExponent() {
        vector<double> defSpecExp(_defaultSpecularExp,1);
        return (GetValueDouble(_specularExpTag,defSpecExp));
    }

    const vector<double> getCameraPosLocal() {return getCurrentViewpoint()->getCameraPosLocal();}

    void getStretchedCamPosLocal(double* vec){
        getCurrentViewpoint()->getStretchedCamPosLocal(vec);
    }
    int setStretchedCamPosLocal(const double* vec){
        return getCurrentViewpoint()->setStretchedCamPosLocal(vec,this);
    }
    void getStretchedRotCtrLocal(double* vec){
        getCurrentViewpoint()->getStretchedRotCtrLocal(vec);
    }
    int setStretchedRotCtrLocal(const double* vec){
        return getCurrentViewpoint()->setStretchedRotCtrLocal(vec,this);
    }
    const vector<double> getViewDir() {return getCurrentViewpoint()->getViewDir();}

    const vector<double> getUpVec() {return getCurrentViewpoint()->getUpVec();}

    const vector<double> getRotationCenterLocal(){return getCurrentViewpoint()->getRotationCenterLocal();}

    void setCurrentVPToHome(){
        Viewpoint* currentViewpoint = getCurrentViewpoint();
        setHomeViewpoint((Viewpoint*)currentViewpoint->deepCopy());
    }

    double getCameraPosLocal(int coord) {
        return getCurrentViewpoint()->getCameraPosLocal()[coord];
    }

    int setCameraPosLocal(const vector<double>& val,int  ) {
        VPSetChanged(true);
        return getCurrentViewpoint()->setCameraPosLocal(val, this);
    }
    int setViewDir(int coord, double val) {
        VPSetChanged(true);
        return getCurrentViewpoint()->setViewDir(coord,val, this);
    }
    int setViewDir(const vector<double>& val) {
        VPSetChanged(true);
        return getCurrentViewpoint()->setViewDir(val, this);
    }
    int setUpVec(int i, double val) { 
        VPSetChanged(true);
        return getCurrentViewpoint()->setUpVec(i,val,this);
    }
    int setUpVec(const vector<double>& val) {
        VPSetChanged(true);
        return getCurrentViewpoint()->setUpVec(val,this);
    }
    double getRotationCenterLocal(int coord){ return getCurrentViewpoint()->getRotationCenterLocal(coord);}

    int setRotationCenterLocal(const vector<double>& vec){
        VPSetChanged(true);
        return getCurrentViewpoint()->setRotationCenterLocal(vec,this);
    }
    int setNumLights(int nlights) {
        return SetValueLong(_numLightsTag,"Set number of lights", nlights);
    }
    double getLightDirection(int lightNum, int dir){
        return GetValueDoubleVec(_lightDirectionsTag)[dir+3*lightNum];
    }
    int setLightDirection(int lightNum, int dir, double val){
        
        vector<double> ldirs = GetValueDoubleVec(_lightDirectionsTag);
        ldirs[dir+3*lightNum] = val;
        return  SetValueDouble(_lightDirectionsTag,"Set light direction",ldirs);
    }
    double getDiffuseCoeff(int lightNum) {
        vector<double> _defaultDiffCoeff;
        for (int i = 0; i<3; i++) _defaultDiffCoeff.push_back(_defaultDiffuseCoeff[i]);
        return GetValueDoubleVec(_diffuseCoeffTag,_defaultDiffCoeff)[lightNum];
    }
    double getSpecularCoeff(int lightNum) {
        vector<double> _defaultSpecCoeff;
        for (int i = 0; i<3; i++) _defaultSpecCoeff.push_back(_defaultSpecularCoeff[i]);
        return GetValueDoubleVec(_specularCoeffTag,_defaultSpecCoeff)[lightNum];
    }
    double getAmbientCoeff() {
        vector<double> _defaultAmbient(_defaultAmbientCoeff,1);
        return GetValueDouble(_ambientCoeffTag,_defaultAmbient);
    }
    int setDiffuseCoeff(int lightNum, double val) {
        
        vector<double>diffCoeff = GetValueDoubleVec(_diffuseCoeffTag);
        diffCoeff[lightNum]=val;
        return SetValueDouble(_diffuseCoeffTag,"Set diffuse coefficient",diffCoeff);
    }
    int setSpecularCoeff(int lightNum, double val) {
        
        vector<double>specCoeff= GetValueDoubleVec(_specularCoeffTag);
        specCoeff[lightNum]=val;
        return  SetValueDouble(_specularCoeffTag,"Set specular coefficient",specCoeff);
    }
    int setExponent(double val) {
        return SetValueDouble(_specularExpTag, "Set specular lighting",val);
    }
    int setAmbientCoeff(double val) {
        return   SetValueDouble(_ambientCoeffTag,"Set ambient lighting",val);
    }
    int setCurrentViewpoint(Viewpoint* newVP){
        Command* cmd = Command::CaptureStart(this,"set current viewpoint");
        vector<string> path;
        path.push_back(_currentViewTag);
        path.push_back(Viewpoint::_viewpointTag);
        int rc = SetParamsBase(path,newVP);
        Command::CaptureEnd(cmd,this);
        VPSetChanged(true);
        return rc;
        
    }
    int setHomeViewpoint(Viewpoint* newVP){
        Command* cmd = Command::CaptureStart(this, "set home viewpoint");
        vector<string> path;
        path.push_back(_homeViewTag);
        path.push_back(Viewpoint::_viewpointTag);
        int rc = SetParamsBase(path,newVP);
        Command::CaptureEnd(cmd,this);
        VPSetChanged(true);
        return rc;
    }
    void centerFullDomain(int timestep);


    virtual Viewpoint* getHomeViewpoint() {
        vector<string> path;
        path.push_back(_homeViewTag);
        path.push_back(Viewpoint::_viewpointTag);
        return (Viewpoint*) GetParamsBase(path);
    }
    void VPSetChanged(bool val);

    bool VPHasChanged(int viz = -1);

#ifndef DOXYGEN_SKIP_THIS
    
    static const double* getDefaultViewDir(){return _defaultViewDir;}
    static const double* getDefaultUpVec(){return _defaultUpVec;}
    static const double* getDefaultLightDirection(int lightNum){return _defaultLightDirection[lightNum];}
    static double getDefaultAmbientCoeff(){return _defaultAmbientCoeff;}
    static double getDefaultSpecularExp(){return _defaultSpecularExp;}
    static int getDefaultNumLights(){return _defaultNumLights;}
    static const double* getDefaultDiffuseCoeff() {return _defaultDiffuseCoeff;}
    static const double* getDefaultSpecularCoeff() {return _defaultSpecularCoeff;}
    static void setDefaultLightDirection(int lightNum, double val[3]){
        for (int i = 0; i<3; i++) _defaultLightDirection[lightNum][i] = val[i];
    }
    static void setDefaultUpVec(double val[3]){
        for (int i = 0; i<3; i++) _defaultUpVec[i] = val[i];
    }
    static void setDefaultViewDir(double val[3]){
        for (int i = 0; i<3; i++) _defaultViewDir[i] = val[i];
    }
    static void setDefaultSpecularCoeff(double val[3]){
        for (int i = 0; i<3; i++) _defaultSpecularCoeff[i] = val[i];
    }
    static void setDefaultDiffuseCoeff(double val[3]){
        for (int i = 0; i<3; i++) _defaultDiffuseCoeff[i] = val[i];
    }
    static void setDefaultAmbientCoeff(double val){ _defaultAmbientCoeff = val;}
    static void setDefaultSpecularExp(double val){ _defaultSpecularExp = val;}
    static void setDefaultNumLights(int val){ _defaultNumLights = val;}

private:
    bool _vpChangeBit; //accessed via VPHasChanged() and VPSetChanged();
    static const string _shortName;
    static const string _currentViewTag;
    static const string _homeViewTag;
    static const string _lightDirectionsTag;
    static const string _diffuseCoeffTag;
    static const string _specularCoeffTag;
    static const string _specularExpTag;
    static const string _ambientCoeffTag;
    static const string _numLightsTag;

    //Following is protected 
    virtual Viewpoint* getCurrentViewpoint() {
        vector<string> path;
        path.push_back(_currentViewTag);
        path.push_back(Viewpoint::_viewpointTag);
        return (Viewpoint*)GetParamsBase(path);
    }
    //defaults:
    static double _defaultViewDir[3];
    static double _defaultUpVec[3];
    static double _defaultLightDirection[3][3];
    static double _defaultDiffuseCoeff[3];
    static double _defaultSpecularCoeff[3];
    static double _defaultAmbientCoeff;
    static double _defaultSpecularExp;
    static int _defaultNumLights;
    double _modelViewMatrix[16];
    double _projectionMatrix[16];
#endif //DOXYGEN_SKIP_THIS
};
};
#endif //VIEWPOINTPARAMS_H