DtIndirectGeometryRegistrar.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2021 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 <vrvCore/DtVirtualBaseClassCreator.h>

#include <vrvUtil/signalslib.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 <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 DtOsgShaderManager;

   struct DtAggregateModelInfo;

   class DtIndirectGeometryRegistrar;

   typedef DtVirtualBaseClassCreator<DtIndirectGeometryRegistrar, DtIndirectTextureCollectionPolicy&> DtIndirectGeometryRegistrarCreator;

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




   class  DT_DLL_VRVOSG DtIndirectGeometryRegistrar : public osg::Referenced
   {
   protected:
      friend DtIndirectGeometryRegistrarCreator;

   protected:
      DtIndirectGeometryRegistrar(DtDe& de, const DtIndirectTextureCollectionPolicy& textureCollectionPolicy);

      virtual ~DtIndirectGeometryRegistrar();

   private:
       DtIndirectGeometryRegistrar() = delete;

      DtIndirectGeometryRegistrar(const DtIndirectGeometryRegistrar& other) = delete;

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

      DtIndirectGeometryRegistrar& operator=(const DtIndirectGeometryRegistrar& other) = delete;
   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), bool daylightControlled = false);

      virtual void processRegisterModelQueue(DtOsgRenderer* renderer);

      virtual bool beingProcessed();

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

      virtual unsigned int numModelsInQueue() const;

      virtual int numModels(void) const;

      virtual int modelId(int index) const;

      virtual int numGeometriesForModelID(int modelId) const;

      virtual bool isModelDownloaded(int modelId) const;

      virtual const DtAggregateModelInfo* modelInfoForModelID(int modelId) const;

      virtual const DtAggregatedGeometry* aggregatedGeometry() const;

      virtual DtAggregatedGeometry* aggregatedGeometry();

      virtual void bindBuffers() const;

      virtual void unbindBuffers() const;

      virtual const DtIndirectTextureCollectionPolicy& textureCollectionPolicy(void) const;

      virtual DtIndirectTextureProcessor& textureProcessor();

      virtual const DtIndirectEffectTexturesTemplate& effectTexturesState(void) const;

      virtual DtIndirectGeometryStateManager& stateManager(void) const;

      virtual GLenum indicesType(void) const;

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

      virtual bool registeredModelsDirty() const;

      virtual void drainModelQueue(DtOsgRenderer* renderer);

      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 daylightControlled, 
         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();
         RegisterModelOp(const RegisterModelOp& rhs);
         RegisterModelOp& operator=(const RegisterModelOp& rhs);
         ~RegisterModelOp();
      public:
         int myModelId;
         osg::ref_ptr<const osg::Node> myModel;
         // used only for debugging messages
         std::string myModelFileName;
         bool myCullFaceEnabled;
         DtIndirectPolygonOffset myPolygonOffset;
         bool myDaylightControlled;
      };

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

      const DtIndirectTextureCollectionPolicy* myTextureCollectionPolicy;

      osg::ref_ptr<DtIndirectTextureProcessor> myTextureProcessor;

      mutable bool myRegisteredModelsDirty;
      unsigned int myLastRebuildNumber;

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

      mutable DtIndirectGeometryStateManager myMutableStateContainer;

      DtDe& myDe;

      DtOsgShaderManager& myShaderManager;
   };

}