DtIndirectGeometryRegistrar.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2020 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 <vrvOsg/DtIndirectEffectTexturesTemplate.h>
#include <vrvOsg/DtIndirectGeometryStateManager.h>
#include <vrvOsg/DtIndirectSwitchManager.h>
#include <vrvOsg/DtIndirectLodManager.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 <tbb/atomic.h>
#include <tbb/task.h>

#include <boost/signals.hpp>

#include <string>
#include <vector>


#define INDIRECTGEOMETRYREGISTRAR_DEBUG 0

namespace osgUtil{
   class CullVisitor;
};

namespace osgEarth {
   class VirtualProgram;
};

namespace makVrv
{
   class DtGlBuffer;

   class DtIndirectGeometryRegistrar;

   class DtIndirectTextureCollectionPolicy;

   class DtAggregatedGeometry;

   class DtAggregatedGeometryCreator;
   class DtIndirectGeometryAggregatorCreator;
   class DtCoreGlBufferCreator;
   class DtOsgShaderManager;





   class  DT_DLL_VRVOSG DtIndirectGeometryRegistrar : public osg::Referenced
   {
   protected:
      DtIndirectGeometryRegistrar(DtDe& de,
         const DtIndirectTextureCollectionPolicy& textureCollectionPolicy,
         DtAggregatedGeometryCreator& aggregatedGeometryCreator,
         DtIndirectGeometryAggregatorCreator& indirectGeometryAggregatorCreator,
         DtCoreGlBufferCreator& coreGlBufferCreator);

      friend class DtIndirectGeometryRegistrarCreator;

   protected:

      virtual ~DtIndirectGeometryRegistrar();

   private:
       DtIndirectGeometryRegistrar();

      DtIndirectGeometryRegistrar(const DtIndirectGeometryRegistrar& other);

      DtIndirectGeometryRegistrar(const DtIndirectGeometryRegistrar& lhs, const osg::CopyOp& copyop);

      DtIndirectGeometryRegistrar& operator=(const DtIndirectGeometryRegistrar& other) { return *this; }
      
      

   public:

      virtual void setName(const std::string& name);

      // ! Thread safe method - can be called in any paging thread or the main render thread
      // ! 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 modelFileName is used only for debugging messages for the aggregator
      virtual void queueUpRegisterModel(int modelId, osg::ref_ptr<const osg::Node> model, const std::string& modelFileName,
         bool cullFaceEnabled = false,
         const DtIndirectPolygonOffset& polygonOffset = DtIndirectPolygonOffset(0.0f,0.0f));

      virtual void processRegisterModelQueue(DtOsgRenderer* renderer);

      virtual bool beingProcessed();

      virtual unsigned int rebuildIfNeeded(osg::RenderInfo& renderInfo, unsigned int currentFrameNum);

      virtual unsigned int numModelsInQueue();

      virtual int numModels(void) const;

      virtual int modelId(int index) const;

      virtual bool isModelDownloaded(int modelId) const;

      virtual DtAggregateModelInfo* modelInfoForModelID(int modelId) const;

      virtual int numGeometriesForModelID(int modelId) const;

      virtual void bindBuffers();

      virtual void unbindBuffers();

      virtual const DtIndirectTextureCollectionPolicy& textureCollectionPolicy(void) const;

      virtual DtIndirectTextureProcessor& textureProcessor();

      virtual const DtIndirectEffectTexturesTemplate& effectTexturesState(void) const;

      virtual DtIndirectGeometryStateManager& stateContainer(void) const;

      virtual GLenum indicesType(void) const;

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

      virtual bool registeredModelsDirty();

      virtual void drainModelQueue(DtOsgRenderer* renderer);

      virtual DtAggregatedGeometry* aggregatedGeometry();

      virtual void setPagerHandlesModelLoading(bool value);
      virtual bool pagerHandlesModelLoading();
      
      virtual boost::mutex& addingModelsMutex();

   protected:
      virtual void registerModel(int modelId, osg::ref_ptr<const osg::Node> model, const std::string& modelFileName, 
         bool cullFaceEnabled = true,
         const DtIndirectPolygonOffset& polygonOffset = DtIndirectPolygonOffset(0.0f, 0.0f));

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

   protected:


      DtAggregatedGeometry* myAggregatedGeometry;

      DtIndirectEffectTexturesTemplate myEffectTexturesState;
      bool myPagerHandlesModelLoading;
      
      class DT_DLL_VRVOSG RegisterModelOp
      {
      public:
         RegisterModelOp()
             : myModelId(0)
             , myCullFaceEnabled(true)
         {

         }
         RegisterModelOp(const RegisterModelOp& rhs);
         RegisterModelOp& operator=(const RegisterModelOp& rhs);
      public:
         int myModelId;
         osg::ref_ptr<const osg::Node> myModel;
         // used only for debugging messages
         std::string myModelFileName;
         bool myCullFaceEnabled;
         DtIndirectPolygonOffset myPolygonOffset;
      };

      typedef tbb::concurrent_queue<RegisterModelOp> QueueRegisterModelOps;
      QueueRegisterModelOps myQueueRegisterModelOps;

      const DtIndirectTextureCollectionPolicy* myTextureCollectionPolicy;

      osg::ref_ptr<DtIndirectTextureProcessor> myTextureProcessor;

      mutable bool myRegisteredModelsDirty;
      unsigned int myLastRebuiltFrameNum;

      DtIndirectGeometryAggregator* myAggregator;
      tbb::atomic<bool> myBeingProcessed;
      boost::mutex myAddingModelsMutex;

      mutable DtIndirectGeometryStateManager myMutableStateContainer;

      DtDe& myDe;

      DtOsgShaderManager& myShaderManager;
   };

   class DT_DLL_VRVOSG DtIndirectGeometryRegistrarCreator : public DtVirtualBaseClass
   {
   public:

      DtIndirectGeometryRegistrarCreator(DtDe& de);

      virtual ~DtIndirectGeometryRegistrarCreator();

      //init is also called here so the registrar is not created without init being called. 
      // This must be done the same way in all derived creators!!!!!
      virtual DtIndirectGeometryRegistrar* create(DtIndirectTextureCollectionPolicy& textureCollectionPolicy,
         DtAggregatedGeometryCreator& aggregatedGeometryCreator,
         DtIndirectGeometryAggregatorCreator& indirectGeometryAggregatorCreator,
         DtCoreGlBufferCreator& coreGlBufferCreator) const;

      static DtIndirectGeometryRegistrarCreator& instance(DtDe& de);

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