DtDeSharedState.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeTimeManager.h>
#include <vrvMath/DtColorValue.h>
#include <vrvMath/DtVector2.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/signalslib.h>

namespace makVrv
{

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

   class DtModelDefinition;
   class DtLightPointManager;
   class DtSharedSettingsManager;
   class DtDeRecord;
   class DtMessageClient;
   enum class DtModelSetId;

   class DT_DLL_VRVCORE DtDeSharedState
   {

   public:

      friend class DtDeSharedStateCreator;

      friend class DtDeSharedStateProctor;

      virtual ~DtDeSharedState();

      DtDeSharedState() = delete;

      DtDeSharedState(const DtDeSharedState&) = delete;

      DtDeSharedState& operator=(const DtDeSharedState&) = delete;

      virtual void initialize();



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

      virtual const DtModelSetRealizationManager& modelSetRealizationManager() const;
      virtual DtModelSetRealizationManager& modelSetRealizationManager();

      virtual void setVisualizeModelSet( DtModelSetId 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 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 setPerformanceOverlayState(unsigned int state);
      virtual unsigned int performanceOverlayState() const;

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

      virtual void setImguiOverlayOn(bool enabled);
      virtual bool imguiOverlayOn() const;

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

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

      virtual bool dofUseAutofocus() const;
      virtual void setDofUseAutofocus(bool useAutofocus);

      virtual double dofFocalDepth() const;
      virtual void setDofFocalDepth(double focalDepth);

      virtual double dofFocalRange() const;
      virtual void setDofFocalRange(double focalRange);

      // size of the water on screen effect(Rain Splash/Ocean Spray/Wave Splash) in percentage, default is 100(%)
      virtual double waterOnScreenSize() const;
      virtual void setWaterOnScreenSize(double size);
      
      virtual float hbaoRadius() const;
      virtual void setHbaoRadius(float value);

      virtual float hbaoBias() const;
      virtual void setHbaoBias(float value);

      virtual float hbaoExponent() const;
      virtual void setHbaoExponent(float value);

      virtual float hbaoSmallScalar() const;
      virtual void setHbaoSmallScalar(float value);

      virtual float hbaoLargeScalar() const;
      virtual void setHbaoLargeScalar(float value);

      virtual int hbaoDepthClampMode() const;
      virtual void setHbaoDepthClampMode(int mode);


      virtual float indirectLodTransitionPercentage() const;
      virtual void setIndirectLodTransitionPercentage(float val);

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

      virtual bool colorizePerDrawableEnabled() const;
      virtual void setColorizePerDrawableEnabled(bool flag);
      
      virtual bool atcGlobalModelEnable() const;
      virtual void setAtcGlobalModelEnable(bool flag);

      virtual bool atcGlobalTerrainEnable() const;
      virtual void setAtcGlobalTerrainEnable(bool flag);

      virtual bool atcEnableDither() const;
      virtual void setAtcEnableDither(bool flag);

      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 setShadowsEnabled(bool shadowMode);
      virtual bool shadowsEnabled() const;

      virtual void setApplyShadowToAmbientLighting(bool applyShadowToAmbient);
      virtual bool applyShadowToAmbientLighting() const;

      virtual void setShadowsEnabledOnOcean(bool shadowMode);
      virtual bool shadowsEnabledOnOcean() const;

      virtual void setSimulationTimeIsPaused(bool setting);
      virtual bool simulationTimeIsPaused() const;

      virtual void setWheelRotationEnabled(bool setting);
      virtual bool wheelRotationEnabled() const;

      virtual void setAdaptiveTickRateEnabled(bool setting);
      virtual bool adaptiveTickRateEnabled() const;

      virtual void setPaperMapEnabled(bool setting);
      virtual bool paperMapEnabled() const;

      virtual void setPaperMapLayerTimeout(double val);
      virtual double paperMapLayerTimeout() const;

      virtual void setPaperMapGroup(std::string group);
      virtual std::string paperMapGroup() const;

      virtual bool paperMapIntersectionOverride() const;
      virtual void setPaperMapIntersectionOverride(bool setting);

      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 bool artPartSmoothingEnabled() const;

      virtual void setArtPartSmoothingEnabled(bool setting);

      virtual float artPartSmoothingPeriod() const;

      virtual void setArtPartSmoothingPeriod(float period);
      
      virtual void loadEntityDisplaySettings(const std::string& filepath);
      virtual void saveEntityDisplaySettings(const std::string& filepath);
      virtual void loadDefaultEntityDisplaySettings(bool useOnlyFactorySettings);
      virtual void saveDefaultEntityDisplaySettings();
      virtual void updateEntityDisplayState();



      virtual void setDdsFlip(bool state);
      virtual bool ddsFlip() const;
      
      virtual void setIndirectBufferUpdateTimeBudget( int milliseconds );
      virtual int indirectBufferUpdateTimeBudget() const;
      
      virtual void setCdbParallelForThreadCount( int threadCount );
      virtual int cdbParallelForThreadCount() 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 bool planarReflectionsShowSpeedTrees() const;
      virtual void setPlanarReflectionsShowSpeedTrees(bool flag);

      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 unsigned int oceanQuality() const;
      virtual void setOceanQuality(unsigned int quality);

      virtual unsigned int oceanSpectralModel() const;
      virtual void setOceanSpectralModel(unsigned int model);

      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 setTerrainMagnificationScaleFactor(float scale);
      virtual float terrainMagnificationScaleFactor() const;

      virtual void setTerrainMagnificationHighLodAngle(float radians);
      virtual float terrainMagnificationHighLodAngle() const;
      virtual void setMetaflightPagingDistScale(float dist);
      virtual float metaflightPagingDistScale() const;
      virtual void setMetaflightPagingDistScaleEnabled(bool enabled);
      virtual bool metaflightPagingDistScaleEnabled() const;
      virtual void setIndirectDistScale(float scale);
      virtual float indirectDistScale() const;
      virtual void setIndirectDistScaleEnabled(bool enabled);
      virtual bool indirectDistScaleEnabled() 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 bool diGuyTextureVariationsEnabled() const;
      virtual void setDiGuyTextureVariationsEnabled(bool enabled);

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

      virtual const float diGuyMaxMotionUpdateDistance() const;
      virtual void setDiGuyMaxMotionUpdateDistance(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 bool enableHdr() const;
      virtual void setEnableHdr(bool enabled);

      virtual bool enableHdrAutoExposure() const;
      virtual void setEnableHdrAutoExposure(bool enabled);

      virtual bool enableHdrExposureCorrelation() const;
      virtual void setEnableHdrExposureCorrelation(bool enabled);

      virtual bool enableHdrBloom() const;
      virtual void setEnableHdrBloom(bool enabled);

      virtual bool enableHdrStreaks() const;
      virtual void setEnableHdrStreaks(bool enabled);

      virtual bool enableHdrLensFlare() const;
      virtual void setEnableHdrLensFlare(bool enabled);

      virtual void setLightPointScale(double val);
      virtual double lightPointScale() const;

      virtual void setDynamicLightScale(double val);
      virtual double dynamicLightScale() const;

      virtual void setEmissiveTextureScale(double val);
      virtual double emissiveTextureScale() const;

      virtual void setSpecularScale(double val);
      virtual double specularScale() const;

      virtual void setShininessScale(double val);
      virtual double shininessScale() const;

      virtual void setAutoExposureRateScale(double val);
      virtual double autoExposureRateScale() const;

      virtual void setAutoExposurePreScale(double val);
      virtual double autoExposurePreScale() const;

      virtual void setAutoExposureMinDiff(double val);
      virtual double autoExposureMinDiff() const;

      virtual void setAutoExposureMaxDiff(double val);
      virtual double autoExposureMaxDiff() const;

      virtual void setAutoExposureClampMin(double val);
      virtual double autoExposureClampMin() const;

      virtual void setAutoExposureClampMax(double val);
      virtual double autoExposureClampMax() const;

      virtual void setAutoExposurePostScale(double val);
      virtual double autoExposurePostScale() const;

      virtual void setBloomScale(double val);
      virtual double bloomScale() const;

      virtual void setStreakIntensityScale(double val);
      virtual double streakIntensityScale() const;

      virtual void setNumStreaks(int val);
      virtual int numStreaks() const;

      virtual void setStreaksLenScale(double val);
      virtual double streaksLenScale() const;

      virtual void setStreakRotationOffset(double val);
      virtual double streakRotationOffset() const;

      virtual void setLensFlareScale(double val);
      virtual double lensFlareScale() const;

      virtual void setGamma(double val);
      virtual double gamma() const;

      virtual void setHdrResolutionScale(int val);
      virtual int hdrResolutionScale() const;

      virtual void setLightPointGroupColor(const std::string& groupName, DtColorValue color, bool createGroupIfNonexistent);
      virtual DtColorValue lightPointGroupColor(const std::string& groupName);

      //this is not saved out but is a part of how the HDR post processor works
      // scale for the tonemapping, shared so slaves match master intensity
      virtual void setHdrOutputScale(double val);
      virtual double hdrOutputScale() const;

      virtual void loadPostProcessorSettings(const std::string& filepath);
      virtual void savePostProcessorSettings(const std::string& filepath);
      virtual void loadDefaultPostProcessorSettings(bool useOnlyFactorySettings);
      virtual void saveDefaultPostProcessorSettings();
      virtual void updatePostProcessorState();

      virtual void setLimitEntityTextures(const DtVector2<int>& resolution);
      virtual const DtVector2<int>& limitEntityTextures(void) const;


      virtual void excludeFromTextureLimits(const std::string& modelDef);
      virtual const std::unordered_set<std::string> modelDefsExcludedFromTextureLimits(void);

      virtual void setLimitEntityTexturesProportional(bool proportional);
      virtual bool limitEntityTexturesProportional(void) const;

      virtual void setLimitTerrainTextures(const DtVector2<int>& resolution);
      virtual const DtVector2<int>& limitTerrainTextures() const;


      virtual void setLimitEarthTerrainTextures(int resolution);
      virtual int limitEarthTerrainTextures() const;


      virtual void setLimitEarthSplattingTextures(int resolution);
      virtual int limitEarthSplattingTextures() const;

      virtual void setLimitEarthVegetationTextures(int resolution);
      virtual int limitEarthVegetationTextures() const;

      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 sendLightPointGroupsToSlave(DtMessageClient* messageClient);

      virtual void local_setLightPointGroupColor(const std::string& groupName, const DtColorValue& color, bool createGroupIfNonexistent);



      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_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_setShadowsEnabled(bool enable);

      virtual void local_setShadowsEnabledOnOcean(bool enable);

      virtual void local_ddsFlipState(bool flip);

      virtual void local_setIndirectBufferUpdateTimeBudget( int milliseconds );

      virtual void local_setCdbParallelForThreadCount( int threadCount );

      virtual void local_setVisualizeModelSet(DtModelSetId 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_setPlanarReflectionsShowSpeedTrees(bool flag);

      virtual void local_setStaticOceanLodRange(double range);

      virtual void local_setCrepuscularRaysEnabled(bool mode);

      virtual void local_setColorizePerDrawableEnabled(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 slot_dateChanged();



      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_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_setOceanQuality(unsigned int setting);

      virtual void local_setOceanSpectralModel(unsigned int setting);

      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_setDiGuyTextureVariationsEnabled(bool enabled);

      virtual void local_setDiGuyMaxDrawDistance(float distance);

      virtual void local_setDiGuyMaxMotionUpdateDistance(float distance);
      
      virtual void local_setDiGuyMultiThreadUpdate(bool enabled);

      virtual void local_setTerrainMagnificationHighLodAngle(float radians);

      virtual void local_setTerrainMagnificationScaleFactor(float scale);

      virtual void local_setSimulationTimeIsPaused(bool val);

      virtual void local_setMetaflightPagingDistScale(float dist);

      virtual void local_setMetaflightPagingDistScaleEnabled(bool enabled);

      virtual void local_setIndirectDistScale(float scale);

      virtual void local_setIndirectDistScaleEnabled(bool enabled);

      virtual void local_setDofUseAutofocus(bool useAutofocus);

      virtual void local_setDofFocalDepth(double focalDepth);

      virtual void local_setDofFocalRange(double focalRange);

      // size of the water on screen effect(Rain Splash/Ocean Spray/Wave Splash) in percentage, default is 100(%)
      virtual void local_setWaterOnScreenSize(double size);

      virtual void local_setHbaoRadius(float value);
      virtual void local_setHbaoBias(float value);
      virtual void local_setHbaoExponent(float value);
      virtual void local_setHbaoSmallScalar(float value);
      virtual void local_setHbaoLargeScalar(float value);
      virtual void local_setHbaoDepthClampMode(int mode);

      virtual void local_setIndirectLodTransitionPercentage(float val);

      virtual void local_setWheelRotationEnabled(bool enabled);

      virtual void local_setAdaptiveTickRateEnabled(bool enabled);

      virtual void local_setArtPartSmoothingEnabled(bool setting);

      virtual void local_setArtPartSmoothingPeriod(float period);

      virtual void local_setEnableHdr(bool enabled);
      virtual void local_setEnableHdrAutoExposure(bool enabled);
      virtual void local_setEnableHdrExposureCorrelation(bool enabled);
      virtual void local_setEnableHdrBloom(bool enabled);
      virtual void local_setEnableHdrStreaks(bool enabled);
      virtual void local_setEnableHdrLensFlare(bool enabled);


      virtual void local_setLightPointScale(double val);
      virtual void local_setDynamicLightScale(double val);
      virtual void local_setEmissiveTextureScale(double val);
      virtual void local_setSpecularScale(double val);
      virtual void local_setShininessScale(double val);
      virtual void local_setAutoExposureRateScale(double val);
      virtual void local_setAutoExposurePreScale(double val);
      virtual void local_setAutoExposureMinDiff(double val);
      virtual void local_setAutoExposureMaxDiff(double val);
      virtual void local_setAutoExposureClampMin(double val);
      virtual void local_setAutoExposureClampMax(double val);
      virtual void local_setAutoExposurePostScale(double val);
      virtual void local_setBloomScale(double val);
      virtual void local_setStreakIntensityScale(double val);
      virtual void local_setNumStreaks(int val);
      virtual void local_setStreaksLenScale(double val);
      virtual void local_setStreakRotationOffset(double val);
      virtual void local_setLensFlareScale(double val);
      virtual void local_setGamma(double val);
      virtual void local_setHdrResolutionScale(int val);

      virtual void local_setHdrOutputScale(double val);

      virtual void local_setAtcEnableDither(bool flag);
      virtual void local_setAtcGlobalTerrainEnable(bool flag);
      virtual void local_setAtcGlobalModelEnable(bool flag);

      virtual void local_setPaperMapEnabled(bool enabled);

      virtual void local_setPaperMapLayerTimeout(double val);

      virtual void local_setPaperMapGroup(std::string group);

      virtual void local_setPaperMapIntersectionOverride(bool enabled);

      virtual void local_setLimitEntityTextures(const DtVector2<int>& resolution);

      virtual void local_setLimitTerrainTextures(const DtVector2<int>& resolution);

      virtual void local_setLimitEntityTexturesProportional(bool val);

      virtual void local_excludeModelDefFromTextureLimits(const std::string& modelDef);

      virtual void local_setApplyShadowToAmbientLighting(bool val);

      virtual void local_setLimitEarthTerrainTextures(int resolution);

      virtual void local_setLimitEarthSplattingTextures(int resolution);

      virtual void local_setLimitEarthVegetationTextures(int resolution);

      virtual void local_setComponentVisualizationMode(int val);

   protected:

      DtDe& myDe;
      DtDeSharedStateProctor* myIgSharedStateProctor;
      DtModelDefinitionManager* myModelDefinitionManager;
      DtModelSetRealizationManager* myModelSetRealizationManager;
      DtCoordinateSystem* myCoordinateSystem;
      DtDeTimeManager* myTimeManager;
      DtLightPointManager* myLightPointManger;
      DtSharedSettingsManager* mySharedSettingsManager;

      bool myWireframeMode;
      bool myTerrainScalingEnabled;
      double myTerrainScaleFactor;
      float myTerrainMagnificationHighLodAngle;
      float myTerrainMagnificationScaleFactor;
      float myGlobalAmbientValue;
      bool myUseGlobalAmbient;
      float myGlobalDiffuseValue;
      bool myUseGlobalDiffuse;
      bool myClearTrackHistoryOnTerrainScaleChanged;
      float myPlanViewGeocentricOccludedTransparency;
      bool myShadowsEnabled;
      bool myShadowsEnabledOnOcean;
      bool myPerPixelLightingEnabled;
      bool myOceanPlanarReflectionsEnabled;
      float myOceanPlanarReflectionsLODScale;
      bool myOceanPlanarReflectionsSpecifyFarClip;
      double myOceanPlanarReflectionsFarClip;
      bool myCrepuscularRaysEnabled;
      bool myWaveSprayEffectEnabled;
      bool myRotorWashDecalEnabled;
      bool myTidalStreamWakesEnabled;
      double myOceanHeightMapResolution;
      double myStaticOceanLodRange;
      bool myAutoSave;
      bool myColorizeDrawablesEnabled;
      int myComponentVizualizationMode;
      double myRegenerateCubeMapThreshold;
      double myRegenerateHeightMapPercThreshold;
      bool myOmitCloudInCubeMap;
      int myOceanHeightMapTextureSize;
      int myPlanarReflectionTextureWidth;
      int myPlanarReflectionTextureHeight;
      unsigned int myOceanQuality;
      unsigned int myOceanSpectralModel;

      bool myPlanarReflectionsShowSpeedTrees;

      bool myAtcGlobalModelEnable;
      bool myAtcGlobalTerrainEnable;
      bool myAtcEnableDither;

      float myLightingEmissionScale;
      float myLightingDiffuseScale;
      float myLightingAmbientScale;

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

      bool myDiGuyInstancingEnabled;
      int myDiGuyInstancedLod;
      bool myDiGuyVisualizeInstancing;
      bool myDiGuyTextureVariationsEnabled;
      float myDiGuyMaxDrawDistance;
      float myDiGuyMaxMotionUpdateDistance;
      bool myDiGuyMultiThreadUpdate;
      bool myDofUseAutofocus;
      double myDofFocalDepth;
      double myDofFocalRange;
      double myWaterOnScreenSize;
      float myIndirectLodTransitionPercentage;
      bool myEnableHdr;
      bool myEnableHdrAutoExposure;
      bool myEnableHdrExposureCorrelation;
      bool myEnableHdrBloom;
      bool myEnableHdrStreaks;
      bool myEnableHdrLensFlare;

      double myLightPointScale;
      double myDynamicLightScale;
      double myEmissiveTextureScale;
      double mySpecularScale;
      double myShininessScale;
      double myAutoExposureRateScale;
      double myAutoExposurePreScale;
      double myAutoExposureMinDiff;
      double myAutoExposureMaxDiff;
      double myAutoExposureClampMin;
      double myAutoExposureClampMax;
      double myAutoExposurePostScale;
      double myBloomScale;
      double myStreakIntensityScale;
      int myNumStreaks;
      double myStreaksLenScale;
      double myStreakRotationOffset;
      double myLensFlareScale;
      double myGamma;
      int myHdrResolutionScale;

      double myHdrOutputScale;

      bool mySimulationTimeIsPaused;
      float myInstancingCullDistance;
      bool myInstancingCullDistEnabled;
      float myMetaflightPagingDistScale;
      bool myMetaflightPagingDistScaleEnabled;
      float myIndirectDistScale;
      bool myIndirectDistScaleEnabled;
      bool myWheelRotationEnabled;
      bool myAdaptiveTickRateEnabled;
      bool myArtPartSmoothingEnabled;
      float myArtPartSmoothingPeriod;
      bool myPaperMapEnabled;
      double myPaperMapLayerTimeout;
      std::string myPaperMapGroup;
      bool myPaperMapIntersectionOverride;

      float myHbaoRadius;
      float myHbaoBias;
      float myHbaoExponent;
      float myHbaoSmallScalar;
      float myHbaoLargeScalar;
      int myHbaoDepthClampMode;

      DtVector2<int> myLimitEntityTexturesResolution;

      bool myLimitEntityTexturesProportional;

      DtVector2<int> myLimitTerrainTexturesResolution;

      std::unordered_set<std::string> myModelDefsExcludedFromTextureLimits;

      bool myApplyShadowToAmbientLighting;

      int myLimitEarthTerrainTextures = -1;
      int myLimitEarthSplattingTextures = -1;
      int myLimitEarthVegetationTextures = -1;

      DtSignalConnectionManager myConnections;
   };

   class DT_DLL_VRVCORE DtDeSharedStateCreator : public DtVirtualBaseClass
   {

   public:

      static DtDeSharedStateCreator& instance(DtDe&);

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

      virtual DtDeSharedState* create(DtDe& de);

   };

}