DtOsgShadowTechnique.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtOsgTextureApplyAttribute.h>

#include <vrvUtil/signalslib.h>

#include <osgEarth/VirtualProgram>

#include <osgShadow/ShadowTechnique>

#include <osg/StateSet>
#include <osg/Camera>
#include <osg/PolygonOffset>
#include <osg/FrameBufferObject>
#include <osg/Uniform>
#include <osg/LightSource>
#include <osg/RenderInfo>
#include <osg/Vec2>
#include <osg/Vec3>
#include <osg/Matrix>
#include <osg/MatrixTransform>
#include <osg/Program>
#include <osg/Texture2D>
#include <osg/Texture2DArray>
#include <osg/Geode>
#include <osg/Geometry>
#include <osg/GL>

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

#include <tbb/mutex.h>

namespace makVrv
{

   class DtShadowTweakables;
   class DtChannel;
   class DtOsgChannel;
   class DtShadowSettingsObject;
   class TextureApplyAttribute;
   class DtOsgShadowTechnique;
   struct DtCurrentPassData;
   struct DtPerChannelData;
   class DtSkyObjectManager;

   class  DT_DLL_VRVOSG DtOsgShadowTechnique :  public osgShadow::ShadowTechnique
   {
   public:

      DtOsgShadowTechnique(DtDe& de);

      DtOsgShadowTechnique(const DtOsgShadowTechnique& es, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);

      virtual osg::Object* cloneType() const { return new DtOsgShadowTechnique(myDe); }

      virtual osg::Object* clone(const osg::CopyOp& copyop) const { return new DtOsgShadowTechnique (*this, copyop); }

      virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const DtOsgShadowTechnique *>(obj)!=NULL; }

      virtual const char* libraryName() const { return "makVrv"; }

      virtual const char* className() const { return "DtOsgShadowTechnique"; }

      virtual void init();

      virtual void postConstructionInit();

      virtual void update(osg::NodeVisitor& nv);

      virtual void cull(osgUtil::CullVisitor& cv);

      virtual void cleanSceneGraph();

      void setChannelShadowState(DtOsgChannel* osgChannel, bool enable);

      bool getChannelShadowSettings(DtOsgChannel* osgChannel, DtShadowSettingsObject** shadowSettingObject, bool* isPlanView);

      void setGlobalLight(osg::LightSource* light) { myGlobalLight = light; }

      const osg::LightSource* getGlobalLight() const { return myGlobalLight.get(); }

      static const std::string& shadowCameraPrefixString(void);
      
      const osg::StateSet * mapCameraToStateSet(const osg::Camera* camera) const;

      class DtShadowTweakables * myShadowUI;

      virtual void resizeGLObjectBuffers(unsigned int maxSize) override;

      virtual void releaseGLObjects(osg::State* = 0) const override;
   protected:
      virtual void reInitialize(unsigned int quality);

      virtual void cleanupOldPerChannelData();

      virtual bool configureShadowTraversalNodeMask(bool traverseEntities, bool traverseProps, bool traverseTerrain);

      virtual void slot_refresh_maps();
   public:
      // per window info 
      static const int MAX_NUM_CASCADES = 6;

   protected:

      virtual std::string generateVertexShader(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      virtual std::string generateFragmentShader(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      unsigned int getFilterCount(DtShadowSettingsObject* shadowSettingObject);

      bool getReceiveShadows(const DtShadowSettingsObject* shadowSettings) const;

      virtual void computeFrustumPoints(const osg::Matrix& projectionMat, bool reverseZ, const osg::Matrix& inverseViewMat,
         double nearPlane, double farPlane, osg::Vec3d* outFrustumPoints);

      virtual void chooseComputeShadowFunction(std::stringstream& sstr,
         DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettings);

   private:

      std::string generateFragmentComputeShadowFunction(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      std::string generateFragmentComputeShadowFunctionEsm(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      std::string generateFragmentComputeShadowFunctionVsm(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      std::string generateFragmentUniformAndVariables(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      std::string generateFragmentMain(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      bool getCameraSettings(osg::Camera* viewCamera, DtPerChannelData** perChannelData, DtShadowSettingsObject** shadowSettingObject, bool* isPlanView);

      void initPerChannelData(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      
      void installReceiverVPandSharedStateSet(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      void triggerExternalModuleShaderRefresh();

      void updateCascadeImportance(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      osg::Program* getProgramFromFile(const std::string& szVertexShader, const std::string& szFragmentShader);

      void installPreFilter(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject, osg::Camera* depthCamera,
         osg::Camera* xBlurCamera, osg::Camera* yBlurCamera, osg::Texture2DArray* texture, osg::StateSet* stateSet, unsigned int textureUnit);

      void installPreFilter(DtPerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject, osg::Camera* depthCamera,
         osg::Camera* xBlurCamera, osg::Camera* yBlurCamera, unsigned int textureLayer, osg::Texture2DArray* texture2DArray,
         osg::Texture2DArray* preFilterTexture2DArray1, osg::Texture2DArray* preFilterTexture2DArray2);

      void setupReverseZBuffer(osg::Camera* depthCamera, osg::Camera* xBlurCamera, osg::Camera* yBlurCamera);
      void setupBlurCamera(osg::Camera* camera, osg::ref_ptr<osg::Program> &blurProgram, const osg::Vec2 & direction);

      osg::Texture2D* createTexture2D(int width, int height, GLenum internalFormat, GLenum sourceFormat, GLenum sourceType, bool shadowComparisonMode,
         osg::Texture2D::FilterMode minFilter = osg::Texture2D::NEAREST, osg::Texture2D::FilterMode magFilter = osg::Texture2D::NEAREST);

      osg::Texture2DArray* createTexture2DArray(int width, int height, int depth, GLenum internalFormat, GLenum sourceFormat, GLenum sourceType,
         bool shadowComparisonMode, osg::Texture2DArray::FilterMode minFilter = osg::Texture2DArray::NEAREST, osg::Texture2DArray::FilterMode magFilter = osg::Texture2DArray::NEAREST);

      osg::Camera* createCamera(int width, int height, GLbitfield clearMask);

      osg::Geode* createFullScreenQuad(const osg::Vec2& size, const osg::Vec2& uvStart, const osg::Vec2& uvStop);

      osg::Camera* createHudCamera(int width, int height, GLbitfield clearMask, const char * name = NULL);

      double computeUniformSplit(double nearDistance, double farDistance, unsigned int splitIndex, unsigned int numSplits);

      double computeLogarithmicSplit(double nearDistance, double farDistance, unsigned int splitIndex, unsigned int numSplits);
    
      struct CameraDescription
      {
         osg::Matrix myViewMatrix;
         osg::Matrix myProjectionMatrix;
         osg::Matrix myTextureViewProjectionMatrix;
      };
     CameraDescription constructSplitLightCamera(const DtCurrentPassData & d, int split_index, bool farCascade = false);

     void updateCameras(const DtCurrentPassData & d);

      void getSplitCameraDistances(const DtCurrentPassData & d, int split_index, double &splitCamNear, double &splitCamFar);

      void setDirty(bool dirty) { _dirty = dirty; }

      // not really used yet.
      void frustumBoundingBoxLightViewSpace(const DtCurrentPassData & d, int split_index/*for_debug visualization*/, const osg::Matrix & lightViewMatrix,
         double nearPlane, double farPlane, osg::Vec3d& minFrustum, osg::Vec3d& maxFrustum);

      friend struct DtCurrentPassData;

   protected:

      virtual ~DtOsgShadowTechnique();

      typedef std::map< const osg::Camera*, osg::ref_ptr<DtPerChannelData> > PerChannelDataMap;
      typedef std::vector< osg::ref_ptr<DtPerChannelData> > PerChannelDataVector;

      PerChannelDataMap myPerChannelDataMap;
      PerChannelDataVector myPerChannelDataDeleteList;

      osg::ref_ptr<osg::LightSource> myGlobalLight;
      osg::ref_ptr<osg::Uniform>  myLightDirectionUniform;
      osg::ref_ptr<osg::Uniform>  myReceiveShadowsUniform;

      DtDe& myDe;

      static const std::string    myShadowCameraPrefixString;

      osg::ref_ptr<osg::Program>  myVsmBlurTextureProgram;
      osg::ref_ptr<osg::Program>  myVsmBlurTexArrayProgram;

      osg::ref_ptr<osg::Program>  myVsmPassthroughArrayProgram;
      osg::ref_ptr<osg::Program>  myVsmPassthroughProgram;

      osg::ref_ptr<osg::Program>  myEsmBlurTextureProgram;
      osg::ref_ptr<osg::Program>  myEsmBlurTexArrayProgram;

      osg::ref_ptr<osg::Program>  myEVsmBlurTextureProgram;
      osg::ref_ptr<osg::Program>  myEVsmBlurTexArrayProgram;

      // Avoid camera deletion (and resulting GL calls) in cull thread.
      std::vector<osg::ref_ptr<osg::Camera> > myDeferredDeleteCamera;

      // Protect myDeferredDeleteCamera
      tbb::mutex myDeferredCameraDeletionMutex;

      bool myMulticastIsSupported;   // true if multicast extension is supported
      bool myShadingRateIsSupported; // true if shading rate extension is supported

      DtSkyObjectManager& mySkyObjectManager;

      boost::signalslib::connection myTerrainPatchAddedConnection;
      boost::signalslib::connection myTerrainPatchDeletedConnection;
      
   };
}