DtRenderSettingsRecord.h

Go to the documentation of this file.

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


#pragma once
#include <makArchives/makArchives.h>

namespace makArchives
{
   class DT_DLL_MAKARCHIVES DtRenderSettingsRecord
   {
   public:

      DtRenderSettingsRecord();

      DtRenderSettingsRecord(const DtRenderSettingsRecord& orig);

      ~DtRenderSettingsRecord();

      DtRenderSettingsRecord& operator=(DtRenderSettingsRecord rhs);

      void swap(DtRenderSettingsRecord& other);

      bool wireframeMode() const;
      void setWireframeMode(bool setting);

      bool shadowMode() const;
      void setShadowMode(bool setting);

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

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

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

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

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

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

      double waterOnScreenSize() const;
      void   setWaterOnScreenSize(double value);

      float indirectLodTransitionPercentage() const;
      void   setIndirectLodTransitionPercentage(float value);

      unsigned int performanceOverlayState() const;
      void setPerformanceOverlayState(unsigned int state);

      bool imguiOverlayEnabled() const;
      void setImguiOverlayEnabled(bool setting);

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

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

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

      bool colorizePerDrawableEnabled() const;
      void setColorizePerDrawableEnabled(bool setting);

      bool occlusionCullingEnabled() const;
      void setOcclusionCullingEnabled(bool setting);

      float terrainMagnificationHighLodAngle() const;
      void setTerrainMagnificationHighLodAngle(float radians);

      bool atcGlobalModelEnable() const;
      void setAtcGlobalModelEnable(bool setting);
      bool atcGlobalTerrainEnable() const;
      void setAtcGlobalTerrainEnable(bool setting);
      bool atcEnableDither() const;
      void setAtcEnableDither(bool setting);
      bool wheelRotationEnable() const;
      void setWheelRotationEnable(bool setting);

      bool artPartSmoothingEnabled() const;
      void setArtPartSmoothingEnabled(bool setting);

      float artPartSmoothingPeriod() const;
      void setArtPartSmoothingPeriod(float period);

   protected:

      friend class boost::serialization::access;

      template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myWireframeMode);

         if (version <= 38)
         {
            ar & BOOST_SERIALIZATION_NVP(myShadowMode);
            ar & BOOST_SERIALIZATION_NVP(myShadowQuality);
            ar & BOOST_SERIALIZATION_NVP(myEntityShadowMode);
            ar & BOOST_SERIALIZATION_NVP(myPropShadowMode);
            ar & BOOST_SERIALIZATION_NVP(myTerrainShadowMode);
         }

         if (version >= 1 && version <= 43)
         {
            ar & BOOST_SERIALIZATION_NVP(myPerformanceOverlayEnabled);
         }
         else if (version > 43)
         {
            ar& BOOST_SERIALIZATION_NVP(myPerformanceOverlayState);
         }

         if (version == 2)
         {
            // DDS Flip is no longer part of render settings.
            bool flip;
            ar & BOOST_SERIALIZATION_NVP(flip);
         }

         if (version >= 4)
         {
            ar & BOOST_SERIALIZATION_NVP(myPlanViewGeocentricOccludedTransparency);
         }
         if (version >= 5)
         {
            ar & BOOST_SERIALIZATION_NVP(myTerrainScalingEnabled);
            ar & BOOST_SERIALIZATION_NVP(myTerrainScaleFactor);
            ar & BOOST_SERIALIZATION_NVP(myClearTrackHistoryOnTerrainScaleChanged);
         }
         if (version >= 7 && version <= 29)
         {
            ar & BOOST_SERIALIZATION_NVP(myPerPixelLightingEnabled);
         }
         if (version >= 8 && version <= 27)
         {
            ar & BOOST_SERIALIZATION_NVP(myOceanPlanarReflectionsEnabled);
         }
         if (version >= 9 && version <= 27)
         {
            ar & BOOST_SERIALIZATION_NVP(myStaticOceanLodRange);
         }
         if (version <= 32)
         {
            ar & BOOST_SERIALIZATION_NVP(myLensFlareEnabled);
         }
         if (version >= 10)
         {
            ar & BOOST_SERIALIZATION_NVP(myCrepuscularRaysEnabled);
         }
         if (version >= 11 && version < 18)
         {
            ar & BOOST_SERIALIZATION_NVP(myRainSplashEffectEnabled);
            ar & BOOST_SERIALIZATION_NVP(myWaveSplashEffectEnabled);
         }
         if (version >= 12 && version <= 27)
         {
            if (version < 18)
            {
               ar & BOOST_SERIALIZATION_NVP(myOceanSprayEffectEnabled);
            }
            ar & BOOST_SERIALIZATION_NVP(myOceanHeightMapResolution);
         }
         if (version >= 13)
         {
            ar & BOOST_SERIALIZATION_NVP(myUsePixelShaderForOsgEarthModels);
         }
         if (version >= 14)
         {
            ar & BOOST_SERIALIZATION_NVP(myMaximumDynamicLights);
         }
         if (version >= 15 && version <= 27)
         {
            ar & BOOST_SERIALIZATION_NVP(myOceanPlanarReflectionsLODScale);
            ar & BOOST_SERIALIZATION_NVP(myOceanPlanarReflectionsSpecifyFarClip);
            ar & BOOST_SERIALIZATION_NVP(myOceanPlanarReflectionsFarClip);
         }
         if (version >= 16 && version <= 27)
         {
            ar & BOOST_SERIALIZATION_NVP(myWaveSprayEffectEnabled);
            ar & BOOST_SERIALIZATION_NVP(myRotorWashDecalEnabled);
         }
         if (version >= 17)
         {
            ar & BOOST_SERIALIZATION_NVP(myInstancedRenderingEnabled); // NOT USED
         }
         // version 18 only removed items...
         if (version >= 19 && version <= 28)
         {
            ar & BOOST_SERIALIZATION_NVP(myAmbientFactor);
         }
         if (version >= 20 && version <= 28)
         {
            ar & BOOST_SERIALIZATION_NVP(myUseMaterialAmbient);
         }
         if (version >= 21)
         {
            ar & BOOST_SERIALIZATION_NVP(myUseAutofocus);
            ar & BOOST_SERIALIZATION_NVP(myFocalRange);
            ar & BOOST_SERIALIZATION_NVP(myFocalDepth);
         }
         if (version >= 22 && version <= 28)
         {
            ar & BOOST_SERIALIZATION_NVP(myDiffuseScaleFactor);
            ar & BOOST_SERIALIZATION_NVP(myUseMaterialDiffuse);
         }
         if (version >= 23 && version <= 42) //Profiler overlay enabled is no longer saved out
         {
            ar & BOOST_SERIALIZATION_NVP(myProfilerOverlayEnabled);
         }
         if (version >= 24 && version <= 27)
         {
            ar & BOOST_SERIALIZATION_NVP(myTidalStreamWakesEnabled);
         }
         if (version >= 25 && version <= 27)
         {
            ar & BOOST_SERIALIZATION_NVP(myRegenerateCubeMapThreshold);
            ar & BOOST_SERIALIZATION_NVP(myRegenerateHeightMapPercThreshold);
            ar & BOOST_SERIALIZATION_NVP(myOmitCloudInCubeMap);
         }
         if (version >= 26 && version <= 27)
         {
            ar & BOOST_SERIALIZATION_NVP(myOceanHeightMapTextureSize);
         }
         if (version >= 27 && version <= 28)
         {
            ar & BOOST_SERIALIZATION_NVP(myDiffuseFactor);
            ar & BOOST_SERIALIZATION_NVP(myAmbientScaleFactor);
         }
         if (version >= 31)
         {
            if (version < 42)
            {
               ar & BOOST_SERIALIZATION_NVP(myPagedLodMagnificationHighLodAngle);
            }
            ar & BOOST_SERIALIZATION_NVP(myWaterOnScreenSize);
         }
         if (version >= 34)
         {
            ar & BOOST_SERIALIZATION_NVP(myAtcGlobalModelEnable);
            ar & BOOST_SERIALIZATION_NVP(myAtcGlobalTerrainEnable);
            ar & BOOST_SERIALIZATION_NVP(myAtcEnableDither);
         }
         if (version >= 35)
         {
            ar & BOOST_SERIALIZATION_NVP(myImguiOverlayEnabled);
         }
         if (version >= 36)
         {
            ar & BOOST_SERIALIZATION_NVP(myOcclusionCullingEnabled);
         }
         if (version >= 37)
         {
            ar & BOOST_SERIALIZATION_NVP(myIndirectLodTransitionPercentage);
         }
         if (version >= 38 && version <= 43)
         {
             ar & BOOST_SERIALIZATION_NVP(myWheelRotationEnabled);
         }
         if (version >= 40 && version <= 43)
         {
            ar & BOOST_SERIALIZATION_NVP(myArtPartSmoothingEnabled);
            ar & BOOST_SERIALIZATION_NVP(myArtPartSmoothingPeriod);
         }
         if (version >= 41)
         {
            ar & BOOST_SERIALIZATION_NVP(myShadowMode);
         }
         if (version >= 42)
         {
            ar & BOOST_SERIALIZATION_NVP(myTerrainMagnificationHighLodAngle);
         }
         if (version >= 44)
         {
            ar & BOOST_SERIALIZATION_NVP(myColorizePerDrawableEnabled);
         }
      }

   protected:
      int myShadowQuality;
      bool myEntityShadowMode;
      bool myPropShadowMode;
      bool myTerrainShadowMode;
      unsigned int myMaximumDynamicLights;
      bool myUsePixelShaderForOsgEarthModels;
      bool myWireframeMode;
      bool myShadowMode;
      bool myPerformanceOverlayEnabled; // no longer used. Use state instead
      unsigned int myPerformanceOverlayState;
      bool myProfilerOverlayEnabled;
      bool myImguiOverlayEnabled;
      float myPlanViewGeocentricOccludedTransparency;
      bool myTerrainScalingEnabled;
      double myTerrainScaleFactor;
      bool myClearTrackHistoryOnTerrainScaleChanged;
      bool myUseAutofocus;
      // Focal depth = the distance to the point in focus
      double myFocalDepth;
      // Focal range = depth of field = distance to focal point +/- focal range is in focus
      double myFocalRange;
      double myWaterOnScreenSize;

      float myIndirectLodTransitionPercentage;

      // for back compatibility
      float myPagedLodMagnificationHighLodAngle;

      // replaces myPagedLodMagnificationHighLodAngle in version 42
      float myTerrainMagnificationHighLodAngle;

      double myAmbientFactor;
      double myAmbientScaleFactor;
      bool myUseMaterialAmbient;

      double myDiffuseFactor;
      double myDiffuseScaleFactor;
      bool myUseMaterialDiffuse;

      bool myPerPixelLightingEnabled;
      bool myOceanPlanarReflectionsEnabled;
      float myOceanPlanarReflectionsLODScale;
      bool myOceanPlanarReflectionsSpecifyFarClip;
      double myOceanPlanarReflectionsFarClip;
      double myStaticOceanLodRange;
      bool myLensFlareEnabled;
      bool myCrepuscularRaysEnabled;
      bool myColorizePerDrawableEnabled;
      bool myOcclusionCullingEnabled;
      bool myWaveSprayEffectEnabled;
      bool myRotorWashDecalEnabled;
      bool myRainSplashEffectEnabled;
      bool myWaveSplashEffectEnabled;
      bool myOceanSprayEffectEnabled;
      double myOceanHeightMapResolution;
      bool myInstancedRenderingEnabled;
      bool myTidalStreamWakesEnabled;
      double myRegenerateCubeMapThreshold;
      double myRegenerateHeightMapPercThreshold;
      bool myOmitCloudInCubeMap;
      int myOceanHeightMapTextureSize;
      bool myAtcGlobalModelEnable;
      bool myAtcGlobalTerrainEnable;
      bool myAtcEnableDither;
      bool myWheelRotationEnabled; // As of v. 44, moved to DtEntitySettingsRecord 
      bool myArtPartSmoothingEnabled; // As of v. 44, moved to DtEntitySettingsRecord 
      float myArtPartSmoothingPeriod; // As of v. 44, moved to DtEntitySettingsRecord 
   };
}


BOOST_CLASS_VERSION(makArchives::DtRenderSettingsRecord, 44)