DtAggregatedGeometry.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtIndirectGeometryTextures.h>
#include <vrvOsg/DtIndirectSwitchManager.h>
#include <vrvOsg/DtIndirectLodManager.h>
#include <vrvOsg/DtIndirectAggregateHelper.h>

#include <vrvOsg/DtIndirectSwitchManager.h>

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

#include <vrvUtil/DtVirtualBaseClass.h>

#include <osg/Geometry>

#include <tbb/concurrent_queue.h>
#include <tbb/task.h>
#include <boost/thread.hpp>

#include <list>

namespace makVrv
{
   class DtGlBuffer;
   class DtCoreGlBufferCreator;
   class DtAggregatedGeometry;
   class DtAggregatedGeometryCopyDataAsync;
   class DtIndirectGeometryAggregator;
   class DtIndirectGeometryRegistrar;
   class DtIndirectAggregateHelper;

   struct DtAggregateModelInfo 
   {
      //optional
      DtAggregateModelInfo() : myModelID(-1), myDownloaded(false), myLastVertex(0){ ; }
      
      std::string myModelName;
      int myModelID;
      int myLastVertex;
      bool myDownloaded;

      DtGeometrySpecVector myGeometrySpecifications;
      DtIndirectMaterialVector myMaterials;
      OsgTexturesArray myTextures;
      DtPerGeomInstances myPerGeomInstancesTemplate;
      
      DtIndirectSwitchManager::DequeNodeSwitchInfoPairsArray mySwitchPaths;
      DtIndirectLodManager::DequeIndirectLodInfoArray myLodStacks;
   };

   struct DtCopyDataStructure
   {
      DtAggregateModelInfo * myModelInfo;
      osg::ref_ptr<osg::Geometry> myGeomToProcess;
      DtIndirectGeometryTexturesRefPtr myTextureForThisGeometry;
      osg::Matrix myMatrix;
   };

   class DtAggregatedGeometryCopyDataAsync : public tbb::task
   {
   public:
      DtAggregatedGeometryCopyDataAsync(DtAggregatedGeometry * geometry) : myGeometry(geometry)
      {

      };

      virtual tbb::task* execute();

    protected:

      DtAggregatedGeometry *myGeometry;
   };


   class  DT_DLL_VRVOSG DtAggregatedGeometry
   {
   public:
      DtAggregatedGeometry();

      DtAggregatedGeometry(DtCoreGlBufferCreator& coreGlBufferCreator);

      virtual ~DtAggregatedGeometry();

      virtual void releaseGLObjects(osg::State* state) const;
      
      virtual void addGeometryToLoad(const DtCopyDataStructure & cds);

      virtual bool hasDataToAsyncLoad();

      virtual bool hasDataToCopy();
      
      virtual void setDtDe(DtDe* myDe);

      boost::mutex& copyDataMutex() { return myCopyDataMutex; }

      int isCopyingData() { return myIsCopyingData; }

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

   public:


      virtual int numModels(void) const;

      virtual int modelId(int index) const;

      virtual DtAggregateModelInfo* getOrCreateModelInfoFor(int modelId);

      virtual DtAggregateModelInfo* getModelInfoFor(int modelId);

      virtual const DtIndirectSwitchManager::DequeNodeSwitchInfoPairsArray& getVectorSwitchPaths(int modelId) const;

      virtual const DtIndirectLodManager::DequeIndirectLodInfoArray& getVectorLodStacks(int modelId) const;
      
      virtual int vertexAndAttributesBufferSize(void) const;

      virtual osg::Geometry* aggregatedGeometry(void);

   
      virtual void printStats();
      virtual void testDrawUsingDrawElements();

      virtual GLenum indicesType(void) const;

      virtual void copyDataQueue();

protected:
   friend DtIndirectGeometryRegistrar;
   friend DtAggregatedGeometryCopyDataAsync;
   friend DtIndirectGeometryAggregator;

      void configureBuffers();

      virtual void reserveMaxMemory();

      virtual void copyData(DtCopyDataStructure & data);

      virtual void convertToUIntIfNecessary(int indicesCount);

      virtual bool updateBuffers();

      virtual void bindBuffers();

      virtual void unbindBuffers();
      virtual unsigned int vertexBufferSizeInBytes() const;
      virtual unsigned int vertexBufferNumElements() const;
      virtual const void*  verticesPointer() const;
      virtual unsigned int numVertices(void) const;

      virtual unsigned int normalBufferSizeInBytes() const;
      virtual unsigned int normalBufferNumElements() const;
      virtual const void*  normalsPointer() const;
      virtual unsigned int numNormals(void) const;

      virtual unsigned int colorBufferSizeInBytes() const;
      virtual unsigned int colorBufferNumElements() const;
      virtual const void*  colorsPointer() const;
      virtual unsigned int numColors(void) const;

      virtual unsigned int textureCoordsBufferSizeInBytes(unsigned int unit) const;
      virtual unsigned int textureCoordsBufferNumElements(unsigned int unit) const;
      virtual const void*  textureCoordsPointer(unsigned int unit) const;
      virtual unsigned int numTextureCoords(unsigned int unit) const;

      virtual unsigned int textureBufferSizeInBytes() const;

      virtual void copyTextureData(DtGlBuffer* vertexAndAttributesBuffer, int &offset) const;

      virtual const void* indexBufferPointer() const;
      virtual unsigned int indexBufferSizeInBytes() const;
      DtGlBuffer* myVertexAndAttributesBuffer;
      DtGlBuffer* myColorBuffer;
      DtGlBuffer* myNormalBuffer;
      DtGlBuffer* myUVBuffer;
      DtGlBuffer* myIndexBuffer;

      typedef std::map<int, DtAggregateModelInfo *> MapModelsToModelInfo;
      std::vector<int> myEnabledVertexAttribArrays;
      MapModelsToModelInfo myMapModelsToModelInfo;
      std::vector<int> myScratchIndices;
      DtIndirectAggregateHelper myAggregateHelper;
     
      osg::ref_ptr<osg::Geometry> myAggregatedGeometry;


      // not sure if I need a mutex the way I'm using this
      tbb::concurrent_queue<DtCopyDataStructure> myDataToCopy;

      int myLastVertex;
      int myLastIndex;

      tbb::atomic<int> myIsCopyingData;
      boost::mutex myCopyDataMutex;

      mutable boost::mutex myMutableMapModelsToModelInfoMutex;
      
      DtDe* myDtDe;
      
      tbb::atomic<int> myCancelTask;

   };

   class DT_DLL_VRVOSG DtAggregatedGeometryCreator : public DtVirtualBaseClass
   {

   public:
      DtAggregatedGeometryCreator(DtDe& de);

      virtual ~DtAggregatedGeometryCreator();

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

   public:
      static DtAggregatedGeometryCreator& instance(DtDe& de);

      static void registerInstance(DtDe& de,
         DtAggregatedGeometryCreator* instance);

      virtual DtAggregatedGeometry* create(DtCoreGlBufferCreator& coreGlBufferCreator);

      //virtual DtAggregatedGeometry* create();

      DtDe& myDe;
   };



}