DtOsgLightingComponentTcsUserData.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>
#include <vrvCore/DtKeyedData.h>

#include <vrvGraphicsUtils/DtLight.h>
#include <vrvMath/DtVector3.h>
#include <vrvMath/DtVector2.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <osg/Matrixd>

#include <unordered_map>
#include <string>
#include <vector>

namespace osg
{
   class State;
   class Camera;
}

namespace makVrv
{
   class DtGlBuffer;
   class DtLightData;
   class DtLightingComponentShaderConstants;
   class DtTileSpaceLightGrid;
   class DtLightComputeProgram;
   class DtGlDeleteObjectManager;
   class DtCoreGlBufferCreator;
   class DtOsgLightManager;
   class DtIndirectGlTextureObject;
   class DtCoordinateSystem;

   class DtIndirectDefaultTexturesContainer;
   class DtIndirectGlTextureObjectManager;
   class DtIndirectGlTextureObject;

   struct DtTileLightIndexInfo
   {
   public:
      DtTileLightIndexInfo()
         : myBufferToLightIndexMap()
         , myBufferChunkCount(0)
         , myTotalCount(0)
      {
         //intentional nop
      }
      virtual void reset()
      {
         myBufferToLightIndexMap.clear();
         myBufferChunkCount = 0;
         myTotalCount = 0;
      }
   public:
      //Map of buffers for each indirect geometry, buffer pointer to number of lights in the buffer
      std::unordered_map<DtGlBuffer*, int> myBufferToLightIndexMap;
      int myBufferChunkCount;
      int myTotalCount;
   };

   class DtOsgLightingComponentTcsUserData : public DtKeyedDataUserData
   {
   public:
      DtOsgLightingComponentTcsUserData(DtDe& de, const std::string& name);
      virtual ~DtOsgLightingComponentTcsUserData();
   private:
      DtOsgLightingComponentTcsUserData() = delete;
      DtOsgLightingComponentTcsUserData(const DtOsgLightingComponentTcsUserData& rhs) = delete;
      DtOsgLightingComponentTcsUserData& operator=(const DtOsgLightingComponentTcsUserData& rhs) = delete;
   public:
      virtual void update(const std::vector<const DtLight*>& lights, const osg::State& state, const osg::Camera* camera);

      virtual void releaseGLObjects(void);

      virtual void bindRenderPassBuffers();

      virtual void updateLightSourceIndexBufferHandle(DtGlBuffer* handle, int maxNumLightSources);

      virtual const DtLightingComponentShaderConstants* shaderConstants(void) const;
      virtual DtLightingComponentShaderConstants* shaderConstants(void);
   protected:
      virtual void packLights(const osg::Matrixd& normalMatrix, const std::vector<const DtLight*>& lights, const osg::State& state);

      virtual void updateTiledShadingData(const std::vector<const DtLight*>& 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 updateLightingShaderUbo(const osg::State& state);

      virtual void bindCommonBuffers(const osg::State& state);

      int lightGridSize() const;

      virtual void deleteBuffers(void);

      virtual void createComputePassSsbos(void);
      virtual void createRenderPassSsbos(void);

      virtual void deleteComputePassSsbos(void);
      virtual void deleteRenderPassSsbos(void);

      virtual void releaseComputePassSsbos(void);
      virtual void releaseRenderPassSsbos(void);

      virtual void slot_componentVisualizationModeChanged(int mode);

      virtual void slot_reloadShader();

      virtual void slot_coordinateSystemChanged();

      virtual void slot_preTick();
      Vector3_32 upVector(const osg::State& state) const;

      virtual void releaseTexture(DtIndirectGlTextureObject*& indirectGlTextureObject);

   protected:
      DtLightData* myLightGrid;

      static const int theLightBlockBase = 6;  // base binding for light UBO data
      static const int theLightBlockCount = 5; // number of light UBOs
      std::array<DtGlBuffer*, theLightBlockCount> myLightDataBlockUbos;

      DtGlBuffer* myLightingShaderUbo = nullptr;
      int myLightingShaderUboBiding = -1;
      DtLightingComponentShaderConstants* myLightingShaderUboConstants = nullptr;

      DtGlBuffer* myTileLightIndexListSsbo = nullptr;
      int myTileLightIndexListSsboBinding = -1;

      DtTileSpaceLightGrid* myTileSpaceLightGrid;

      DtTileLightIndexInfo myTileLightIndexInfo;

      std::vector<DtLight*> myViewSpaceLightsScratchPad;

      DtLightComputeProgram* myLightComputeProgram;

      // This goes in at binding 0 in the compute pass
      DtGlBuffer* myTileLightIndexBuffersInfoSsbo = nullptr;
      // This goes in at binding 2 in the compute pass
      DtGlBuffer* myTileLightIntersectionDataSsbo = nullptr;
      // This is not applied directly. various of its address/offset are fed via myTileLightIndexBuffersInfoSsbo
      DtGlBuffer* myTileLightIndexListPreComputeSsbo = nullptr;

      DtGlDeleteObjectManager& myGlDeleteObjectManager;
      DtCoreGlBufferCreator& myCoreGlBufferCreator;

      DtSignalConnectionManager myConnections;

      DtOsgLightManager& myOsgLightManager;

      DtCoordinateSystem* myCoordinateSystem = nullptr;

      DtIndirectDefaultTexturesContainer& myIndirectDefaultTexturesContainer;
      DtIndirectGlTextureObjectManager& myIndirectGlTextureObjectManager;

      DtIndirectGlTextureObject* myBrdfLookUpTexture = nullptr;
      DtIndirectGlTextureObject* myModelDebugTexture = nullptr;
protected:
      //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;
   };

   typedef DtVirtualBaseClassCreator<DtOsgLightingComponentTcsUserData, const std::string&> DtOsgLightingComponentTcsUserDataCreator;

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