DtOsgShadowTechnique.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.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/Program>
#include <osg/Texture2D>
#include <osg/Texture2DArray>
#include <osg/Geode>
#include <osg/GL>

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

namespace makVrv
{

    class DtChannel;
   class DtOsgChannel;
   class DtShadowSettingsObject;
   class TextureApplyAttribute;
   
   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 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);

      bool getChannelCloudShadowMap(DtOsgChannel* osgChannel, unsigned int* textureIndex, osg::Matrix* textureViewProjMatrix);

      bool getCameraCloudShadowMap(osg::Camera* camera, unsigned int* textureIndex, osg::Matrix* textureViewProjMatrix);

      void setGlobalLight(osg::LightSource* light) { myGlobalLight = light; }
      
      const osg::LightSource* getGlobalLight() const { return myGlobalLight.get(); }

        static const std::string& shadowCameraPrefixString(void);
        static const std::string& shadowSDSMCameraPrefixString(void);

   protected:
      virtual void reInitialize(unsigned int quality);

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

      struct PreDrawFBOCallback : public osg::Camera::DrawCallback
      {
         PreDrawFBOCallback( osg::FrameBufferObject* fbo);

         virtual void operator () (osg::RenderInfo& renderInfo) const;

         void enableBindFbo(bool bind);

      private:
         osg::ref_ptr<osg::FrameBufferObject> mySharedFbo;
         bool myEnableBindFbo;
      };


      struct PostDrawFBOCallback : public osg::Camera::DrawCallback
      {
         PostDrawFBOCallback();

         virtual void operator () (osg::RenderInfo& renderInfo) const;

         void setRestoreDrawBuffer(GLenum bufferAttachment);
         
         void setRestoreReadBuffer(GLenum bufferAttachment);
         
         void enableUnbindFbo(bool unbind);
      private:
         GLenum myDrawBufferAttachment;
         GLenum myReadBufferAttachment;
         bool myEnableUnbindFbo;
      };

      struct SdsmDrawCallback : public osg::Camera::DrawCallback
      {
         SdsmDrawCallback(bool bindFbo, GLenum colorAttachment, unsigned int numPipelines, unsigned int numPartitions, unsigned int width, unsigned int height);

         ~SdsmDrawCallback();

         virtual void operator () (osg::RenderInfo& renderInfo) const;

         float minDepth() const;

         float maxDepth() const;

         float minDepth(unsigned int splitIndex) const;

         float maxDepth(unsigned int splitIndex) const;

         osg::Vec2 partition(unsigned int splitIndex) const;

         bool isSDSMDepthAvailable() const;
      private:
         mutable std::vector<osg::Vec2> myPartitions;
         mutable unsigned int myFBOBufferIndex;
         mutable std::vector<unsigned int> myPBOBufferIndex;
         mutable unsigned int myCurrentPBOIndex;
         mutable unsigned int myColorTextureIndex;
         mutable unsigned int myDepthRBOBufferIndex;
         GLenum myColorAttachment;
         bool myBindFbo;
         unsigned int myWidth;
         unsigned int myHeight;
         mutable float myMinDepth;
         mutable float myMaxDepth;
         mutable float myMinDepthArray[20];
         mutable float myMaxDepthArray[20];
         unsigned int myDepthSamplePos;
         mutable bool mySDSMDepthAvailable;
      };


      struct PostDrawSDSMCallback : public osg::Camera::DrawCallback
      {
         PostDrawSDSMCallback(){}

         // Callback Method to unbind the currently bound framebuffer object
         virtual void operator () (osg::RenderInfo& renderInfo) const;
      };

      struct CascadeImportanceData
      {
         float                      myImportance;
         unsigned int                  myCascadeIndex;
      };

      struct CsmSplitData
      {
         osg::ref_ptr<osg::Camera>        myCamera;
         osg::ref_ptr<osg::Camera>        myDepthCamera;
         osg::ref_ptr<osg::Camera>        myXBlurCamera;
         osg::ref_ptr<osg::Camera>        myYBlurCamera;
         unsigned int                  myTexUnit;
         osg::Vec4                     myAtlasTexOffsetAndScale;
         osg::ref_ptr<osg::Uniform>       myAtlasTexOffsetAndScaleUniform;
         osg::ref_ptr<osg::PolygonOffset> myPolygonOffset;


         double                        mySplitFar;
         osg::ref_ptr<osg::Uniform>       mySplitFarUniform;

         unsigned int                  mySplitIndex;
         unsigned int                  myGlobalLightShadowMapSize;

         osg::Matrix                   myTextureViewProjectionMatrix;

         unsigned int                  myRefreshAge;
         bool                       myRefresh;
      };

      struct PerChannelData : public osg::Referenced
      {
         PerChannelData(makVrv::DtOsgChannel& channel)
            : myAtlasWidth(0)
            , myAtlasHeight(0)
            , myAtlasWidthNumSplits(0)
            , myAtlasHeightNumSplits(0)
            , myJustInitialized(false)
            , myNotInitialized(true)
            , myChannel(channel)
            , mySDSMTime(0)
         {

         }
         std::vector<CascadeImportanceData>        myImportance;
         std::vector<CsmSplitData>              myCsmSplits;
         osg::ref_ptr<osg::StateSet>               mySharedStateSet;
         osg::ref_ptr<osg::Uniform>             myShadowTexGenUniform;
         osg::ref_ptr<osg::Uniform>             myCloudShadowTexGenUniform;
         osg::ref_ptr<TextureApplyAttribute>       myCloudShadowTexture;
         osg::Matrix                             myCloudShadowTexGenMatrix;
         osg::ref_ptr<osgEarth::VirtualProgram>    myVirtualProgram;
         unsigned int                        myNumSplits;
         unsigned int                        myAtlasWidth;
         unsigned int                        myAtlasHeight;
         unsigned int                        myAtlasWidthNumSplits;
         unsigned int                        myAtlasHeightNumSplits;
         osg::ref_ptr<osg::Uniform>             myShadowAmbientFactorUniform;
         bool                             myJustInitialized;
         bool                             myNotInitialized;
         makVrv::DtOsgChannel&                  myChannel;
         osg::Vec3d                          myLastCameraPosition;
         osg::ref_ptr<osg::Camera>              mySDSMCamera;
         std::vector<osg::ref_ptr<osg::Camera> >      mySDSMReduceCamera;
         osg::ref_ptr<osg::Uniform>             myFarNearSumDiffProdx2Uniform;
         osg::ref_ptr<osg::Uniform>             myMaximumViewDistanceUniform;
         osg::ref_ptr<osg::Uniform>             myMaximumDepthUniform;
         osg::ref_ptr<osg::Uniform>             myInvNumSplitsInterpUniform;
         osg::ref_ptr<osg::Camera>              mySDSMLinearizeDepthCamera;
         osg::ref_ptr<osg::Camera>              mySDSMCopyReduceDepthCamera;
         osg::ref_ptr<osg::Camera>              mySDSMPartitionCamera;
         std::vector<osg::ref_ptr<osg::Camera> >      mySDSMPartitionReduceCamera;
         osg::ref_ptr<SdsmDrawCallback>            mySDSMDrawCallback;
         osg::ref_ptr<osg::Camera>              myAtlasDepthCamera;
         osg::ref_ptr<osg::Camera>              myAtlasXBlurCamera;
         osg::ref_ptr<osg::Camera>              myAtlasYBlurCamera;
         osg::ref_ptr<osg::Camera>              myCloudShadowCamera;
         double                              mySDSMTime;
      protected:
         virtual ~PerChannelData(){}
      };


      struct CloudShadowPreDrawCallback : public osg::Camera::DrawCallback
      {
         CloudShadowPreDrawCallback(DtOsgShadowTechnique& shadowTechnique, PerChannelData& perChannelData);

         // Callback Method to unbind the currently bound framebuffer object
         virtual void operator () (osg::RenderInfo& renderInfo) const;
         mutable DtOsgShadowTechnique& myShadowTechnique;
         mutable PerChannelData& myPerChannelData;
      };

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

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

      virtual std::string generateCloudShadowVertexShader(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      virtual std::string generateCloudShadowFragmentShader(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      unsigned int getFilterCount(DtShadowSettingsObject* shadowSettingObject);

   private:

      std::string generatePoissonDiscArray(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      std::string generateHelperFunctions(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

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

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

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

      std::string generateFragmentVisualizeCascadeMain(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

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

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

      void installVirtualProgramAndSharedStateSet(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);
      
      void packTextureAtlas(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);
      
      void installSDSM(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);

      void traverseSDSMCameras(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject, osgUtil::CullVisitor& cv, double cameraMagnification);

      void installCloudShadows(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);
      
      void updateCloudShadows(osg::Camera* camera);
      
      void updateCloudShadows(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject, const osg::Matrix& inverseViewMatrix);
      
      void updateCascadeImportance(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject);
      
      osg::Program* getProgramFromFile(const std::string& szVertexShader, const std::string& szFragmentShader);
      
      void installPreFilter(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject, osg::Camera* depthCamera,
         osg::Camera* xBlurCamera, osg::Camera* yBlurCamera, osg::Texture2D* texture, osg::StateSet* stateSet, unsigned int textureUnit);
      
      void installPreFilter(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject, osg::Camera* depthCamera,
         osg::Camera* xBlurCamera, osg::Camera* yBlurCamera, unsigned int textureLayer, osg::Texture2DArray* texture2DArray,
         osg::Texture2DArray* preFilterTexture2DArray1, osg::Texture2DArray* preFilterTexture2DArray2);

      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);

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

      double computeLogarithmicSplit(double nearDistance, double farDistance, unsigned int splitIndex, unsigned int numSplits);
      
      void constructSplitLightCamera(PerChannelData* perChannelData, DtShadowSettingsObject* shadowSettingObject, CsmSplitData &csmSplit, const osg::Vec3& lightDirection,
         const osg::Matrix& cameraViewMatrix, const osg::Matrix& cameraProjectionMatrix, double cameraMagnification);
      
      void setDirty(bool dirty) { _dirty = dirty; }
   protected:

      virtual ~DtOsgShadowTechnique() {}

      typedef std::map< osg::Camera*, osg::ref_ptr<PerChannelData> > PerChannelDataMap;

      PerChannelDataMap myPerChannelDataMap;

      osg::ref_ptr<osg::LightSource>   myGlobalLight;

      unsigned int      myTextureUnitOffset;

      DtDe& myDe;

        static const std::string myShadowCameraPrefixString;
        static const std::string mySDSMShadowCameraPrefixString;
   };
}