DtShadowSettingsObject.h

Go to the documentation of this file.

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


#pragma once

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

#include <string>
#include <vector>

namespace makVrv
{

   class DtDe;

   class DT_DLL_VRVCORE DtShadowSettingsObject
   {
   public:
      DtShadowSettingsObject( DtDe& de, DtUniqueID id, const std::string& name="" );

      ~DtShadowSettingsObject();

      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 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 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 setSplitNearDistanceMinimumBias(double bias);

      double splitNearDistanceMinimumBias() const { return mySplitNearDistanceMinimumBias; }

      void setSplitNearDistanceMaximumBias(double bias);

      double splitNearDistanceMaximumBias() const { return mySplitNearDistanceMaximumBias; }

      void setSplitFarDistanceBias(double bias);

      double splitFarDistanceBias() const { return mySplitFarDistanceBias; }

      void setShadowAmbientFactor(float shadowAmbientFactor );

      float shadowAmbientFactor() const { return myShadowAmbientFactor; }

      enum ShadowStabilizationScheme
      {
         EXACT_ANTI_FLICKERING,
         APPROXIMATE_ANTI_FLICKERING,
         NO_ANTI_FLICKERING
      };

      void setShadowStabilizationScheme(ShadowStabilizationScheme shadowStabilizationScheme);

      ShadowStabilizationScheme shadowStabilizationScheme() const { return myShadowStabilizationScheme; }

      void setAntiFlickerQuantizationFactor(float antiFlickerQuantizationFactor);

      float antiFlickerQuantizationFactor() const { return myAntiFlickerQuantizationFactor; }

      enum SplitDistanceComputeScheme
      {
         LOGARITHMIC_SPLIT,
         UNIFORM_SPLIT,
         MIXED_LOGARITHMIC_UNIFORM_SPLIT
      };

      void setSplitDistanceComputeScheme(SplitDistanceComputeScheme splitDistanceComputeScheme);

      SplitDistanceComputeScheme splitDistanceComputeScheme() const { return mySplitDistanceComputeScheme; }

      void setMixedSplitInterpolationValue(double interp);

      double mixedSplitInterpolationValue() const { return myMixedSplitInterp; }

      enum SplitSelectionScheme
      {
         EYE_SPACE,
         LIGHT_SPACE
      };

      void setSplitSelectionScheme(SplitSelectionScheme splitSelectionScheme);

      SplitSelectionScheme splitSelectionScheme() const { return mySplitSelectionScheme; }

      enum DataStorageScheme
      {
         TEXTURE_2D_STORAGE,
         TEXTURE_2D_ATLAS_STORAGE,
         TEXTURE_2D_ARRAY_STORAGE
      };

      void setDataStorageScheme(DataStorageScheme dataStorageScheme);

      DataStorageScheme dataStorageScheme() const { return myDataStorageScheme; }

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

      void setPreFilteringScheme(PreFilteringScheme preFilteringScheme);

      PreFilteringScheme preFilteringScheme() const { return myPreFilteringScheme; }

      enum FilteringScheme
      {
         PCF_4_TAPS,
         PCF_9_TAPS,
         PCF_16_TAPS,
         PCF_25_TAPS,
         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,
         NO_FILTERING
      };

      void setFilteringScheme(FilteringScheme filteringScheme);

      FilteringScheme filteringScheme() const { return myFilteringScheme; }

      enum PoissonDiskSamplingScheme
      {
         UNIFORM_SAMPLING,
         STRATIFIED_SAMPLING,
         ROTATED_SAMPLING
      };

      void setPoissonDiskSamplingScheme(PoissonDiskSamplingScheme poissonDiskSamplingScheme);

      PoissonDiskSamplingScheme poissonDiskSamplingScheme() const { return myPoissonDiskSamplingScheme; }

      void setDirty(bool dirty);

      bool dirty() const { return myDirty; }

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

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

      int quality() const { return myQuality; }

      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 setEVSMPositiveExponent(double evsmPositiveExponent);
      
      double evsmPositiveExponent() const { return myEVSMPositiveExponent; }
      
      void setEVSMNegativeExponent(double evsmNegativeExponent);
      
      double evsmNegativeExponent() const { return myEVSMNegativeExponent; }
      
      void setVSMMininumVariance(double vsmMininumVariance);
      
      double vsmMininumVariance() const { return myVSMMininumVariance; }
      
      void setESMDarkeningFactor(double esmDarkeningFactor);
      
      double esmDarkeningFactor() const { return myESMDarkeningFactor; }

   protected:

      bool           myEntitiesCastsShadows;

      bool           myPropsCastsShadows;

      bool           myTerrainCastsShadows;

      bool           myCloudsCastsShadows;

      unsigned int      myNumSplits;

      bool           myVisualizeShadows;

      std::vector<float>   myPolygonOffsetFactor;

      std::vector<float>  myPolygonOffsetUnits;

      bool           myUsePolygonOffset;

      unsigned int      mySpotLightShadowMapSize;

      unsigned int      myGlobalLightShadowMapSize;

      double            myMaximumViewDistance;

      bool           myUseMaximumViewDistance;

      bool           myUseFrontFaceCulling;

      double            mySplitNearDistanceMinimumBias;

      double            mySplitNearDistanceMaximumBias;

      double            mySplitFarDistanceBias;

      double            mySDSMRenderInterval;

      float                   myShadowAmbientFactor;

      ShadowStabilizationScheme     myShadowStabilizationScheme;

      float                   myAntiFlickerQuantizationFactor;

      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;

      double                     myEVSMPositiveExponent;

      double                     myEVSMNegativeExponent;

      double                     myVSMMininumVariance;

      double                     myESMDarkeningFactor;

      bool                    myDirty;

      DtDe&                   myDe;

      std::string                myName;

      int                        myQuality;
   };

}