DtGpuCulling.h

Go to the documentation of this file.

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


#pragma once

#include <osg/FrameStamp>
#include <osg/Camera>

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtModelIdAndStreamedBytesTracker.h>
#include <vrvOsg/DtFirstTextureStreamedModelAndIndexTracker.h>
#include <vrvOsg/DtIndirectEffectTexturesTemplate.h>
#include <vrvOsg/DtCullShaderConfig.h>
#include <vrvOsg/DtIndirectModelSubGeometry.h>
#include <vrvOsg/DtGpuCullingTcsUserData.h>


#include <vrvMath/DtCommonTypes.h>
#include <vrvMath/DtVector4.h>
#define CPU_SIDE_COMPILATION 1
#include <../data/shaders/indirect/GeometrySpecification.h>

#include <vrvIndirectRendering/DtIndirectViewParameters.h>
#include <vrvIndirectRendering/DtIndirectInstancesInvalidated.h>
#include <vrvIndirectRendering/DtMaterial.h>

#include <vrvUtil/DtVirtualBaseClassCreator.h>

#include <unordered_set>
#include <thread>

namespace osg
{
   class State;
   class RenderInfo;
};

namespace makVrv
{
   class DtGlBuffer;
   class DtIndirectGeometryRegistrar;
   class DtInstanceContainer;
   class DtOsgShaderFilesCache;
   class DtIndirectCullProgram;
   class DtCpuCullingHelper;
   class DtOsgLightPointManager;
   class DtGlDeleteObjectManager;
   class DtCoreGlBufferCreator;
   class DtIndirectClearBufferProgram;
   class DtIndirectModelInfo;
   class DtIndirectGlTextureObject;
   class DtIndirectGlTextureObjectManager;
   class DtGpuCullingTcsUserData;
   class DtThreadCameraStreamDataManager;

   class DtGpuCulling;

   typedef DtVirtualBaseClassCreator<DtGpuCulling, DtInstanceContainer&, const DtCullShaderConfig&> DtGpuCullingCreator;

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

   class DT_DLL_VRVOSG DtGpuCulling
   {
   public:
      struct InstancesOffsetAndNumOfInstances
      {
         int myOffset;
         int myNumOfInstances;

         bool operator==(const InstancesOffsetAndNumOfInstances& rhs) const
         {
            return myOffset == rhs.myOffset && myNumOfInstances == rhs.myNumOfInstances;
         }
      };

      struct StateIdOffsetAndMaxCommands
      {
         int myOffset;
         int myMaxCommands;
      };

      typedef std::vector<StateIdOffsetAndMaxCommands> VectorStateIdOffsetAndMaxCommands;

      //All the culling output buffers need to be per camera so shadows passes work
      typedef std::set<osg::observer_ptr<const osg::Camera> > CameraSet;

   public:
      //friend class so that it can be created only by its creator
      friend DtGpuCullingCreator;

      virtual ~DtGpuCulling();

   protected:
      DtGpuCulling(DtDe& de, DtInstanceContainer& container, const DtCullShaderConfig&);

   private:
      DtGpuCulling() = delete;
      DtGpuCulling(const DtGpuCulling& other) = delete;
      DtGpuCulling& operator=(const DtGpuCulling& other) = delete;

   public:
      virtual void setRegistrar(DtIndirectGeometryRegistrar* registrar);

      virtual void setRegistrarInvalid(void);

      virtual void setDebug(bool debug);

      virtual const DtCullShaderConfig& cullShaderConfig(void) const;

      virtual void updateGpuBuffers(bool amortizeTextures);

      virtual void modelIdsToNumInstancesChanged(void);

      virtual void updatePerInstancePerGeomBuffers(const MapIntToInt& modelIdsToNumInstances, const osg::Camera* camera);

      virtual void doCulling(const DtIndirectViewParameters& viewParameters
         , const osg::FrameStamp* frameStamp
         , const DtGlBuffer* gpuLodVisibleBuffer
         , const DtGlBuffer* gpuDofTransformBuffer
         , const DtGlBuffer* gpuSwitchStateBuffer
         , const DtGlBuffer* gpuPerInstanceDataBuffer
         , const osg::Camera* camera
         , bool& outputInstanceBufferChanged);

      static bool setUpOutputFormatAndBindings();

      static void unsetUpOutputFormatAndBindings();

      virtual bool bindGpuOutputInstanceBuffersWithAddressRange(const osg::Camera* camera) const;

      virtual bool bindCommandBufferAndSsbos(const DtGlBuffer* gpuDofTransformBuffer
         , const DtGlBuffer* gpuDofModelScaleBuffer
         , const DtGlBuffer* gpuUvOffsetBuffer
         , const DtGlBuffer* gpuPerInstanceDataBuffer
         , const osg::Camera* camera);

      virtual void unbindCommandBufferAndSsbos(const osg::Camera* camera);

      // It is an instanced buffer. It advances once per instance. 
      virtual void bindGpuOutputInstanceBufferDebug(const osg::Camera* camera) const;

      virtual void unbindGpuOutputInstanceBufferDebug(const osg::Camera* camera) const;

      virtual bool bindIndirectThingsDebug(const DtGlBuffer* gpuDofTransformBuffer, const osg::Camera* camera);

      virtual void unbindIndirectThingsDebug(const osg::Camera* camera);

      virtual bool useInstanceCount(void) const;

      virtual int numDrawCommands(const osg::Camera* camera) const;

      virtual void releaseGLObjects(void);

      virtual void reloadShaders() const;

      virtual bool buffersInitializedForCamera(const osg::Camera* camera) const;

      virtual unsigned int maxNumInstances(void) const;

      virtual const VectorStateIdOffsetAndMaxCommands& stateIdOffsetAndMaxCommands(void) const;

      virtual const std::vector<InstancesOffsetAndNumOfInstances>& instancesOffsetAndNumInstances(void) const;

      virtual bool readyToUpdateAndGpuBuffersNeedUpdate() const;

      virtual bool gpuBuffersNeedUpdate() const;

      virtual bool textureUpdateDirty() const;

      virtual void setTextureUpdateDirty(bool flag);

      virtual bool perGeomInstanceDataDirty() const;

      virtual void setPerGeomInstanceDataDirty(bool flag);

      virtual bool instancesInvalidatedDirty() const;

      virtual void invalidateInstance(int instanceId, int offset, int size);

      virtual const DtGlBuffer* gpuInputPerGeomInstancesBuffer(void) const;

      virtual const DtGlBuffer* gpuMaterialsBuffer() const;

      virtual void fillOutputInstances(std::vector< DtVector4<int> >& outputInstances, const osg::Camera* camera) const;

      virtual const DtIndirectEffectTexturesTemplate& currentEffectTexturesState() const;

      virtual void setName(const std::string& name);

      virtual const std::string& name(void) const;

   protected:
      virtual void updateGpuInputPerGeomInstancesBufferByInvalidating();
      virtual void updateGpuGeometrySpecificationsBuffer();
      virtual void updateGpuMaterialsBuffer();
      virtual void updateGpuInputPerGeomInstancesBuffer();
      virtual void updateGpuLightPointBuffers();
      virtual void updateGpuIndirectBuffersInstanceCount(const MapIntToInt& modelIdsToNumInstances, DtGpuCullingTcsUserData* userData);
      virtual void updateGpuIndirectBuffersNonInstanceCount(const MapIntToInt& modelIdsToNumInstances, DtGpuCullingTcsUserData* userData);
      virtual void clearGpuIndirectBuffer(DtGpuCullingTcsUserData* userData);
      virtual void clearStateIdCommandCountBuffer();
      virtual void clearLightSourceIndexOutputBuffer(unsigned int maxNumLightSources, DtGpuCullingTcsUserData* userData);


      virtual void updateGpuTexturesBuffer(bool amortizeTextures);

      virtual void updateInstancesOffsetAndInstances(const MapIntToInt& modelIdsToNumInstances);

      virtual void updateInstancesOffsetAndInstancesBuffer(void);

      virtual void updateStateIdToMaxNumCommands(const MapIntToInt& modelIdsToNumInstances);

      virtual void updateStateIdToMaxNumCommandsBuffer(void);

      virtual void deleteBuffers(void);

      virtual void flushSingleCameraSet(CameraSet& cameraSet);

      virtual void incrementUsersAndLoadIfNecessary(DtIndirectModelInfo* info);

      virtual void releaseGlObjectsDecrementUsersAndUnLoadIfNecessary();

      virtual DtGpuCullingTcsUserData* getOrCreate(const osg::Camera* camera);

   protected:
      DtIndirectGeometryRegistrar* myRegistrar;
      bool myRegistrarValid;
      const DtInstanceContainer& myInstanceContainer;

      DtGlBuffer* myGpuInputPerGeomInstancesBuffer;
      bool myPerGeomInstanceDataDirty;
      DtIndirectInstancesInvalidated myInstancesInvalidated;

      std::vector<DtGeometrySpecification> myGeometrySpecifications;

      DtGlBuffer* myGpuGeometrySpecificationsBuffer;

      std::vector<DrawElementsIndirectBindlessCommandNV> myBindlessIndexAndVertexBuffers;

      DtGlBuffer* myBindlessIndexAndVertexBuffersBuffer;
      
      DtGlBuffer* myGpuMaterialsBuffer;

      DtIndirectMaterialVector myMaterials;

      DtGlBuffer* myGpuTexturesBuffer;

      DtIndirectCullProgram* myCullProgram;

      const DtCullShaderConfig myCullShaderConfig;

      std::vector<InstancesOffsetAndNumOfInstances> myInstancesOffsetAndNumInstances;
      DtGlBuffer* myGpuInstancesOffsetAndNumInstancesBuffer;

      unsigned int myMaxNumInstancesPreCulling;
      unsigned int myMaxNumInstances;

      unsigned int myMaxNumLightSources;

      // For when instance count is false or true
      VectorStateIdOffsetAndMaxCommands myStateIdToMaxNumCommands;

      // For when instance count if false
      DtGlBuffer* myGpuStateIdToMaxNumCommandsBuffer;
      DtGlBuffer* myGpuStateIdToCommandCountBuffer;

      // For when instance count is true
      VectorInts myGeomSpecIndexToCommandIndex;
      DtGlBuffer* myGpuSpecIndexToCommandIndexBuffer;

      DtOsgLightPointManager& myLightPointManager;

      DtDe& myDe;

      //texture state
      DtFirstTextureStreamedModelAndIndexTracker myFirstTextureStreamedModelAndIndexTracker;
      unsigned int myLastNumEffectTextures;
      unsigned int myLastNumUniqueGeometriesForGpuTextures;
      bool myTextureUpdateDirty;

      DtModelIdAndStreamedBytesTracker myMaterialBufferTracker;
      DtModelIdAndStreamedBytesTracker mySpecBufferTracker;

      int myStreamedGeometryOffsetIdx;
      int myNumGeometries;

      CameraSet myModelIdsToNumInstancesChanged;

      DtCoreGlBufferCreator& myDtCoreGlBufferCreator;
      DtIndirectEffectTexturesTemplate myCurrentEffectTextureState;

      std::string myName;

      static const int theGpuOutputInstanceBufferIndex;
      static const int theGpuOutputInstanceOffsetInPerInstanceDataBufferIndex;
      static const int theGpuOutputInstanceBufferDebugIndex;

      DtIndirectClearBufferProgram* myClearBufferProgram;

      std::unordered_set<DtIndirectModelInfo*> myModelsBeingUsed;

      DtGlDeleteObjectManager& myGlDeleteObjectManager;

      std::unordered_set<DtIndirectGlTextureObject*> myIndirectTexturesBeingUsed;

      DtIndirectGlTextureObjectManager& myIndirectGlTextureObjectManager;

      static std::thread::id theMainThreadId;

      DtThreadCameraStreamDataManager& myTcsDataManager;

      DtGpuCullingTcsUserDataCreator& myUserDataCreator;
   };
}