DtDeSharedState.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2016 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/


#pragma once

#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeTimeManager.h>
#include <vrvGraphicsUtils/DtColorValue.h>
#include <vrvUtil/signalslib.h>

namespace makVrv 
{ 

   class DtCoordinateSystem;
   class DtDeSharedStateProctor;
   class DtModelDefinition;
   class DtModelDefinitionManager;
   class DtModelSetRealizationManager;
   class DtModelDefinition;

   class DT_DLL_VRVCORE DtDeSharedState 
   { 

   public:

      friend class DtDeSharedStateCreator;

      friend class DtDeSharedStateProctor;

      virtual ~DtDeSharedState();

      virtual void initialize();



      virtual const DtModelDefinitionManager& modelDefinitionManager() const;
      virtual DtModelDefinitionManager& modelDefinitionManager();

      virtual const DtModelSetRealizationManager& modelSetRealizationManager() const;

      virtual void setVisualizeModelSet( int modelset, bool visualize );

      virtual void addModelDefinition(const DtModelDefinition& definition);

      virtual void setModelDefinitionManager(
         const DtModelDefinitionManager& definition);

      virtual void renameModelDefinition(const DtModelDefinition& old,
         const DtModelDefinition& newDef);

      virtual void destroyModelDefinition(const DtModelDefinition& definition);

      virtual void setModelInstancingEnabled(bool);

      virtual void clearModelInstancingCache();




      virtual void setCoordinateSystem(const std::string& coordinateSystemName,
         const std::string& coordinateSystemParameters);

      const DtCoordinateSystem& coordinateSystem() const;
      DtCoordinateSystem& coordinateSystem();





      virtual void setDateAndTime(int year, DtDeTimeManager::Month month,
         int dayOfMonth, int hour, int minutes,double seconds);

      virtual void setUseGlobalTimeZone(bool);

      virtual void setTimeScale(double timeScale);

      const DtDeTimeManager& timeManager() const;

      DtDeTimeManager& timeManager();




      virtual void reloadShader();

      virtual void setWireframeMode(bool state);
      virtual bool wireframeMode() const;

      virtual bool terrainScalingEnabled() const;
      virtual void setTerrainScalingEnabled(bool enabled);

      virtual double terrainScaleFactor() const;
      virtual void setTerrainScaleFactor(double scaleFactor);

      virtual bool clearTrackHistoryOnTerrainScaleChanged() const;
      virtual void setClearTrackHistoryOnTerrainScaleChanged(bool clear );

      virtual bool useAutofocus() const;
      virtual void setUseAutofocus(bool useAutofocus);

      virtual double focalDepth() const;
      virtual void setFocalDepth(double focalDepth);

      virtual double focalRange() const;
      virtual void setFocalRange(double focalRange);

      virtual float globalAmbientValue() const;
      virtual void setGlobalAmbientValue(float globalAmbientValue);

      virtual bool useGlobalAmbient() const;
      virtual void setUseGlobalAmbient(bool useGlobalAmbient);

      virtual float globalDiffuseValue() const;
      virtual void setGlobalDiffuseValue(float globalDiffuseValue);

      virtual bool useGlobalDiffuse() const;
      virtual void setUseGlobalDiffuse(bool useGlobalDiffuse);

      virtual void setPlanViewGeocentricOccludedTransparency(float f);
      virtual float planViewGeocentricOccludedTransparency() const;      

      virtual void setPerformanceOverlayOn(bool enabled);
      virtual bool performanceOverlayEnabled() const;

      virtual void setProfilerOverlayOn(bool enabled);
      virtual bool profilerOverlayEnabled() const;

      virtual bool perPixelLightingEnabled() const;
      virtual void setPerPixelLightingEnabled( bool setting );

      virtual bool lensFlareEnabled() const;
      virtual void setLensFlareEnabled( bool setting );

      virtual bool crepuscularRaysEnabled() const;
      virtual void setCrepuscularRaysEnabled( bool setting );

      virtual int componentVisualizationMode() const;
      virtual void setComponentVisualizationMode(int value);

      virtual double regenerateCubeMapThreshold() const;
      virtual void setRegenerateCubeMapThreshold(double threshold);

      virtual double regenerateHeightMapPercThreshold() const;
      virtual void setRegenerateHeightMapPercThreshold(double threshold);

      virtual bool omitCloudInCubeMap() const;
      virtual void setOmitCloudInCubeMap(bool omit);

      virtual void setInstancedRenderingEnabled(bool enabled);

      virtual bool instancedRenderingEnabled() const;

      virtual void setShadowState(bool shadowMode);

      virtual bool shadowMode() const;

      virtual void loadRenderSettings(const std::string& filepath);      
      virtual void saveRenderSettings(const std::string& filepath);
      virtual void loadDefaultRenderSettings(bool useOnlyFactorySettings);
      virtual void saveDefaultRenderSettings();
      virtual void updateRenderState();




      virtual void setDdsFlip(bool state);

      virtual bool ddsFlip() const;

      virtual void loadLoaderSettings(const std::string& filepath);      
      virtual void saveLoaderSettings(const std::string& filepath);
      virtual void loadDefaultLoaderSettings(bool useOnlyFactorySettings);
      virtual void saveDefaultLoaderSettings();
      virtual void updateLoaderState();




      virtual void setAccelerationCachingEnabled(bool enabled);

      virtual bool accelerationCachingEnabled() const;

      virtual void clearAccelerationCache() const;

      virtual void setInstancingEnabled(bool enabled);

      virtual void setClearInstancesOnNewSceneEnabled(bool enabled);

      virtual bool instancingEnabled() const;

      virtual bool clearInstancesOnNewScene() const;

      virtual void clearInstancingCache();

      virtual void setCompressTextures(bool enabled);

      virtual bool compressTextures() const;

      virtual void loadCacheSettings(const std::string& filepath);
      virtual void saveCacheSettings(const std::string& filepath);
      virtual void loadDefaultCacheSettings(bool useOnlyFactorySettings);
      virtual void saveDefaultCacheSettings();
      virtual void updateCacheState();




      virtual bool oceanPlanarReflectionsEnabled() const;
      virtual void setOceanPlanarReflectionsEnabled( bool setting );

      virtual float oceanPlanarReflectionsLODScale() const;
      virtual void setOceanPlanarReflectionsLODScale( float setting );

      virtual bool oceanPlanarReflectionsSpecifyFarClip() const;
      virtual void setOceanPlanarReflectionsSpecifyFarClip( bool setting );

      virtual double oceanPlanarReflectionsFarClip() const;
      virtual void setOceanPlanarReflectionsFarClip( double setting );

      virtual double staticOceanLodRange() const;
      virtual void setStaticOceanLodRange( double range );

      virtual bool waveSprayEffectEnabled() const;
      virtual void setWaveSprayEffectEnabled( bool setting );

      virtual bool rotorWashDecalEnabled() const;
      virtual void setRotorWashDecalEnabled( bool setting );

      virtual double oceanHeightMapResolution() const;
      virtual void setOceanHeightMapResolution( double setting );

      virtual void setOceanHeightMapTextureSize(int setting);
      virtual int oceanHeightMapTextureSize() const;


      virtual void setTidalStreamWakesEnabled(bool enabled);

      virtual bool tidalStreamWakesEnabled() const;

      virtual int planarReflectionTextureWidth() const;
      virtual void setPlanarReflectionTextureWidth( int w );

      virtual int planarReflectionTextureHeight() const;
      virtual void setPlanarReflectionTextureHeight( int h );

      virtual void loadOceanRenderSettings(const std::string& filepath);      
      virtual void saveOceanRenderSettings(const std::string& filepath);
      virtual void loadDefaultOceanRenderSettings(bool useOnlyFactorySettings);
      virtual void saveDefaultOceanRenderSettings();
      virtual void updateOceanRenderState();

      virtual void setPagedLodMagnificationHighLodAngle(float angle);
      virtual float pagedLodMagnificationHighLodAngle() const;



      virtual float lightingEmissionScale() const;
      virtual void setLightingEmissionScale( float setting );

      virtual float lightingDiffuseScale() const;
      virtual void setLightingDiffuseScale(float setting);

      virtual float lightingAmbientScale() const;
      virtual void setLightingAmbientScale(float setting);

      virtual void loadLightingRenderSettings(const std::string& filepath);      
      virtual void saveLightingRenderSettings(const std::string& filepath);
      virtual void loadDefaultLightingRenderSettings(bool useOnlyFactorySettings);
      virtual void saveDefaultLightingRenderSettings();
      virtual void updateLightingRenderState();




      virtual bool intersectorDrawEnabled() const;
      virtual void setIntersectorDrawEnabled( bool setting );

      virtual float intersectorDrawnDuration() const;
      virtual void setIntersectorDrawnDuration(float setting);

      virtual const DtColorValue& failedIntersectorColor() const;
      virtual void setFailedIntersectorColor(const DtColorValue& setting);

      virtual const DtColorValue& oddSegmentIntersectorColor() const;
      virtual void setOddSegmentIntersectorColor(const DtColorValue& setting);

      virtual const DtColorValue& evenSegmentIntersectorColor() const;
      virtual void setEvenSegmentIntersectorColor(const DtColorValue& setting);

      virtual void loadIntersectorSettings(const std::string& filepath);      
      virtual void saveIntersectorSettings(const std::string& filepath);
      virtual void loadDefaultIntersectorSettings(bool useOnlyFactorySettings);
      virtual void saveDefaultIntersectorSettings();
      virtual void updateIntersectorState();
      
      virtual const bool diGuyInstancingEnabled() const;
      virtual void setDiGuyInstancingEnabled(bool enabled);

      virtual const int diGuyInstancedLod() const;
      virtual void setDiGuyInstancedLod(int lod);

      virtual const bool diGuyVisualizeInstancing() const;
      virtual void setDiGuyVisualizeInstancing(bool enabled);

      virtual const float diGuyMaxDrawDistance() const;
      virtual void setDiGuyMaxDrawDistance(float distance);

      virtual const bool diGuyMultiThreadUpdate() const;
      virtual void setDiGuyMultiThreadUpdate(bool enabled);

      virtual void loadDiGuySettings(const std::string& filepath);
      virtual void saveDiGuySettings(const std::string& filepath);
      virtual void loadDefaultDiGuySettings(bool useOnlyFactorySettings);
      virtual void saveDefaultDiGuySettings();
      virtual void updateDiGuyState();



      virtual void initializeSharedChangeManager();



      virtual void synchronizeSlave(DtDeRecord* igRecord);


      void setAutoSave(bool b)
      {
         myAutoSave = b;
      }

      bool autoSave() const
      {
         return myAutoSave;
      }

   protected:

      DtDeSharedState(DtDe& DtDe);

      virtual void sendModelDefinitionsToSlave(DtMessageClient* messageClient);

      virtual void sendModelSetConfigurationToSlave(
         DtMessageClient* messageClient);




      virtual void local_setModelDefinitionManager(const DtModelDefinitionManager& definition);

      virtual void local_addModelDefinition(const DtModelDefinition& definition);

      virtual void local_destroyModelDefinition(const std::string& definition);

      virtual void local_setModelInstancingEnabled(bool);

      virtual void local_clearModelInstancingCache();

      virtual void local_reloadShader();

      virtual void local_setWireframeMode(bool mode);

      virtual void local_setTerrainScalingEnabled(bool enabled);

      virtual void local_setTerrainScaleFactor(double scaleFactor);

      virtual void local_setUseAutofocus(bool useAutofocus);

      virtual void local_setFocalDepth(double focalDepth);

      virtual void local_setFocalRange(double focalRange);

      virtual void local_setGlobalAmbientValue(float globalAmbientValue);

      virtual void local_setUseGlobalAmbient(bool useGlobalAmbient);

      virtual void local_setGlobalDiffuseValue(double globalDiffuseValue);

      virtual void local_setUseGlobalDiffuse(bool useGlobalDiffuse);

      virtual void local_setClearTrackHistoryOnTerrainScaleChanged(bool clear);

      virtual void local_setPlanViewGeocentricOccludedTransparency(float alpha);

      virtual void local_setShadowState(bool mode);

      virtual void local_ddsFlipState(bool flip);

      virtual void local_setVisualizeModelSet( int modelSet, bool visualize );

      void local_setCoordinateSystem(const std::string& coordinateSystemName, 
         const std::string& coordinateSystemParameters);

      virtual void local_setPerPixelLightingEnabled(bool mode);

      virtual void local_setOceanPlanarReflectionsEnabled(bool mode);

      virtual void local_setOceanPlanarReflectionsLODScale(float val);

      virtual void local_setOceanPlanarReflectionsSpecifyFarClip(bool mode);

      virtual void local_setOceanPlanarReflectionsFarClip(double val);

      virtual void local_setStaticOceanLodRange(double range);

      virtual void local_setLensFlareEnabled(bool mode);

      virtual void local_setCrepuscularRaysEnabled(bool mode);

      virtual void local_setWaveSprayEffectEnabled(bool mode);

      virtual void local_setRotorWashDecalEnabled(bool mode);

      virtual void local_setOceanHeightMapResolution(double resolution);


      void local_setDateAndTime(int year, DtDeTimeManager::Month month,int dayOfMonth,
         int hour, int minutes,double seconds);
      void local_setTimeScale(double timeScale);
      void local_setUseGlobalTimeZone(bool);



      virtual void local_setAccelerationCachingEnabled(bool enabled);

      virtual void local_clearAccelerationCache();

      virtual void local_setInstancingEnabled( bool enabled );

      virtual void local_setClearInstancesOnNewScene( bool enabled );

      virtual void local_clearInstancingCache();

      virtual void local_setCompressTextures( bool enabled );

      virtual void local_setTidalStreamWakesEnabled( bool enabled );

      virtual void local_setInstancedRenderingEnabled(bool enabled);
      
     virtual void local_setRegenerateCubeMapThreshold(double threshold);
     
     virtual void local_setRegenerateHeightMapPercThreshold(double threshold);

     virtual void local_setOmitCloudInCubeMap(bool enabled);

      virtual void local_setOceanHeightMapTextureSize(int val);

      virtual void local_setPlanarReflectionTextureWidth(int w);

      virtual void local_setPlanarReflectionTextureHeight(int w);

      virtual void local_setLightingEmissionScale(float val);
      virtual void local_setLightingDiffuseScale(float val);
      virtual void local_setLightingAmbientScale(float val);


      virtual void local_setIntersectorDrawEnabled( bool setting );

      virtual void local_setIntersectorDrawnDuration(float setting);

      virtual void local_setFailedIntersectorColor(const DtColorValue& setting);

      virtual void local_setOddSegmentIntersectorColor(const DtColorValue& setting);

      virtual void local_setEvenSegmentIntersectorColor(const DtColorValue& setting);
      

      virtual void local_setDiGuyInstancingEnabled(bool color);
      
      virtual void local_setDiGuyInstancedLod(int lod);
      
      virtual void local_setDiGuyVisualizeInstancing(bool enabled);
      
      virtual void local_setDiGuyMaxDrawDistance(float distance);
      
      virtual void local_setDiGuyMultiThreadUpdate(bool enabled);

      virtual void local_setPagedLodMagnificationHighLodAngle(float val);

   protected:

      DtDe& myDe;
      DtDeSharedStateProctor* myIgSharedStateProctor;
      DtModelDefinitionManager* myModelDefinitionManager;
      DtModelSetRealizationManager* myModelSetRealizationManager;
      DtCoordinateSystem* myCoordinateSystem;
      DtDeTimeManager myTimeManager;

      bool myWireframeMode;
      bool myTerrainScalingEnabled;
      double myTerrainScaleFactor;
      bool myUseAutofocus;
      double myFocalDepth;
      double myFocalRange;
      float myPagedLodMagnificationHighLodAngle;
      float myGlobalAmbientValue;
      bool myUseGlobalAmbient;
      float myGlobalDiffuseValue;
      bool myUseGlobalDiffuse;
      bool myClearTrackHistoryOnTerrainScaleChanged;
      float myPlanViewGeocentricOccludedTransparency;
      bool myShadowMode;
      bool myPerPixelLightingEnabled;
      bool myOceanPlanarReflectionsEnabled;
      float myOceanPlanarReflectionsLODScale;
      bool myOceanPlanarReflectionsSpecifyFarClip;
      double myOceanPlanarReflectionsFarClip;
      bool myLensFlareEnabled;
      bool myCrepuscularRaysEnabled;
      bool myWaveSprayEffectEnabled;
      bool myRotorWashDecalEnabled;
      bool myTidalStreamWakesEnabled;
      double myOceanHeightMapResolution;
      double myStaticOceanLodRange;
      bool myAutoSave;
      int myComponentVizualizationMode;
      double myRegenerateCubeMapThreshold;
      double myRegenerateHeightMapPercThreshold;
      bool myOmitCloudInCubeMap;
      int myOceanHeightMapTextureSize;
      int myPlanarReflectionTextureWidth;
      int myPlanarReflectionTextureHeight;

      float myLightingEmissionScale;
      float myLightingDiffuseScale;
      float myLightingAmbientScale;

      bool myIntersectorDrawEnabled;
      float myIntersectorDrawnDuration;
      DtColorValue myFailedIntersectorColor;
      DtColorValue myOddSegmentIntersectorColor;
      DtColorValue myEvenSegmentIntersectorColor;

      bool myDiGuyInstancingEnabled;
      int myDiGuyInstancedLod;
      bool myDiGuyVisualizeInstancing;
      float myDiGuyMaxDrawDistance;
      bool myDiGuyMultiThreadUpdate;
   };

   class DT_DLL_VRVCORE DtDeSharedStateCreator : public DtVirtualBaseClass
   {

   public:

      static DtDeSharedStateCreator& instance(DtDe&);

      static void registerInstance(DtDe& de, DtDeSharedStateCreator*);

      virtual DtDeSharedState* create(DtDe& de);

   };

}