DtShadowSettingsRecord.h

Go to the documentation of this file.

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


#pragma once

#include <makArchives/makArchives.h>
#include <makArchives/DtSerialize.h>
#include <makArchives/UnicodeStringRecord.h>

#include <string>
#include <map>
#include <vector>



namespace makArchives
{

   class DT_DLL_MAKARCHIVES DtShadowSettingsRecord
   {
   public:
      enum ShadowStabilizationScheme
      {
         NO_ANTI_FLICKERING,
         EXACT_ANTI_FLICKERING,
         APPROXIMATE_ANTI_FLICKERING,
      };

      enum SplitDistanceComputeScheme
      {
         LOGARITHMIC_SPLIT,
         UNIFORM_SPLIT,
         MIXED_LOGARITHMIC_UNIFORM_SPLIT
      };

      enum SplitSelectionScheme
      {
         EYE_SPACE,
         LIGHT_SPACE
      };

      enum DataStorageScheme
      {
         TEXTURE_2D_STORAGE,
         TEXTURE_2D_ATLAS_STORAGE,
         TEXTURE_2D_ARRAY_STORAGE
      };

      enum PreFilteringScheme
      {
         NO_PRE_FILTERING,
         EXPONENTIAL_VARIANCE_SHADOW_MAPS,
         EXPONENTIAL_SHADOW_MAPS,
         VARIANCE_SHADOW_MAPS
      };


      enum FilteringScheme
      {
         NO_FILTERING,
         PCF_POISSON_DISC_4_TAPS,
         PCF_POISSON_DISC_8_TAPS,
         PCF_POISSON_DISC_16_TAPS,
         PCF_POISSON_DISC_24_TAPS,
         PCF_POISSON_DISC_32_TAPS
      };

      enum PoissonDiskSamplingScheme
      {
         UNIFORM_SAMPLING,
         STRATIFIED_SAMPLING,
         ROTATED_SAMPLING
      };

      DtShadowSettingsRecord();

      DtShadowSettingsRecord(const DtShadowSettingsRecord& orig);

      ~DtShadowSettingsRecord();

      DtShadowSettingsRecord& operator=(const DtShadowSettingsRecord& orig);

      void setName(const std::string& name);

      const std::string& name() const { return myName; }

      void setDirty(bool dirty);

      bool dirty() const { return myDirty; }

      void setShadowsEnabled(bool shadowsEnabled);

      bool shadowsEnabled() const { return myShadowsEnabled; }

      void setShadowsEnabledOnOcean(bool shadowsEnabled);

      bool shadowsEnabledOnOcean() const;

      void setEntitiesCastsShadows(bool castShadows);

      bool entitiesCastsShadows() const { return myEntitiesCastsShadows; }

      void setPropsCastsShadows(bool castShadows);

      bool propsCastsShadows() const { return myPropsCastsShadows; }

      void setTerrainCastsShadows(bool castShadows);

      bool terrainCastsShadows() const { return myTerrainCastsShadows; }

      void setMoonCastsShadows(bool castShadows);

      bool moonCastsShadows() const { return myMoonCastsShadows; }

      void setVisualizeShadows(bool visualizeShadows);

      bool visualizeShadows() const { return myVisualizeShadows; }

      void setNumberOfSplits(unsigned int numSplits);

      unsigned int numberOfSplits() const { return myNumSplits; }

      void setUseCachedFarCascade(bool useCachedFarCascade);

      bool useCachedFarCascade() const { return myUseCachedFarCascade; }

      void setFarCascadeUpdateFrequency(float value) { myFarCascadeUpdateFrequency = value; }

      float farCascadeUpdateFrequency() const { return myFarCascadeUpdateFrequency; }

      void setUseFrontFaceCulling(bool useFrontFaceCulling);

      bool useFrontFaceCulling() const { return myUseFrontFaceCulling; }

      void setUsePolygonOffset(bool usePolygonOffset);

      bool usePolygonOffset() const { return myUsePolygonOffset; }

      void setPolygonOffset(unsigned int splitIndex, float factor, float units);

      float polygonOffsetFactor(unsigned int splitIndex) const;

      float polygonOffsetUnits(unsigned int splitIndex) const;

      void setSpotLightShadowMapSize(unsigned int size);

      unsigned int spotLightShadowMapSize() const { return mySpotLightShadowMapSize; }

      void setGlobalLightShadowMapSize(unsigned int size);

      unsigned int globalLightShadowMapSize() const { return myGlobalLightShadowMapSize; }

      void setUseMaximumViewDistance(bool useMaximumViewDistance);

      bool useMaximumViewDistance() const { return myUseMaximumViewDistance; }

      void setMaximumViewDistance(double viewDistance);

      double maximumViewDistance() const { return myMaximumViewDistance; }


      void setShadowAmbientFactor(float shadowAmbientFactor);

      float shadowAmbientFactor() const { return myShadowAmbientFactor; }

      void setShadowStabilizationScheme(ShadowStabilizationScheme shadowStabilizationScheme);

      ShadowStabilizationScheme shadowStabilizationScheme() const { return myShadowStabilizationScheme; }

      void setSplitDistanceComputeScheme(SplitDistanceComputeScheme splitDistanceComputeScheme);

      SplitDistanceComputeScheme splitDistanceComputeScheme() const { return mySplitDistanceComputeScheme; }

      void setMixedSplitInterpolationValue(double interp);

      double mixedSplitInterpolationValue() const { return myMixedSplitInterp; }

      void setSplitSelectionScheme(SplitSelectionScheme splitSelectionScheme);

      SplitSelectionScheme splitSelectionScheme() const { return mySplitSelectionScheme; }

      void setPreFilteringScheme(PreFilteringScheme preFilteringScheme);

      PreFilteringScheme preFilteringScheme() const { return myPreFilteringScheme; }

      void setFilteringScheme(FilteringScheme filteringScheme);

      FilteringScheme filteringScheme() const { return myFilteringScheme; }

      void setPoissonDiskSamplingScheme(PoissonDiskSamplingScheme poissonDiskSamplingScheme);

      PoissonDiskSamplingScheme poissonDiskSamplingScheme() const { return myPoissonDiskSamplingScheme; }

      void setUseViewportMulticast(bool useViewportMulticast);

      bool useViewportMulticast() const { return myUseViewportMulticast; }

      void setNumPersistentPassesPerCascade(unsigned int numPasses);

      unsigned int numPersistentPassesPerCascade() const { return myNumPersistentPassesPerCascade; }

      void setNumAdditionalPassesPerCascade(unsigned int numPasses);

      unsigned int numAdditionalPassesPerCascade() const { return myNumAdditionalPassesPerCascade; }

      void setPcfFilterWidth(unsigned int pcfFilterWidth);

      unsigned int pcfFilterWidth() const { return myPcfFilterWidth; }

      void setBlendCascadesBoundaries(bool blendCascadesBoundaries);

      bool blendCascadesBoundaries() const { return myBlendCascadesBoundaries; }

      void setAdjustFarAndFlagsBasedOnHAT(bool enabled) { myAdjustFarAndFlagsBasedOnHAT = enabled; }

      bool adjustFarAndFlagsBasedOnHAT() const { return myAdjustFarAndFlagsBasedOnHAT; }

      void setApplyShadowToAmbientLighting(bool applyShadowToAmbient);

      bool applyShadowToAmbientLighting() const;



      void setSplitNearDistanceMinimumBias(double bias);

      double splitNearDistanceMinimumBias() const;

      void setSplitNearDistanceMaximumBias(double bias);

      double splitNearDistanceMaximumBias() const;

      void setSplitFarDistanceBias(double bias);

      double splitFarDistanceBias() const;
      void setEVSMPositiveExponent(double evsmPositiveExponent);

      double evsmPositiveExponent() const { return myEVSMPositiveExponent; }

      void setEVSMNegativeExponent(double evsmNegativeExponent);

      double evsmNegativeExponent() const { return myEVSMNegativeExponent; }

      void setVSMMininumVariance(double vsmMininumVariance);

      double vsmMininumVariance() const;

      void setESMDarkeningFactor(double esmDarkeningFactor);

      double esmDarkeningFactor() const;

      void setAntiFlickerQuantizationFactor(float antiFlickerQuantizationFactor);

      float antiFlickerQuantizationFactor() const;


   protected:
      friend class boost::serialization::access;

      template <typename Archive>
      void serialize(Archive& ar, unsigned int version)
      {
         ar& BOOST_SERIALIZATION_NVP(myName);
         ar& BOOST_SERIALIZATION_NVP(myNumSplits);
         if (version >= 7)
         {
            ar& BOOST_SERIALIZATION_NVP(myShadowsEnabled);
         }
         ar& BOOST_SERIALIZATION_NVP(myEntitiesCastsShadows);
         ar& BOOST_SERIALIZATION_NVP(myPropsCastsShadows);
         ar& BOOST_SERIALIZATION_NVP(myTerrainCastsShadows);
         ar& BOOST_SERIALIZATION_NVP(myVisualizeShadows);
         ar& BOOST_SERIALIZATION_NVP(myPolygonOffsetFactor);
         ar& BOOST_SERIALIZATION_NVP(myPolygonOffsetUnits);
         ar& BOOST_SERIALIZATION_NVP(myUsePolygonOffset);
         ar& BOOST_SERIALIZATION_NVP(mySpotLightShadowMapSize);
         ar& BOOST_SERIALIZATION_NVP(myGlobalLightShadowMapSize);
         ar& BOOST_SERIALIZATION_NVP(myMaximumViewDistance);
         ar& BOOST_SERIALIZATION_NVP(myUseMaximumViewDistance);
         ar& BOOST_SERIALIZATION_NVP(myUseFrontFaceCulling);
         ar& BOOST_SERIALIZATION_NVP(mySplitNearDistanceMinimumBias);
         ar& BOOST_SERIALIZATION_NVP(mySplitNearDistanceMaximumBias);
         ar& BOOST_SERIALIZATION_NVP(mySplitFarDistanceBias);
         ar& BOOST_SERIALIZATION_NVP(myShadowAmbientFactor);
         ar& BOOST_SERIALIZATION_NVP(myShadowStabilizationScheme);
         ar& BOOST_SERIALIZATION_NVP(myAntiFlickerQuantizationFactor);
         ar& BOOST_SERIALIZATION_NVP(mySplitDistanceComputeScheme);
         ar& BOOST_SERIALIZATION_NVP(myMixedSplitInterp);
         ar& BOOST_SERIALIZATION_NVP(mySplitSelectionScheme);
         ar& BOOST_SERIALIZATION_NVP(myDataStorageScheme);
         ar& BOOST_SERIALIZATION_NVP(myPreFilteringScheme);
         ar& BOOST_SERIALIZATION_NVP(myFilteringScheme);
         ar& BOOST_SERIALIZATION_NVP(myPoissonDiskSamplingScheme);
         ar& BOOST_SERIALIZATION_NVP(myNumAdditionalPassesPerCascade);
         ar& BOOST_SERIALIZATION_NVP(myPcfFilterWidth);
         ar& BOOST_SERIALIZATION_NVP(myBlendCascadesBoundaries);

         // These are not used anymore
         if (version <= 9)
         {
             bool myUseSDSM = false;
             ar& BOOST_SERIALIZATION_NVP(myUseSDSM);

             bool mySDSMReadBackLatency = false;
             ar& BOOST_SERIALIZATION_NVP(mySDSMReadBackLatency);

             bool myUseCameraDepthBufferForSDSM = false;
             ar& BOOST_SERIALIZATION_NVP(myUseCameraDepthBufferForSDSM);
         }
         ar& BOOST_SERIALIZATION_NVP(myEVSMPositiveExponent);
         ar& BOOST_SERIALIZATION_NVP(myEVSMNegativeExponent);
         ar& BOOST_SERIALIZATION_NVP(myVSMMininumVariance);
         ar& BOOST_SERIALIZATION_NVP(myESMDarkeningFactor);
         ar& BOOST_SERIALIZATION_NVP(myDirty);
         ar& BOOST_SERIALIZATION_NVP(myNumPersistentPassesPerCascade);

         if (version >= 2)
         {
            // Not used anymore. Only there for backward compatibility
            bool myCloudsCastsShadows = false;
            ar& BOOST_SERIALIZATION_NVP(myCloudsCastsShadows);
         }

         if (version >= 3)
         {
            ar& BOOST_SERIALIZATION_NVP(myUseCachedFarCascade);
         }

         if (version >= 4)
         {
            ar& BOOST_SERIALIZATION_NVP(myUseViewportMulticast);
         }

         if (version >= 5)
         {
            ar& BOOST_SERIALIZATION_NVP(myAdjustFarAndFlagsBasedOnHAT);
            ar& BOOST_SERIALIZATION_NVP(myFarCascadeUpdateFrequency);
         }

         if (version >= 6)
         {
            ar& BOOST_SERIALIZATION_NVP(myMoonCastsShadows);
         }

         if (version >= 8)
         {
            ar& BOOST_SERIALIZATION_NVP(myShadowsEnabledOnOcean);
         }

         if (version >= 9)
         {
            ar& BOOST_SERIALIZATION_NVP(myApplyShadowToAmbientLighting);
         }
      }


   protected:

      std::string             myName;
      bool                    myDirty;

      bool                    myShadowsEnabled;

      bool                    myShadowsEnabledOnOcean;

      bool                    myEntitiesCastsShadows;

      bool                    myPropsCastsShadows;

      bool                    myTerrainCastsShadows;

      bool                    myMoonCastsShadows;

      unsigned int               myNumSplits;

      std::vector<float>            myPolygonOffsetFactor;

      std::vector<float>            myPolygonOffsetUnits;

      unsigned int               myGlobalLightShadowMapSize;

      double                     myMaximumViewDistance;

      bool                    myUseMaximumViewDistance;

      bool                    myUseFrontFaceCulling;

      bool                    myUseCachedFarCascade;

      float               myFarCascadeUpdateFrequency;

      bool                            myUseViewportMulticast;

      bool                myAdjustFarAndFlagsBasedOnHAT;

      double                     mySplitNearDistanceMinimumBias;
      double                     mySplitNearDistanceMaximumBias;
      double                     mySplitFarDistanceBias;
      float                   myShadowAmbientFactor;
      ShadowStabilizationScheme     myShadowStabilizationScheme;
      SplitDistanceComputeScheme    mySplitDistanceComputeScheme;
      double                     myMixedSplitInterp;
      SplitSelectionScheme       mySplitSelectionScheme;
      DataStorageScheme          myDataStorageScheme;
      PreFilteringScheme            myPreFilteringScheme;
      FilteringScheme               myFilteringScheme;
      PoissonDiskSamplingScheme     myPoissonDiskSamplingScheme;
      unsigned int               myNumPersistentPassesPerCascade;
      unsigned int               myNumAdditionalPassesPerCascade;
      unsigned int               myPcfFilterWidth;
      bool                    myBlendCascadesBoundaries;

      // deprecated
      double                     myEVSMPositiveExponent;

      double                     myEVSMNegativeExponent;

      double                     myVSMMininumVariance;

      double                     myESMDarkeningFactor;
      bool                    myVisualizeShadows;
      float                   myAntiFlickerQuantizationFactor;
      unsigned int               mySpotLightShadowMapSize;
      bool                    myUsePolygonOffset;
      bool                    myApplyShadowToAmbientLighting;


   };
}

BOOST_CLASS_VERSION(makArchives::DtShadowSettingsRecord, 9)