DtShadowSettingsRecord.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2021 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 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 setCloudsCastsShadows(bool castShadows);

        bool cloudsCastsShadows() const { return myCloudsCastsShadows; }

        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 setDataStorageScheme(DataStorageScheme dataStorageScheme);

        DataStorageScheme dataStorageScheme() const { return myDataStorageScheme; }

        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 setUseSDSM(bool useSDSM);

        bool useSDSM() const { return myUseSDSM; }

        void setSDSMReadBackLatency(unsigned int sdsmReadBackLatency);

        unsigned int sdsmReadBackLatency() const { return mySDSMReadBackLatency; }

        void setUseCameraDepthBufferForSDSM(bool useCameraDepthBufferForSDSM);

        bool useCameraDepthBufferForSDSM() const { return myUseCameraDepthBufferForSDSM; }

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

        bool adjustFarAndFlagsBasedOnHAT() const { return myAdjustFarAndFlagsBasedOnHAT; }



        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);
            ar & BOOST_SERIALIZATION_NVP(myUseSDSM);
            ar & BOOST_SERIALIZATION_NVP(mySDSMReadBackLatency);
            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)
            {
                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);
            }
        }

   
    protected:

        std::string                 myName;
        bool                     myDirty;

        bool                     myShadowsEnabled;

        bool                     myEntitiesCastsShadows;

        bool                     myPropsCastsShadows;

        bool                     myTerrainCastsShadows;

        bool                     myMoonCastsShadows;

        bool                     myCloudsCastsShadows;

        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;
        bool                     myUseSDSM;
        unsigned int                    mySDSMReadBackLatency;
        bool                     myUseCameraDepthBufferForSDSM;

        // deprecated
        double                   myEVSMPositiveExponent;

        double                   myEVSMNegativeExponent;

        double                   myVSMMininumVariance;

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


    };
}

BOOST_CLASS_VERSION(makArchives::DtShadowSettingsRecord, 7)