DtIndirectGeometry.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/DtIndirectGeometryRegistrar.h>
#include <vrvOsg/DtIndirectSwitchManager.h>
#include <vrvOsg/DtIndirectLodManager.h>
#include <vrvOsg/DtIndirectGeometryInstance.h>
#include <vrvOsg/DtCullShaderConfig.h>
#include <vrvOsg/DtGlVaoManager.h>

#include <vrvIndirectRendering/DtInstanceContainer.h>
#include <vrvIndirectRendering/DtGpuCullingAndLodDefines.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <boost/signals2.hpp>

#include <osg/Drawable>
#include <osg/Uniform>
#include <osg/OperationThread>

#include <boost/unordered_map.hpp>
#include <tbb/atomic.h>
#include <tbb/concurrent_queue.h>

#include <string>

#define INDIRECTGEOMETRY_CONSTRUCT_DESTRUCT_DEBUG 0

namespace osg
{
   class NodeVisitor;
   class State;
}

namespace osgEarth {
   class VirtualProgram;
};

namespace makVrv
{
   class DtIndirectGeometryRegistrar;
   class DtCullShaderConfig;
   class DtGpuCullingAndLod;
   class DtGlBuffer;
   class DtOsgShaderFilesCache;
   class DtTerrainPatchObjectManager;
   class DtOsgCullVisitor;
   class DtIndirectGeometryInitMainThreadJob;
   class DtIndirectGeometryUpdateBuffersMainThreadJob;
   class DtGLDeleteObjectManager;

   class DT_DLL_VRVOSG DtIndirectGeometry : public osg::Drawable
   {
   public:
      DtIndirectGeometry(bool terrainPatch, const DtIndirectFadeParameters& fadeParameters);

   protected:
      virtual ~DtIndirectGeometry();

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

   public:

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

      virtual void setRegistrar(DtIndirectGeometryRegistrar* registrar);

      virtual DtIndirectGeometryRegistrar* registrar();

      virtual void setCullShaderConfig(const DtCullShaderConfig& cullShaderConfig);

      virtual const char* className() const;

      virtual void drawImplementation(osg::RenderInfo& renderInfo) const;

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

      virtual void addInstance(const DtIndirectGeometryInstance& instance);

      virtual void addInstance(int modelId, const osg::Matrixd& xForm);
      
      virtual void removeAllInstances(void);

      virtual void accept(osg::NodeVisitor& nv);

      virtual void setParent(const osg::Group* parent);

      virtual void setDebugDrawString(const std::string& drawString);

      virtual void setRegistrarInvalid(void);

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

      virtual void accept(osg::PrimitiveFunctor& functor) const;

      void setupIndirect(DtDe &de);

      virtual const osg::Geode* parentGeode(void) const;
      virtual osg::Geode* parentGeode(void);

      virtual void setLocalOriginTransform(const osg::Matrixd& localOriginTransform);

      virtual osg::Matrixd& localOriginTransform();

      virtual bool actuallyAddQueuedUpInstances(void);

      virtual void launchMainThreadJobAndWait(DtDe& de, DtOsgRenderer& renderer);

      virtual boost::condition_variable & waitCondition();

      virtual void updateGpuInstanceBuffers(osg::RenderInfo& renderInfo);

      friend class DtIndirectGeometryInitMainThreadJob;

   protected:

      virtual bool addInstanceActual(const DtIndirectGeometryInstance& instance);

      virtual GLuint getOrCreateAndRecordVAO(osg::State* state) const;
      virtual void recordVAO(GLuint vao) const;

      virtual void setupShadersIfNecessary(DtDe& de);

      virtual void setupDebugUniforms(DtDe& de);

      virtual void installIndirectRenderingProgram(DtOsgShaderFilesCache* shaderFilesCache, 
         const std::string& shaderFolderPath, osg::StateSet* ss, DtDe& de) const;

      virtual void installDefaultMaterial(osg::StateSet* ss);

      virtual void slot_reloadShaders();

      virtual void updateIndicesCount(const DtAggregateModelInfo& modelInfo);

      virtual void createCullingAndLodIfNecessary(DtDe& de);

      virtual void createManagersIfNecessary(DtDe& de);

      virtual void drawFromCommandBuffer(osg::RenderInfo& renderInfo) const;

      virtual void reloadShadersIfNecessary(void) const;

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


   protected:
      osg::ref_ptr<DtIndirectGeometryRegistrar> myRegistrar;

      tbb::concurrent_queue<DtIndirectGeometryInstance> myQueueInstancesToAdd;

      DtGpuCullingAndLod* myCullingAndLOD;

      MapIntToInt myModelIDsToInstances;

      std::string myDrawString;
      
      bool myIsTerrainPatch;

      DtIndirectEffectTexturesTemplate myEffectTexturesState;

      bool myReloadSlotConnected;
      boost::signals2::connection myConnection;

      osg::Matrixd myLocalOriginTransformMatrix;

      int myNumIndicesAcrossAllModels;

      bool myLastDebugIndirectColorOn;
      bool myLastMissingTextureColorOn;

      DtTerrainPatchObjectManager* myTerrainPatchObjectManager;

      DtGlVaoManager* myVaoManager;

#if INDIRECTGEOMETRY_CONSTRUCT_DESTRUCT_DEBUG
      static tbb::atomic<int> myRefCount;
#endif

      mutable DtIndirectRenderingParameters myMutableIrParams;

      mutable DtInstanceContainer myMutableInstanceContainer;

      mutable unsigned int myMutableLastFrameRebuilt;
      mutable unsigned int myMutableLastFrameTexturesUpdated;

      mutable DtIndirectSwitchManager* myMutableSwitchManager;

      mutable DtIndirectLodManager* myMutableLodManager;
      DtCullShaderConfig myCullShaderConfig;

      mutable bool myMutableShadersSetup;


   protected:
      mutable bool myMutableShouldReloadShaders;

      boost::condition_variable myWaitCondition;
      boost::mutex myWaitMutex;

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

      boost::mutex myInternalsMutex;
   
      osg::ref_ptr<DtIndirectGeometryInitMainThreadJob> myMainThreadInitJob;
      osg::ref_ptr<DtIndirectGeometryUpdateBuffersMainThreadJob> myMainThreadUpdateBuffersJob;

      DtIndirectFadeParameters myFadeParameters;
   };

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

      virtual ~DtIndirectGeometryCreator();

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

   public:
      virtual DtIndirectGeometry* create(bool terrainPatch, const DtIndirectFadeParameters& fadeParameters) const;

      static DtIndirectGeometryCreator& instance(DtDe& de);

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