DtIndirectGeometryRegistrar.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2022 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>
#include <unordered_set>

#define INDIRECTGEOMETRYREGISTRAR_DEBUG 0

namespace osgUtil{
   class CullVisitor;
};

namespace osgEarth {
   class VirtualProgram;
};

namespace makVrv
{
   class DtGlBuffer;

   class DtIndirectGeometryRegistrar;

   class DtIndirectTextureCollectionPolicy;
   class DtIndirectModelInfoContainer;

   class DtOsgShaderManager;

   class DtIndirectModelInfo;

   class DtIndirectGeometryRegistrar;

   typedef DtVirtualBaseClassCreator<DtIndirectGeometryRegistrar, const std::string&, const DtIndirectLimitTextureStrategy&, const bool&, const bool& > 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 std::string& textureCollectionPolicyName
         , const DtIndirectLimitTextureStrategy& limitTextureStrategy
         , bool supportsPartialTextureUnloading
         , bool supportsPartialBuffersUnloading
         );

      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, const std::string& modelDefName
         , 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::GraphicsContext* gc);

      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 DtIndirectModelInfo* findModelInfoForModelId(int modelId) const;

      virtual const DtIndirectModelInfoContainer* aggregatedGeometry() const;

      virtual DtIndirectModelInfoContainer* aggregatedGeometry();

      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 int numTexCoordArrays(void) const;
      
      virtual boost::mutex& addingModelsMutex();

      virtual bool supportsPartialTextureUnloading(void) const;

      virtual bool supportsPartialBuffersUnloading(void) const;

      virtual void modelsToBeReloaded(const std::unordered_set<int>& models);

      virtual void unloadUnreferencedTextures(void);

      virtual void trackTexturesAndModels(const std::unordered_set<int>& models, bool reloading);

      virtual void findModelInfosThatUseThisImageFileForItsTextures(std::set<DtIndirectModelInfo*>& modelInfos, const std::string& absoluteFileName) const;
   protected:
      virtual void registerModel(int modelId
         , osg::ref_ptr<const osg::Node> model, const std::string& modelFileName, const std::string& modelDefName
         , bool daylightControlled, bool cullFaceEnabled = true, const DtIndirectPolygonOffset& polygonOffset = DtIndirectPolygonOffset(0.0f, 0.0f));

   protected:

      DtIndirectModelInfoContainer* myModelInfoContainer;

      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;
         std::string myModelDefName;
         bool myCullFaceEnabled;
         DtIndirectPolygonOffset myPolygonOffset;
         bool myDaylightControlled;
      };

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

      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;

      std::map< osg::ref_ptr<osg::Texture>, std::set<int> > myTextureToModelsThatAreUsingIt;

      std::unordered_map< std::string, std::set<int> > myImagesToModelsThatAreUsingIt;

      const bool mySupportsPartialTextureUnloading;
      const bool mySupportsPartialBuffersUnloading;
   };

}