DtChannelConfiguration.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2020 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
 
 
#pragma once

#include <vrvUtil/vrvUtil.h> 
#include <vrvUtil/DtConfiguration.h>
#include <vrvUtil/DtKeywordMixin.h>

#include <boost/serialization/set.hpp>
 
namespace makVrv 
{ 
   class DT_DLL_VRVUTIL DtChannelConfiguration 
      : public DtConfiguration
      , public DtKeywordMixin
   { 
      
   public:

      static const char* DefaultChannelString;
      
      static const char* UseObserverSensorString;

      enum ProjectionUnits
      {
         NoUnits,
         FieldOfViewAngles,
         DatabaseUnits
      };

      enum ProjectionResizePolicy
      {
         FIXED = 0, 
         HORIZONTAL, 
         VERTICAL, 
         NONE
      };

      enum NearFarClipPolicy
      {
         NEAR_FAR_FIXED,
         NEAR_FAR_DYNAMIC_REDUCE_NEAR_CLIP,
         NEAR_FAR_DYNAMIC_REDUCE_Z_FIGHT,
         NEAR_FAR_DYNAMIC_NEAR_CLIP_MAG_CLAMP  // same as reduce z fight but with near clamped
                                               // by an intersector so it can't go past terrain
                                               // in front of the camera
      };

      enum DynamicNearClipAttachedObjectPolicy
      {
         IGNORE_ATTACHED = 0, 
         FIXED_NEAR_CLIP_ATTACHED, 
         DISTANCE_TO_ATTACHED 
      };

      DtChannelConfiguration(const std::string& name = DefaultChannelString);

      DtChannelConfiguration(const DtChannelConfiguration&);

      DtChannelConfiguration& operator=(const DtChannelConfiguration&);

      virtual ~DtChannelConfiguration();

      virtual void setParentChannel(const std::string& displayName, 
         const std::string& windowName, const std::string& channelName);

      virtual void getParentChannel(std::string& displayEngineNameOut, 
         std::string& windowNameOut, std::string& channelNameOut) const;
    
      virtual void setProjection(ProjectionUnits units, double left, double right, double bottom, double top, 
         double zNear, double zFar);

      virtual void getProjection(ProjectionUnits& units, double &left, double &right, double &bottom, double &top, 
         double &zNear, double &zFar) const;

      virtual ProjectionUnits projectionUnits() const;

      virtual void setProjectionUnits(ProjectionUnits units);
                  
      virtual void getClearColor(float& r,float& g,float& b,float& a) const;

      virtual void setClearColor(float r,float g,float b,float a);

      virtual void setCameraPositionOffset(double x, double y, double z);

      virtual void getCameraPositionOffset(double& x, double& y, double& z) const;

      virtual void setCameraOrientationOffset(double psi, double theta, double phi);

      virtual void getCameraOrientationOffset(double& psi, double& theta, double& phi) const;

      virtual void getViewport(double& left,double& right,double& bottom,double& top) const;

      virtual void setViewport(double left,double right,double bottom, double top);

      virtual const std::string& observerName() const;

      virtual void setObserverName(const std::string& observerName);

      virtual const std::string& sensorName() const;

      virtual void setSensorName(const std::string& sensorName);

      virtual ProjectionResizePolicy projectionResizePolicy() const;

      virtual void setProjectionResizePolicy(ProjectionResizePolicy policy);

      virtual double cameraMagnification() const;

      virtual void setCameraMagnification(double mag);

      virtual float lodScale() const;

      virtual void setLodScale(float lodScale);
   
      virtual void setNearFarClipPolicy( NearFarClipPolicy policy );

      virtual NearFarClipPolicy nearFarClipPolicy() const;

      virtual void setZFightReductionRatio( double ratio );

      virtual double zFightReductionRatio() const;

      virtual void setDynamicNearClipAttachedObjectPolicy( 
         DynamicNearClipAttachedObjectPolicy useAttached );

      virtual DynamicNearClipAttachedObjectPolicy 
         dynamicNearClipAttachedObjectPolicy() const;

      virtual void setAltitudeForUseAttachedNearClip( double altitude );

      virtual double altitudeForUseAttachedNearClip() const;

      virtual void setNearClipWhenAttached( double distance );

      virtual double nearClipWhenAttached() const;

      virtual void setDynamicWaterVisibilityEnable( bool enable );

      virtual bool dynamicWaterVisibilityEnable() const;

      virtual void setDynamicWaterVisibilityMax( double visMax );

      virtual double dynamicWaterVisibilityMax() const;

      virtual void setRenderOrder( int order );

      virtual int renderOrder() const;

      virtual double minZNear(double value) const;

      virtual void setMinZNear(double value);

      virtual float pixelRatio() const;

      virtual void setPixelRatio(float ratio);

      DT_DECLARE_ALL_serialize_FUNCTIONS
   protected:

      template<class Archive>
      void _serialize(Archive & ar, const unsigned int version)
      {
         ar & DT_SERIALIZE_BASE(DtConfiguration);

         ar & DT_SERIALIZE_MEMBER(myClearColorR);
         ar & DT_SERIALIZE_MEMBER(myClearColorG);
         ar & DT_SERIALIZE_MEMBER(myClearColorB);
         ar & DT_SERIALIZE_MEMBER(myClearColorA);
         ar & DT_SERIALIZE_MEMBER(myViewportLeft);
         ar & DT_SERIALIZE_MEMBER(myViewportRight);
         ar & DT_SERIALIZE_MEMBER(myViewportBottom);
         ar & DT_SERIALIZE_MEMBER(myViewportTop);
         ar & DT_SERIALIZE_MEMBER(myParentDisplayEngineName);
         ar & DT_SERIALIZE_MEMBER(myParentWindowName);
         ar & DT_SERIALIZE_MEMBER(myParentChannelName);
         ar & DT_SERIALIZE_MEMBER(myCameraPositionOffsetX);
         ar & DT_SERIALIZE_MEMBER(myCameraPositionOffsetY);
         ar & DT_SERIALIZE_MEMBER(myCameraPositionOffsetZ);
         ar & DT_SERIALIZE_MEMBER(myCameraOrientationOffsetPsi);
         ar & DT_SERIALIZE_MEMBER(myCameraOrientationOffsetTheta);
         ar & DT_SERIALIZE_MEMBER(myCameraOrientationOffsetPhi);
         ar & DT_SERIALIZE_MEMBER(myFrustumLeft);
         ar & DT_SERIALIZE_MEMBER(myFrustumRight);
         ar & DT_SERIALIZE_MEMBER(myFrustumTop);
         ar & DT_SERIALIZE_MEMBER(myFrustumBottom);
         ar & DT_SERIALIZE_MEMBER(myNearZ);
         ar & DT_SERIALIZE_MEMBER(myFarZ);
         ar & DT_SERIALIZE_MEMBER(myProjectionUnits);
         ar & DT_SERIALIZE_MEMBER(myObserverName);
         ar & DT_SERIALIZE_MEMBER(myProjectionResizePolicy);

         if (version > 1)
         {
            ar & DT_SERIALIZE_MEMBER(myKeywords);
         }

         if (version > 2 && version < 6)
         {
            ar & DT_SERIALIZE_MEMBER(myDynamicNearFar);
            ar & DT_SERIALIZE_MEMBER(myNearFarRatio);
         }

         if (version > 3)
         {
            ar & DT_SERIALIZE_MEMBER(myCameraMagnification);
         }

         if (version > 4)
         {
            ar & DT_SERIALIZE_MEMBER(mySensorName);
         }

         if (version > 5)
         {
            ar & DT_SERIALIZE_MEMBER(myNearFarClipPolicy);
            ar & DT_SERIALIZE_MEMBER(myZFightReductionRatio);
            ar & DT_SERIALIZE_MEMBER(myDynamicNearClipAttachedObjectPolicy);
            ar & DT_SERIALIZE_MEMBER(myAltitudeForUseAttachedNearClip);
            ar & DT_SERIALIZE_MEMBER(myNearClipWhenAttached);
            ar & DT_SERIALIZE_MEMBER(myDynamicWaterVisibilityEnable);
            ar & DT_SERIALIZE_MEMBER(myDynamicWaterVisibilityMax);
         }

         if (version > 6)
         {
            ar & DT_SERIALIZE_MEMBER(myRenderOrder);
         }
         if (version > 7)
         {
            ar & DT_SERIALIZE_MEMBER(myLodScale);
        }
      }

      std::string myParentDisplayEngineName;
      std::string myParentWindowName;
      std::string myParentChannelName;

      // This is storing info, not writing out/reading in
      // The app gets pixel ratio from windows/X (not setting
      // itself)
      float myPixelRatio;

      //Default Clear color is 0,0,0,0
      float myClearColorR;
      float myClearColorG;
      float myClearColorB;
      float myClearColorA;

      double myViewportLeft;
      double myViewportRight;
      double myViewportBottom;
      double myViewportTop;

      double myCameraPositionOffsetX;
      double myCameraPositionOffsetY;
      double myCameraPositionOffsetZ;
      double myCameraOrientationOffsetPsi;
      double myCameraOrientationOffsetTheta;
      double myCameraOrientationOffsetPhi;
      
      double myFrustumLeft;
      double myFrustumRight;
      double myFrustumTop;
      double myFrustumBottom;
      double myNearZ;
      double myFarZ;

      double myMinZNear;

      bool myDynamicNearFar; //Version 3-5
      // Not used
      double myNearFarRatio; //Version 3-5

      double myCameraMagnification; // Version 4

      float myLodScale; // Version 8

      ProjectionUnits myProjectionUnits;
      std::string myObserverName;
      std::string mySensorName;
      ProjectionResizePolicy myProjectionResizePolicy;

      NearFarClipPolicy myNearFarClipPolicy; // Version 6
      double myZFightReductionRatio;
      DynamicNearClipAttachedObjectPolicy myDynamicNearClipAttachedObjectPolicy;
      double myAltitudeForUseAttachedNearClip;
      double myNearClipWhenAttached;
      bool myDynamicWaterVisibilityEnable;
      double myDynamicWaterVisibilityMax;

      int myRenderOrder; // Version 7

   };
} 

BOOST_CLASS_VERSION(makVrv::DtChannelConfiguration,8)