DtOsgLightingComponent.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtOsgStateComponent.h>
#include <vrvOsg/DtOsgTextureApplyAttribute.h>
#include <vrvOsg/DtOsgTextureBufferObjectApplyAttribute.h>
#include <vrvOsg/DtBufferObjectApplyAttribute.h>

#include <vrvOsg/DtBindingManager.h>
#include <vrvOsg/DtLightComputeProgram.h>

#include <vrvGraphicsUtils/DtLight.h>
#include <vrvGraphicsUtils/DtVector4.h>

#include <vrvCore/DtVirtualBaseClassCreator.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <osg/Uniform>
#include <osg/Texture2D>

#include <vector>
#include <unordered_map>
#include <array>

#include <tbb/atomic.h>

namespace osg
{
   class Matrixd;
}

namespace makVrv
{
   class DtLight;
   class DtLightData;
   class DtTileSpaceLightGrid;
   class DtGlSimpleTexture;
   class DtGlBuffer;
   class DtGlTextureBufferObject;
   class DeDe;

   class TextureApplyAttribute;
   class TextureBufferObjectApplyAttribute;
   class DtUniformBufferObjectApplyAttribute;
   class DtShaderStorageBufferApplyAttribute;

   class DtLightingComponentShaderConstants;

   class DtOsgLightingComponentUboCallback;

   class DT_DLL_VRVOSG DtOsgLightingComponent : public DtOsgStateComponent
   {
   public:
      DtOsgLightingComponent(DtDe& de);

      virtual ~DtOsgLightingComponent();
   private:
      DtOsgLightingComponent() = delete;

      DtOsgLightingComponent(const DtOsgLightingComponent&) = delete;

      DtOsgLightingComponent& operator=(const DtOsgLightingComponent&) = delete;
      
   public:
      virtual void update(const VectorLights& lights, const osg::State& state, const osg::Camera* camera);

      virtual const Vector2_uint32& tileSize(void) const;

      virtual const Vector2_uint32& gridMaxDims(void) const;

      virtual void updateLightSourceIndexBufferHandle(const osg::Camera* camera, DtGlBuffer* handle, int maxNumLightSources);
      
      virtual osg::Uniform* getEnableLightingUniform() const;

      virtual void setAmbientFactor(float ambientFactor);

      virtual void setUseGlobalAmbient(bool useGlobalAmbient);

      virtual void setDiffuseFactor(float diffuseFactor);

      virtual void setUseGlobalDiffuse(bool useGlobalDiffuse);

      virtual void setUseHDR(bool useHDR);

      virtual void slot_reloadShader();

      virtual void setDirty(bool isDirty) { myDirty = isDirty; }

      virtual void setEmissionFactor(float emissionFactor);

      virtual bool dirty() const { return myDirty; }

      virtual void releaseGLObjects(void);

      // DtOsgStateComponent interface
      virtual bool install(osg::StateSet* stateset);

      virtual bool uninstall(osg::StateSet* stateset);

      virtual bool isInstalled(void) const;

      virtual void setComponentVisualizationMode(int mode);

      virtual const DtLightingComponentShaderConstants* shaderConstants(void) const;

      virtual DtLightingComponentShaderConstants* shaderConstants(void);
   public:
      static int textureStartOffset(void);

   protected:
      virtual void setLightPointScale(double scale);
      virtual void setDynamicLightScale(double scale);
      virtual void setEmissiveTextureScale(double scale);
      virtual void setSpecularScale(double scale);
      virtual void setShininessScale(double scale);

      virtual osg::ref_ptr<osg::Uniform> createUniform(const std::string& name, osg::Uniform::Type type, int count=1);

      virtual void packLights(const osg::Matrixd& normalMatrix, const VectorLights& lights, const osg::State& state);
      virtual void updateTextureLightDataGrid(void);
      virtual void updateTiledShadingData(const VectorLights& lights, const osg::State& state, const osg::Camera* camera);
      
      virtual void updateTileLightIndexList(const std::vector<Matrix4_64>& projectionMatrix
         , const std::vector<Vector3_64>& vWorldEye
         , const std::vector<Vector3_64>& vWorldCenter
         , const std::vector<Vector3_64>& vWorldUp
         , const Vector2_uint32& viewportSize
         , const osg::Camera* camera);
      virtual void initializeColorRampTexture( );

      virtual int lightGridSize();

      virtual int maxUboSize();

      virtual void setUpDebugTextureComponentMode(void);

      virtual std::string findDebugTexturePath(void) const;

   protected:

      osg::ref_ptr<osg::Uniform> myEnableLightingUniform;
      osg::ref_ptr<osg::Uniform> myLightingOffClampUniform;

      std::vector< osg::ref_ptr<osg::Uniform> > myUniforms;

      // Parameters of lights are stored in this structure
      DtLightData* myLightGrid;

      std::array<DtGlBuffer*, DtBindingManager::theLightBlockCount> myLightUBO;

      DtTileSpaceLightGrid* myTileSpaceLightGrid;

      DtGlBuffer* myTileLightIndexListSsbo;
      DtGlBuffer* myTileLightIndexListSsboPreCompute;
      DtGlBuffer* myTileLightIntersectionDataSsbo;
      DtGlBuffer* myTileLightIndexBuffersInfoSsbo;

      typedef std::unordered_map<DtGlBuffer*, int> BufferToLightIndexMap;

      struct TileLightIndexInfo
      {
         public: 
               TileLightIndexInfo()
                  : myBufferToLightIndexMap()
                  , myBufferChunkCount(0)
                  , myTotalCount(0)
               {
                  //intentional nop
               }
         public:
            //Map of buffers for each indirect geoemetry, buffer pointer to number of lights in the buffer
            BufferToLightIndexMap myBufferToLightIndexMap;
            int myBufferChunkCount;
            int myTotalCount;
      };

      //map for holding a TileLightIndexInfo for each camera
      typedef std::unordered_map<const osg::Camera*, TileLightIndexInfo> CameraToTileLightIndexMapInfoMap;
      CameraToTileLightIndexMapInfoMap myCameraToTileLightIndexMapInfoMap;

      DtGlSimpleTexture* myColorRampTexture;
      osg::ref_ptr<osg::Uniform> myColorRampTextureUniform;

      osg::ref_ptr<TextureApplyAttribute> myTextureApplyAttribute;
      osg::ref_ptr<DtUniformBufferObjectApplyAttribute> myUniformBufferObjectApplyAttribute;
      osg::ref_ptr<DtShaderStorageBufferApplyAttribute> myShaderStorageBufferApplyAttribute;

      DtGlBuffer* myGpuShaderUbo = nullptr;
      int myGpuShaderUboBinding;
      DtLightingComponentShaderConstants* myShaderConstants = nullptr;

      friend class DtOsgLightingComponentUboCallback;
      DtOsgLightingComponentUboCallback* myUboCallback = nullptr;
      
      osg::ref_ptr<osg::Uniform> myAmbientFactorUniform;
      bool myUseGlobalAmbient;
      osg::ref_ptr<osg::Uniform> myUseGlobalAmbientUniform;

      osg::ref_ptr<osg::Uniform> myDiffuseFactorUniform;
      bool myUseGlobalDiffuse;
      osg::ref_ptr<osg::Uniform> myUseGlobalDiffuseUniform;

      bool myUseHDR;
      bool myDirty;

      osg::ref_ptr<osg::Uniform> myUpVectorUniform;
      osg::ref_ptr<osg::Uniform> myBDRFLutUniform;
      osg::ref_ptr<osg::Texture2D> myBDRFLutTexture;
      osg::ref_ptr<osg::Image> myBrdfLutImage;

      osg::ref_ptr<osg::Uniform> myModelTypeDefaultUniform;

      VectorLights myViewSpaceLightsScratchPad;

      bool myIsInstalled;

      DtSignalConnectionManager myConnections;

      static bool bColorRampTextureWasTried;

      GLint myMaxUboSizeInBytes;   // queried from GL
      int   myLightGridSize;       // max size of light grid

      const DtBindingManager& myBindingManager; // reference to the binding manager

      DtLightComputeProgram* myLightComputeProgram;

      //Constants for scaling the HDR scalars to values so the GUI can be a single decimal digit.
      static const float theLightPointHdrScalar;
      static const float theDynamicLightHdrScalar;
      static const float theEmissiveTextureHdrScalar;

      osg::ref_ptr<osg::Texture> myDebugTexture;
   };


   typedef DtVirtualBaseClassCreator<DtOsgLightingComponent> DtOsgLightingComponentCreator;

   template <>
   inline const char* creatorTypeName<DtOsgLightingComponent>(void) { return "DtOsgLightingComponentCreator"; }
}