DtGpuCullingAndLod.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/DtCullShaderConfig.h>

#include <vrvGraphicsUtils/DtCommonTypes.h>

#include <vrvIndirectRendering/DtGpuCullingAndLodDefines.h>
#include <vrvIndirectRendering/DtGeometrySpecification.h>

#include <vrvUtil/DtVirtualBaseClass.h>

namespace osg
{
   class State;
   class RenderInfo;
};

namespace makVrv
{
   class DtGlBuffer;
   class DtIndirectGeometryRegistrar;
   class DtInstanceContainer;
   class DtOsgShaderFilesCache;
   class DtIndirectCullPass;
   class DtCpuCullingHelper;

   class DT_DLL_VRVOSG DtGpuCullingAndLod
   {
   public:
      struct InstancesOffsetAndNumOfInstances
      {
         int offset;
         int numOfInstances;
      };

      struct StateIdOffsetAndMaxCommands
      {
         int offset;
         int maxCommands;
      };

      typedef std::vector<StateIdOffsetAndMaxCommands> VectorStateIdOffsetAndMaxCommands;

   protected:
      DtGpuCullingAndLod(DtDe& de);

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

   public:
      virtual ~DtGpuCullingAndLod();

   private:
      DtGpuCullingAndLod();
      DtGpuCullingAndLod(const DtGpuCullingAndLod &other);
      DtGpuCullingAndLod &operator=(const DtGpuCullingAndLod &other);

   public:
      virtual void setRegistrar(DtIndirectGeometryRegistrar* registrar);

      virtual void setCullShaderConfig(const DtCullShaderConfig& cullShaderConfig);

      virtual const DtCullShaderConfig& cullShaderConfig(void) const;

      virtual void updateGpuBuffers( DtIndirectRenderingParameters& irParams
         , const MapIntToInt& modelIdsToNumInstances
         , osg::RenderInfo& renderInfo); 

      virtual void doCullingAndLOD(const DtIndirectViewParameters& viewParameters
         , DtIndirectRenderingParameters& irParams
         , osg::RenderInfo& renderInfo
         , DtGlBuffer* gpuLodVisibleBuffer);

      virtual void bindGpuOutputInstanceBuffer(void) const;

      virtual void unbindGpuOutputInstanceBuffer(void) const;

      virtual bool bindIndirectThings();

      virtual void unbindIndirectThings();

      virtual bool useInstanceCount(void) const;

      virtual int numDrawCommands(void) const;

      virtual void setShadersFolderPath(const std::string& shaderFolderPath);

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

      virtual void setShadersFileCache(DtOsgShaderFilesCache* shaderFilesCache);

      virtual const DtOsgShaderFilesCache* shadersFileCache(void) const;

      virtual void releaseGLObjects(osg::State* state) const;

      virtual void reloadShaders() const;

      virtual unsigned int maxNumInstances(void) const;

      virtual const VectorStateIdOffsetAndMaxCommands& stateIdOffsetAndMaxCommands(void) const;

      virtual void setInstanceContainer(DtInstanceContainer * instanceContainer);

      virtual bool readyToUpdateBuffers();

      virtual bool needTextureUpdate() const;

   protected:
      virtual void updateGpuInputInstancesBuffer();
      virtual void updateGpuInputPerGeomInstancesBuffer();
      virtual void updateGpuGeometrySpecificationsBuffer(const int numGeometries);
      virtual void updateGpuMaterialsBuffer(const int numGeometries);
      virtual void updateGpuGeometryOffsetAndSizeBuffer(int& numGeometries);
      virtual void updateGpuIndirectBuffer();
      virtual void clearInstanceCountofGpuIndirectBuffer();
      virtual void clearStateIdCommandCountBuffer();

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

      virtual void updateInstancesOffsetAndInstances(const MapIntToInt& modelIdsToNumInstances);

      virtual void updateStateIdMaxNumCommands(const MapIntToInt& modelIdsToNumInstances);

      virtual bool checkSpecBuffersOk(void) const;

   protected:
      DtIndirectGeometryRegistrar* myRegistrar;
      DtInstanceContainer * myInstanceContainer;

      DtGlBuffer* myGpuInputInstancesBuffer;

      DtGlBuffer* myGpuInputPerGeomInstancesBuffer;

      DtGlBuffer* myGpuGeometrySpecificationsBuffer;
     
      std::vector<DtGeometrySpecification> myGeometrySpecifications;

      std::vector<DtIndirectOffsetAndSize> myGeometryOffsetAndSizes;

      DtGlBuffer* myGpuMaterialsBuffer;

      DtGlBuffer* myGpuIndirectBuffer;

      DtGlBuffer* myGpuOutputInstancesBuffer;

      DtIndirectCullPass* myCullPass;

      DtGlBuffer* myGpuTexturesBuffer;

      MapIntToInt myModelIdToIndex;

      DtCullShaderConfig myCullShaderConfig;

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

      std::string myShaderFolderPath;
      DtOsgShaderFilesCache* myShaderFilesCache;

      unsigned int myMaxNumInstances;

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

      DtDe& myDe;
      
      //texture state
      unsigned int myLastNumEffectTextures;
      mutable int myMutableFirstTextureStreamedModel;
      mutable int myMutableFirstTextureStreamedIndex;
      bool myNeedTextureUpdate;

      int myStreamedMaterialModelID;
      int myStreamedMaterialBytes;

      int myStreamedSpecModelID;
      int myStreamedSpecBytes;
      int myStreamedSpecModelGeomIndex;


      int myStreamedGeometryOffsetModelID;
      int myNumGeometries;
   };

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

      virtual ~DtGpuCullingAndLodCreator();

      virtual DtGpuCullingAndLod* create() const;

      static DtGpuCullingAndLodCreator& instance(DtDe& de);

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