DtIndirectModelInfo.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <string>

#include <vrvOsg/DtIndirectSwitchManager.h>
#include <vrvOsg/DtIndirectLodManager.h>
#include <vrvOsg/DtIndirectDofManager.h>
#include <vrvOsg/DtIndirectGeometryTextures.h>
#include <vrvOsg/DtIndirectUvOffsetManager.h>
#include <vrvOsg/DtIndirectModelSubGeometry.h>

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

#include <vrvIndirectRendering/DtMaterial.h>
#include <vrvIndirectRendering/DtPerGeomInstance.h>

#include <vrvUtil/DtVirtualBaseClassCreator.h>

#include <boost/thread/mutex.hpp>

#include <unordered_set>

namespace makVrv
{
   class DtDe;
   class DtIndirectModelSubGeometry;
   class DtIndirectLimitTextureStrategy;
   class DtGlDeleteObjectManager;
   class DtGpuCulling;

   class DtIndirectModelInfo;

   typedef DtVirtualBaseClassCreator<DtIndirectModelInfo> DtIndirectModelInfoCreator;

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

   struct DtIndirectSubGeoBindlessBuffers
   {
      BindlessPtrNV myVertexBufferBindless = {};
      BindlessPtrNV myAdditionalBufferBindless = {};
      BindlessPtrNV myIndexBufferBindless = {};
   };

   class DT_DLL_VRVOSG DtIndirectModelInfo
   {
   public:

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

      virtual ~DtIndirectModelInfo();

      DtIndirectModelInfo() = delete;

      DtIndirectModelInfo(const DtIndirectModelInfo&) = delete;

      DtIndirectModelInfo& operator=(const DtIndirectModelInfo&) = delete;

   protected:

      DtIndirectModelInfo(DtDe& de);

   public:

      virtual void unloadBuffers();
      
      virtual bool buffersUploadedToGpu() const;

      virtual bool processGpuBufferUploads(unsigned int& uploadedMemory);

      virtual void texturesSet(std::map< const DtIndirectTexturePrototype*, int >& texturesSet) const;
      
      virtual void addUser(const DtGpuCulling* user);

      virtual void removeUser(const DtGpuCulling* user);

      virtual void computeMaxTextureResolution(const DtIndirectLimitTextureStrategy& limitStrategy);

      virtual const BindlessPtrNV& vertexBufferBindless(int index) const;

      virtual const BindlessPtrNV& additionalBufferBindless(int index) const;

      virtual const BindlessPtrNV& indexBufferBindless(int index) const;

      virtual int numSubGeometries() const;

      virtual int maxCoords(int index) const;

      virtual int numVertices(int index) const;

      virtual int numIndices(int index) const;
      
      virtual void addSubGeometry(DtIndirectModelSubGeometry* modelSubGeometry);

      virtual DtIndirectModelSubGeometry* subGeometry(int index) const;
      
      virtual void promoteDataFromSubGeosToMe();

   protected:

      virtual void resetGpuUploads();

      virtual bool isDefaultTexture(const DtIndirectTexturePrototype* texture) const;

      virtual bool glBuffersContainAnyData() const;

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

      virtual void createIndirectBuffers();

      virtual void deleteIndirectBuffers();

      virtual void computeChunkUploadSize(unsigned int& desiredUploadSize, unsigned int& maxUploadSize) const;

      virtual void prepareToUploadGpuDataForBuffer(DtGlBuffer& buffer, std::vector<uint8_t>& stagingData);

      virtual void prepareToUploadGpuData();

      virtual void updateBindlessPointers();

   public:

      std::string myModelName;

      std::string myModelDefName;

      int myModelID;

      DtGeometrySpecVector myGeometrySpecifications;

      DtIndirectMaterialVector myMaterials;

      std::vector<DtIndirectGeometryTextures> myTextures;

      DtPerGeomInstances myPerGeomInstancesTemplate;

      DtIndirectUvOffsetManager::AnnotationToUvOffsetMap myAnnotationToUvOffsetIdMap;

      DtIndirectUvOffsetManager::ScrollableUvOffsetIdsAndMultipliers myScrollableUvOffsetIdsAndMultipliers;

      DtIndirectSwitchManager::DequeNodeSwitchInfoPairsArray mySwitchPaths;

      DtIndirectLodManager::DequeIndirectLodInfoArray myLodStacks;
      DtIndirectDofManager::DequeNodeDofInfoPairs myDofPaths;

      int myNumLightSources;

      DtVector2<int> myMaxTextureResolutionInXandY;

   protected:

      static const BindlessPtrNV theInvalidBindless;

      DtDe& myDe;
      DtGlDeleteObjectManager& myGlDeleteObjectManager;

      struct GpuBufferUploadInfo
      {
         unsigned int myTotalSize = 0;
         unsigned int myUploadOffset = 0;
         unsigned int myUploadSize = 0;
         const unsigned char* myUploadData = nullptr;
         DtGlBuffer* myBuffer = nullptr;
      };

      std::vector<GpuBufferUploadInfo> myGpuBufferUploads;

      std::unordered_set<const DtGpuCulling*> myUsers;
      boost::mutex myUserMutex;

      DtGlBuffer* myVertexAndAttributesBuffer = nullptr;
      DtGlBuffer* myIndexBuffer = nullptr;

      bool myBuffersUploadedToGpu;

      std::vector<uint8_t> myVertexBufferData;
      std::vector<uint8_t> myIndexBufferData;

      std::vector<DtIndirectModelSubGeoProps> mySubGeoPropsVec;
      std::vector<DtIndirectSubGeoBindlessBuffers> mySubGeoBindlessBuffersVec;

      std::vector<DtIndirectModelSubGeometry*> myVectorModelSubGeometries;
   };
}