DtShadowSettingsObject.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtUniqueID.h>
#include <makArchives/DtShadowSettingsRecord.h>

#include <string>
#include <vector>

namespace makVrv
{

    class DtDe;

    class DT_DLL_VRVCORE DtShadowSettingsObject // this should really just be public DtShadowSettingsRecord
    {
    public:
        DtShadowSettingsObject(DtDe& de, DtUniqueID id, const std::string& name = "");

        ~DtShadowSettingsObject();

        void setNameAndRegister(const std::string& name, int quality);

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

        int quality() const { return myQuality; }

        void setDirty(bool dirty);

        bool dirty() const { return myDirty; }

        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(makArchives::DtShadowSettingsRecord::ShadowStabilizationScheme shadowStabilizationScheme);

        makArchives::DtShadowSettingsRecord::ShadowStabilizationScheme shadowStabilizationScheme() const { return myShadowStabilizationScheme; }

        void setSplitDistanceComputeScheme(makArchives::DtShadowSettingsRecord::SplitDistanceComputeScheme splitDistanceComputeScheme);

        makArchives::DtShadowSettingsRecord::SplitDistanceComputeScheme splitDistanceComputeScheme() const { return mySplitDistanceComputeScheme; }

        void setMixedSplitInterpolationValue(double interp);

        double mixedSplitInterpolationValue() const { return myMixedSplitInterp; }

        void setSplitSelectionScheme(makArchives::DtShadowSettingsRecord::SplitSelectionScheme splitSelectionScheme);

        makArchives::DtShadowSettingsRecord::SplitSelectionScheme splitSelectionScheme() const { return mySplitSelectionScheme; }

        void setDataStorageScheme(makArchives::DtShadowSettingsRecord::DataStorageScheme dataStorageScheme);

        makArchives::DtShadowSettingsRecord::DataStorageScheme dataStorageScheme() const { return myDataStorageScheme; }

        void setPreFilteringScheme(makArchives::DtShadowSettingsRecord::PreFilteringScheme preFilteringScheme);

        makArchives::DtShadowSettingsRecord::PreFilteringScheme preFilteringScheme() const { return myPreFilteringScheme; }

        void setFilteringScheme(makArchives::DtShadowSettingsRecord::FilteringScheme filteringScheme);

        makArchives::DtShadowSettingsRecord::FilteringScheme filteringScheme() const { return myFilteringScheme; }

        void setPoissonDiskSamplingScheme(makArchives::DtShadowSettingsRecord::PoissonDiskSamplingScheme poissonDiskSamplingScheme);

        makArchives::DtShadowSettingsRecord::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 setSDSMRenderInterval(double sdsmRenderInterval);

        double sdsmRenderInterval() const { return mySDSMRenderInterval; }

        void setAdjustFarAndFlagsBasedOnHAT(bool enabled) { myAdjustFarAndFlagsBasedOnHAT = enabled; }
        
        bool adjustFarAndFlagsBasedOnHAT() const { return myAdjustFarAndFlagsBasedOnHAT; }



        void setSplitNearDistanceMinimumBias(double bias);

        double splitNearDistanceMinimumBias() const {  return 0.0f; }// { return mySplitNearDistanceMinimumBias; }

        void setSplitNearDistanceMaximumBias(double bias);

        double splitNearDistanceMaximumBias() const { return 0.0f; } //{ return mySplitNearDistanceMaximumBias; }

        void setSplitFarDistanceBias(double bias);

        double splitFarDistanceBias() const { return 0.0f; } //{ return mySplitFarDistanceBias; }

        void setEVSMPositiveExponent(double evsmPositiveExponent);

        double evsmPositiveExponent() const { return 0.0; } //{ return myEVSMPositiveExponent; }

        void setEVSMNegativeExponent(double evsmNegativeExponent);

        double evsmNegativeExponent() const { return 0.0; }// {return myEVSMNegativeExponent;    }

        void setVSMMininumVariance(double vsmMininumVariance);

        double vsmMininumVariance() const { return 0.0; }//return myVSMMininumVariance;

        void setESMDarkeningFactor(double esmDarkeningFactor);

        double esmDarkeningFactor() const { return 0.0; }// myESMDarkeningFactor; }

        void setAntiFlickerQuantizationFactor(float antiFlickerQuantizationFactor);

        float antiFlickerQuantizationFactor() const { return 64.0f; } // { return myAntiFlickerQuantizationFactor; }

    protected:
        std::string                 myName;

        int                      myQuality;
        
      DtDe&                   myDe;

       bool             myDirty;
       
        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          mySDSMRenderInterval;

        float                    myShadowAmbientFactor;

        makArchives::DtShadowSettingsRecord::ShadowStabilizationScheme     myShadowStabilizationScheme;

       
        makArchives::DtShadowSettingsRecord::SplitDistanceComputeScheme    mySplitDistanceComputeScheme;

        double                   myMixedSplitInterp;

        makArchives::DtShadowSettingsRecord::SplitSelectionScheme       mySplitSelectionScheme;

        makArchives::DtShadowSettingsRecord::DataStorageScheme          myDataStorageScheme;

        makArchives::DtShadowSettingsRecord::PreFilteringScheme            myPreFilteringScheme;

        makArchives::DtShadowSettingsRecord::FilteringScheme               myFilteringScheme;

        makArchives::DtShadowSettingsRecord::PoissonDiskSamplingScheme     myPoissonDiskSamplingScheme;

        unsigned int             myNumPersistentPassesPerCascade;

        unsigned int             myNumAdditionalPassesPerCascade;

        unsigned int             myPcfFilterWidth;

        bool                     myBlendCascadesBoundaries;

        bool                     myUseSDSM;

        unsigned int                    mySDSMReadBackLatency;

        bool                     myUseCameraDepthBufferForSDSM;

     

        //double           mySplitNearDistanceMinimumBias;

        //double           mySplitNearDistanceMaximumBias;

        //double           mySplitFarDistanceBias;

        //double            myEVSMPositiveExponent;

        //double            myEVSMNegativeExponent;

        //double            myVSMMininumVariance;

        //double            myESMDarkeningFactor;
                                

        bool            myVisualizeShadows;
        //float                myAntiFlickerQuantizationFactor;
        unsigned int    mySpotLightShadowMapSize;
        bool            myUsePolygonOffset;

    };

}