DtGpuCulling.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2020 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 <vrvGraphicsUtils/DtCommonTypes.h>
#include <vrvGraphicsUtils/DtVector4.h>

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

#include <vrvUtil/DtVirtualBaseClass.h>

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 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::map<osg::observer_ptr<const osg::Camera>, DtGlBuffer*> CameraToBufferMap;
      typedef std::set<osg::observer_ptr<const osg::Camera> > CameraSet;


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

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

   public:
      virtual ~DtGpuCulling();

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

   public:
      virtual void setRegistrar(DtIndirectGeometryRegistrar* registrar);

      virtual void setCullShaderConfig(const DtCullShaderConfig& cullShaderConfig);

      virtual const DtCullShaderConfig& cullShaderConfig(void) const;

      virtual DtCullShaderConfig& cullShaderConfig(void);

      virtual void updateGpuBuffers(osg::RenderInfo& renderInfo);

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

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

      virtual void unbindGpuOutputInstanceBuffer(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(osg::State* state) const;

      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, const osg::Camera* camera);
      virtual void updateGpuIndirectBuffersNonInstanceCount(const MapIntToInt& modelIdsToNumInstances, const osg::Camera* camera);
      virtual void clearGpuIndirectBuffer(const osg::Camera* camera);
      virtual void clearStateIdCommandCountBuffer();


      virtual void updateGpuTexturesBuffer(osg::RenderInfo& renderInfo);

      virtual void updateInstancesOffsetAndInstances(const MapIntToInt& modelIdsToNumInstances);

      virtual void updateInstancesOffsetAndInstancesBuffer(void);

      virtual void updateStateIdToMaxNumCommands(const MapIntToInt& modelIdsToNumInstances);

      virtual void updateStateIdToMaxNumCommandsBuffer(void);

      virtual bool checkSpecBuffersOk(void) const;

      virtual void releaseCameraToBufferMap(DtGLDeleteObjectManager& deleteManager, const CameraToBufferMap& cameraToBufferMap) const;

      virtual void deleteBuffers(void);

      virtual void deleteCameraToBufferMap(CameraToBufferMap& cameraToBufferMap);

      virtual void flushCameraSpecificBuffers();

      virtual void flushSingleCameraSpecificBufferMap(CameraToBufferMap& cameraToBufferMap);

      virtual void flushSingleCameraSet(CameraSet& cameraSet);
      
   protected:
      DtIndirectGeometryRegistrar* myRegistrar;
      const DtInstanceContainer& myInstanceContainer;

      DtGlBuffer* myGpuInputPerGeomInstancesBuffer;
      bool myPerGeomInstanceDataDirty;
      DtIndirectInstancesInvalidated myInstancesInvalidated;

      DtGlBuffer* myGpuGeometrySpecificationsBuffer;

      std::vector<DtGeometrySpecification> myGeometrySpecifications;

      DtGlBuffer* myGpuMaterialsBuffer;

      DtIndirectMaterialVector myMaterials;

      DtGlBuffer* myGpuTexturesBuffer;

      mutable CameraToBufferMap myMutableGpuIndirectBuffers;

      mutable CameraToBufferMap myMutableGpuOutputInstancesBuffers;

      mutable CameraToBufferMap myMutableGpuOutputInstanceOffsetInPerInstanceDataBuffers;

      mutable CameraToBufferMap myMutableGpuOutputInstancesBuffersDebug;
      
      CameraToBufferMap myGpuIndirectBuffersDebug;

      CameraToBufferMap myGpuLightSourceIndexOutputBuffers;

      DtIndirectCullProgram* myCullProgram;

      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
      mutable DtFirstTextureStreamedModelAndIndexTracker myFirstTextureStreamedModelAndIndexTracker;
      unsigned int myLastNumEffectTextures;
      unsigned int myLastNumUniqueGeometries;
      bool myTextureUpdateDirty;

      DtModelIdAndStreamedBytesTracker myMaterialBufferTracker;
      DtModelIdAndStreamedBytesTracker mySpecBufferTracker;

      int myStreamedGeometryOffsetIdx;
      int myNumGeometries;

      CameraSet myModelIdsToNumInstancesChanged;

      DtCoreGlBufferCreator& myDtCoreGlBufferCreator;
      DtIndirectEffectTexturesTemplate myCurrentEffectTextureState;

      std::string myName;

   };

   class DT_DLL_VRVOSG DtGpuCullingCreator : public DtVirtualBaseClass
   {
   public:
      DtGpuCullingCreator(DtDe &de);

      virtual ~DtGpuCullingCreator();

      virtual DtGpuCulling* create(DtInstanceContainer& container) const;

      static DtGpuCullingCreator& instance(DtDe& de);

      static const std::string& theClassName();
   protected:
      DtDe& myDe;
   };
}