DtIndirectGeometryRegistrar.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtOsgThreadingUtils.h>
#include <vrvOsg/DtIndirectGeometryAggregator.h>
#include <vrvOsg/DtIndirectTextureProcessor.h>

#include <vrvIndirectRendering/DtGeometrySpecification.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <osg/Node>
#include <osg/Geometry>
#include <osg/Texture>
#include <osg/Referenced>

#include <tbb/concurrent_queue.h>

#include <boost/signals.hpp>

#include <string>
#include <vector>

#define INDIRECTGEOMETRYREGISTRAR_DEBUG 0

namespace osgEarth {
   class VirtualProgram;
};

namespace makVrv
{
   class DtGlBuffer;

   class DtIndirectGeometryRegistrar;

   class DtIndirectTextureCollectionPolicy;

   class DtAggregatedGeometry;



  
   class  DT_DLL_VRVOSG DtIndirectGeometryRegistrar
   {
   public:
      DtIndirectGeometryRegistrar(const DtIndirectTextureCollectionPolicy& textureCollectionPolicy);

      virtual ~DtIndirectGeometryRegistrar();

      // ! Thread safe methods
      // ! This needs to be 'queued' up because the actual registration can happen when rebuild rebuildIfNeeded
      // ! is called from somewhere in the main thread (e.g. via the drawImplementation of DtIndirectGeometry)
      // \param modelId: The model id
      // \param lodId: The lod id for the given model, with id as modelId (a model can have multiple lods)
      // \param modelFileName is used only for debugging messages for the aggregator
      virtual void queueUpRegisterModelLod(int modelId, int lodId, const DtLodInfo& lodInfo, osg::ref_ptr<const osg::Node> model, const std::string& modelFileName);

      virtual void rebuildIfNeeded(unsigned int contextID);

      virtual int numModels(void) const;

      virtual int modelId(int index) const;

      virtual const VectorGeometryLocations& getVectorGeometryLocations(int modelId) const;

      virtual bool hasVectorGeometryLocations(int modelId) const;

      virtual const VectorMaterials& getVectorMaterials(int modelId) const;

      virtual const VectorOsgTextures& getVectorOsgTextures(const int modelId) const;




      virtual void bindBuffers();

      virtual void unbindBuffers();

      virtual const DtIndirectTextureCollectionPolicy& textureCollectionPolicy(void) const;

      virtual DtIndirectTextureProcessor &textureProcessor();

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

      static osgEarth::VirtualProgram * findCachedVirtualProgram(const std::string & vp_hash);
      static void cacheVirtualProgram(const std::string & vp_hash, osgEarth::VirtualProgram * virtualProgram);

   public:
      struct RebuildResult
      {
         bool geometriesChanged;
         VectorOsgTextures newTexturesFound;
         unsigned int contextID;
         const DtIndirectGeometryRegistrar* sender;
      };

      typedef boost::signal< void(const RebuildResult& result) > RebuildSignal;

      RebuildSignal mySignalRebuild;
   protected:
      virtual void registerModelLod(int modelId, int lodId, const DtLodInfo& lodInfo, osg::ref_ptr<const osg::Node> model, const std::string& modelFileName, VectorOsgTextures& newTexturesFound);

      virtual void deleteGpuData() const;


      virtual void bindVAO();
      virtual void unbindVAO();

      virtual bool allTexturesReady(const int modelId, unsigned int contextID) const;

#if INDIRECTGEOMETRYREGISTRAR_DEBUG

      virtual void testDrawUsingDrawElements();
#endif


protected:
      mutable GLuint myVAO;

      DtGlBuffer* myVertexAndAttributesBuffer;
      DtGlBuffer* myIndexBuffer;

      DtAggregatedGeometry* myAggregatedGeometry;

      class RegisterModelLodOp
      {
      public:
         RegisterModelLodOp() : myLodInfo(0, 0, 0), myModelId(0), myLodId(0)
         {

         }
         RegisterModelLodOp(const RegisterModelLodOp& rhs);
         RegisterModelLodOp& operator=(const RegisterModelLodOp& rhs);
      public:
         int myModelId;
         int myLodId;
         DtLodInfo myLodInfo;
         osg::ref_ptr<const osg::Node> myModel;
         // used only for debugging messages
         std::string myModelFileName;
      };

      typedef tbb::concurrent_queue<RegisterModelLodOp> QueueRegisterModelLodOps;
      QueueRegisterModelLodOps myQueueRegisterModelLodOps;

      const DtIndirectTextureCollectionPolicy& myTextureCollectionPolicy;

      typedef osg::ref_ptr<osgEarth::VirtualProgram> VirtualProgramRef;
      typedef std::map<std::string, VirtualProgramRef> StringVpMap;
      static StringVpMap s_VirtualProgramMap;

      DtIndirectTextureProcessor myTextureProcessor;


   private:
      DtIndirectGeometryRegistrar();
   };

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

      virtual ~DtIndirectGeometryRegistrarCreator();

      virtual DtIndirectGeometryRegistrar* create(DtIndirectTextureCollectionPolicy& textureCollectionPolicy) const;

      static DtIndirectGeometryRegistrarCreator& instance(DtDe& de);

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