DtIndirectGeometry.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/DtIndirectGeometryRegistrar.h>
#include <vrvOsg/DtIndirectGeometryInstance.h>
#include <vrvOsg/DtCullShaderConfig.h>
#include <vrvOsg/DtIndirectGeometryInitMainThreadJob.h>
#include <vrvOsg/DtIndirectGeometryUpdateMainThreadJob.h>
#include <vrvOsg/DtIndirectGeometryUpdateBuffersMainThreadJob.h>

#include <vrvIndirectRendering/DtInstanceContainer.h>
#include <vrvIndirectRendering/DtIndirectViewParameters.h>
#include <vrvIndirectRendering/DtIndirectFadeParameters.h>
#include <vrvIndirectRendering/DtIndirectModelScalingAlgorithm.h>
#include <vrvIndirectRendering/DtIndirectAnnotationAndUvOffset.h>

#include <vrvGraphicsUtils/DtVector3.h>

#include <vrvCore/DtVirtualBaseClassCreator.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <matrix/vlTaitBryan.h>

#include <osg/Drawable>
#include <osg/Uniform>
#include <osg/StateSet>
#include <osg/OperationThread>
#include <osgSim/MultiSwitch>

#include <tbb/concurrent_queue.h>

#include <atomic>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <tuple>

namespace osg
{
   class NodeVisitor;
   class State;
}

namespace osgEarth {
   class VirtualProgram;
};

namespace makVrv
{
   class DtIndirectGeometryRegistrar;
   class DtCullShaderConfig;
   class DtGpuCulling;
   class DtGlBuffer;
   class DtOsgCullVisitorParameters;

   class DtIndirectGeometryInitMainThreadJob;
   class DtIndirectGeometryUpdateBuffersMainThreadJob;
   class DtVirtualProgramCache;

   class DtIndirectDrawComponent;
   class DtIndirectDefaultDrawComponent;
   class DtIndirectLightPointDrawComponent;
   class DtIndirectDebugCullComponent;

   class DtIndirectSwitchManager;
   class DtIndirectDofManager;
   class DtIndirectLodManager;
   class DtIndirectUvOffsetManager;
   class DtIndirectPerInstanceDataManager;
   class DtIndirectShaderConstants;
   class DtOsgLightPointManager;

   class DtIndirectVaoManager;

   class DtCoordinateSystem;

   class DtIndirectGeometry;

   typedef DtVirtualBaseClassCreator<DtIndirectGeometry, const DtCullShaderConfig&, const bool&, const bool& > DtIndirectGeometryCreator;

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

   class DT_DLL_VRVOSG DtIndirectGeometry : public osg::Drawable
   {
   public:
      friend DtIndirectGeometryCreator;

   protected:
      DtIndirectGeometry(DtDe& de, const DtCullShaderConfig& cullShaderConfig, bool terrainPatch, bool managesIndividualInstances);

      virtual ~DtIndirectGeometry();

   private:
      DtIndirectGeometry() = delete;

      DtIndirectGeometry(const DtIndirectGeometry& other) = delete;
      DtIndirectGeometry& operator=(const DtIndirectGeometry& other) = delete;

   public:

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

      virtual void setRegistrar(DtIndirectGeometryRegistrar* registrar);

      virtual DtIndirectGeometryRegistrar* registrar();

      virtual const char* className() const;

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

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

      virtual int addInstance(const DtIndirectGeometryInstance& instance);

      virtual int addInstance(int modelId, const osg::Matrixd& xForm, float modelScale, float modelRadius, int lightPointGroupId);

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

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

      virtual void setRegistrarInvalid(void);

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

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

      virtual void setupIndirect();

      virtual void setupIndirectShadersOnly();

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

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

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

      virtual bool actuallyAddQueuedUpInstances(void);

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

      virtual boost::condition_variable& waitCondition();

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


      virtual void setFadeParameters(const DtIndirectFadeParameters& fadeParameters);

      virtual const DtIndirectFadeParameters& fadeParameters(void) const;

      virtual void perCameraUpdateAndCull(osg::RenderInfo& renderInfo, const osg::Camera* camera, const osg::Matrix& modelViewMatrix, const osg::FrameStamp* frameStamp);

      virtual void fillViewParameters(DtIndirectViewParameters& destViewParameters, const osg::Matrix& modelViewMatrix, const osg::Camera* camera, osg::RenderInfo& renderInfo) const;

      virtual void fillAltitude3d(DtIndirectViewParameters& destViewParameters, const Vector3_64& eye) const;

      virtual void setUpdateBuffersJobsRequiredCurrentFrame(bool requiredCurrentFrame);
      virtual bool updateBuffersJobsRequiredCurrentFrame(void) const;

      virtual bool readyToRender(const int instanceIdInIndirect) const;


      virtual bool instanceEverAdded(void) const;

      virtual int numValidInstances(void) const;

   public:
      static void setTrackObjects(bool val);
      static bool trackObjects(void);

      static int numIndirectGeometries(void);

      static void initializeDtDeKeyedInstances(DtDe& de);
   protected:

      virtual bool addInstanceActual(const DtIndirectGeometryInstance& instance);

      virtual void setupShadersIfNecessary();

      virtual void setupDebugUniforms();

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

      virtual void slot_reloadShaders();

      virtual void updateIndicesCount(const DtIndirectModelInfo& modelInfo, int instanceContainerIndex);

      virtual void updateModelIdsToInstances(int modelId, int instanceId, bool add);

      virtual void drawFromCommandBuffer(osg::RenderInfo& renderInfo, const DtIndirectViewParameters& viewParameters, const osg::Camera* camera) const;


      virtual void updateInstancePositionOrientationAddedActual(const DtIndirectGeometryInstance& instance, int outInstanceIndex);

      virtual void updateInstanceSwitchesAddedActual(const DtIndirectGeometryInstance& instance, int outInstanceIndex);

      virtual void updateInstanceSequencesAddedActual(const DtIndirectGeometryInstance& instance, int outInstanceIndex);

      virtual void updateInstanceUvOffsetsAddedActual(const DtIndirectGeometryInstance& instance, int outInstanceIndex);

      virtual void updateInstanceColorAddedActual(const DtIndirectGeometryInstance& instance, int outInstanceIndex);

      virtual void updateInstanceOtherData0AddedActual(const DtIndirectGeometryInstance& instance, int outInstanceIndex);

      virtual void updateInstanceVisibilityLightPointMaxDistanceActual(const DtIndirectGeometryInstance& instance, int outInstanceIndex);

      virtual bool updateInstanceDeletionBeforeAddedActual(const DtIndirectGeometryInstance& instance);

      virtual void updateInstancesDofsAddedActual(const DtIndirectGeometryInstance& instance, int outInstanceIndex);

      virtual void reloadShadersIfNecessary(void) const;

      virtual void update(const osg::FrameStamp* frameStamp);

      virtual void adjustDofConstraintsIfNecessary(osgSim::DOFTransform* clone);

      virtual DtIndirectDrawComponent* drawComponent(int stateId) const;

      virtual bool hasLightPoints(void) const;

      virtual bool hasDepthOnly(void) const;

      virtual bool isDepthOnly(int stateId) const;

      // do debug drawing of bounding boxes of all geometries within each instance
      virtual void debugDrawIfNecessary(osg::RenderInfo& renderInfo, const int maxCommands, const osg::Camera* camera);

      virtual void deleteDrawComponents(void);

      virtual void initDrawComponents(void);

      virtual const DtOsgCullVisitorParameters* findCullVisitorParameters(osg::RenderInfo& renderInfo) const;

      virtual void setPureSignalBasedUpdates(bool val);

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

      virtual void slot_coordinateSystemChanged();


   protected:
      osg::ref_ptr<DtIndirectGeometryRegistrar> myRegistrar;

      tbb::concurrent_queue<DtIndirectGeometryInstance> myQueueInstancesToAdd;

      DtGpuCulling* myGpuCulling;

      MapIntToInt myModelIDsToInstances;

      MapIntToInt myInstancesToModelIds;

      const bool myIsTerrainPatch;

      const bool myManagesIndividualInstances;

      DtIndirectEffectTexturesTemplate myEffectTexturesState;
      unsigned int myNumTextCoordArrays;

      DtSignalConnectionManager myConnections;

      osg::Matrixd myLocalOriginTransformMatrix;

      int myNumIndicesAcrossAllModels;
      std::map<int, int> myInstanceContainerIdToNumIndices;

      bool myLastDebugIndirectColorOn;
      bool myLastColorizePerDrawableEnabled;
      bool myLastMissingTextureColorOn;

      DtIndirectVaoManager& myVaoManager;

      int myId;

      DtInstanceContainer myInstanceContainer;

      DtIndirectSwitchManager* mySwitchManager;
      DtIndirectDofManager* myDofManager;
      DtIndirectLodManager* myLodManager;
      DtIndirectUvOffsetManager* myUvOffsetManager;
      DtIndirectPerInstanceDataManager* myPerInstanceDataManager;

      mutable unsigned int myMutableLastRegistrarRebuildNumber;
      mutable unsigned int myMutableLastFrameTexturesUpdated;

      mutable bool myMutableShadersSetup;

      mutable bool myMutableShouldReloadShaders;

      typedef std::unordered_map<int, int> MapIndirectIdToInstanceContainerId;
      MapIndirectIdToInstanceContainerId myMapIndirectIdToInstanceContainerId;

      unsigned int myLastFrameUpdated;
      const osg::Camera* myLastCamera;

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

      friend class DtIndirectGeometryInitMainThreadJob;

      boost::mutex myInternalsMutex;

      osg::ref_ptr<DtIndirectGeometryInitMainThreadJob> myMainThreadInitJob;
      osg::ref_ptr<DtIndirectGeometryUpdateBuffersMainThreadJob> myMainThreadUpdateBuffersJob;
      osg::ref_ptr<DtIndirectGeometryUpdateMainThreadJob> myMainThreadUpdateJob;

      DtIndirectFadeParameters myFadeParameters;

      // PPP: Is this large enough?
      std::atomic<int> myRunningInstanceId;

      DtIndirectDefaultDrawComponent* myDefaultDrawComponent;
      DtIndirectLightPointDrawComponent* myLightPointDrawComponent;
      DtIndirectDebugCullComponent* myIndirectDebugCullComponent;

      // state set (bin) for the default components
      osg::ref_ptr<osg::StateSet> myDefaultDrawStateSet;

      // state set (bin) for the light point components
      osg::ref_ptr<osg::StateSet> myLightPointDrawStateSet;

      // state set (bin) for depth only components
      osg::ref_ptr<osg::StateSet> myDepthOnlyDrawStateSet;

      bool myUpdateBuffersJobsRequiredCurrentFrame;

      unsigned int myLastFrameUpdateTraversed;

      mutable bool myMutableOutputInstancesBuffersChanged;

      DtGlBuffer* myGpuShaderUbo = nullptr;
      mutable int myGpuShaderUboBinding = -1;
      DtIndirectShaderConstants* myShaderConstants = nullptr;

      DtOsgLightPointManager& myLightPointManager;

      DtDe& myDe;

      DtCoordinateSystem* myCoordinateSystem = nullptr;


   protected:
      static bool theTrackObjects;

      struct TotalCounter
      {
      public:
         TotalCounter();
         virtual ~TotalCounter();
      public:
         std::atomic<int> myCount;
      };
      static TotalCounter theTotalCounter;
   };
}