DtIndirectGeometry.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2024 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/DtIndirectGeometrySubType.h>

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

#include <vrvMath/DtVector3.h>

#include <vrvUtil/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 <boost/thread/condition_variable.hpp>
#include <boost/thread/shared_mutex.hpp>

#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 DtVirtualProgramCache;

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

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

   class DtIndirectVaoManager;

   class DtCoordinateSystem;

   class DtDebugLog;

   class DtIndirectShaderManager;

   class DtIndirectGeometry;

   class DtIndirectGeometryRenderer;

   typedef DtVirtualBaseClassCreator<DtIndirectGeometry, const DtCullShaderConfig&, const DtIndirectGeometrySubType&, 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, const DtIndirectGeometrySubType& geometrySubType, 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 setRenderer(DtIndirectGeometryRenderer* drawerNode);

      virtual void setRegistrar(DtIndirectGeometryRegistrar* registrar);

      virtual DtIndirectGeometryRegistrar* registrar();

      virtual const char* className() const;

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

      virtual void debugDrawImplementation(osg::RenderInfo& renderInfo,
         const osg::Matrixd& modelViewMatrix);

      virtual int addInstance(const DtIndirectGeometryInstance& instance);

      virtual int addInstance(int modelId, const osg::Matrixd& xForm, float modelScale, float modelRadius, int lightPointGroupId
         , bool trackLifeTime
         , const std::string& trackName
         , bool defaultVisibility = true );

      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 setupIndirectShaders();

      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 launchOneTimeInitOp();

      virtual void updateGpuBuffers(bool amortizeTextures);

      virtual void setFadeParameters(const DtIndirectFadeParameters& fadeParameters);

      virtual const DtIndirectFadeParameters& fadeParameters(void) const;

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

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

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

      virtual bool readyToRender(const int instanceIdInIndirect) const;

      virtual bool hasQueuedInstances( void ) const;

      virtual bool allInstancesAreToBeDeleted() const;

      virtual bool instanceEverAdded(void) const;

      virtual int numValidInstances(void) const;

      virtual void setCellId(const Vector3_int& cellId);

      virtual const Vector3_int& cellId(void) const;

      virtual const unsigned int id( void ) const;

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

      static int numIndirectGeometries(void);

      static void initializeDtDeKeyedInstances(DtDe& de);

      static int numUpdateGpuBuffersRanThisFrame();

      static void clearNumUpdateGpuBuffersRanThisFrame();
   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
      , bool isLightBin, bool isDepthBin, bool isShadowPass, bool viaExternalRenderer) const;

      virtual void syncViewParametersToGpu(
         const DtIndirectViewParameters& viewParameters, osg::State* state) 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 updateInstanceLightPointGroupIdActual(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 updateInstanceModelIdAddedActual(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;

      virtual void nullOutDrawComponents(void);

      virtual void initDrawComponents(void);

      virtual void setPureSignalBasedUpdates(bool val);

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

      virtual void slot_coordinateSystemChanged();

      virtual void trackInstanceLifeTime(int instanceIdInIndirectGeometry
         , bool trackLifeTime
         , const std::string& trackName);

      virtual std::pair<bool, std::string> trackInfo(int instanceIdInIndirectGeometry) const;

      virtual void drawImplementation(osg::RenderInfo& renderInfo, const osg::Matrixd& modelViewMatrix
      , bool isLightBin, bool isDepthBin, bool isShadowPass) const;

      virtual bool isTerrainPatch(const DtIndirectGeometrySubType& geometrySubType) const;

      virtual bool disableExternalRenderForSensorFx(const osg::Camera* camera) const;

      virtual bool useExternalRenderer(const osg::Camera* camera) const;

      virtual std::string modelName(int instanceId) const;

   protected:
      osg::ref_ptr<DtIndirectGeometryRegistrar> myRegistrar;

      tbb::concurrent_queue<DtIndirectGeometryInstance> myQueueInstancesToAdd;

      DtGpuCulling* myGpuCulling;

      MapIntToInt myModelIDsToInstances;

      MapIntToInt myInstancesToModelIds;

      const DtIndirectGeometrySubType myGeometrySubType;
      const bool myIsTerrainPatch;

      const bool myManagesIndividualInstances;

      DtIndirectEffectTexturesTemplate myEffectTexturesState;
      unsigned int myNumTextCoordArrays;

      DtSignalConnectionManager myConnections;

      osg::Matrixd myLocalOriginTransformMatrix;

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

      DtIndirectVaoManager& myVaoManager;

      unsigned int myId;

      DtInstanceContainer myInstanceContainer;

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

      mutable bool myMutableShadersSetup;

      mutable bool myMutableShouldReloadShaders;

      typedef boost::unique_lock<boost::shared_mutex> InstanceMutexWriteLock;
      typedef boost::shared_lock<boost::shared_mutex> InstanceMutexReadLock;
      mutable boost::shared_mutex myInstanceMutex;

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

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

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

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

      virtual DtIndirectDrawComponent* component(int component);

      // 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;

      unsigned int myLastFrameUpdateTraversed;

      mutable bool myMutableOutputInstancesBuffersChanged;

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

      DtOsgLightPointManager& myLightPointManager;

      DtDe& myDe;

      DtCoordinateSystem* myCoordinateSystem = nullptr;

      Vector3_int myCellId = { 0,0,0 };

      std::unordered_map<int, std::string> myInstancesBeingTracked;

      DtIndirectShaderManager& myIndirectShaderManager;

      const bool mySensorFxLoaded;

   protected:
      static bool theTrackObjects;

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

      friend class DtIndirectGeometryRenderer;
      friend class DtIndirectGeometryRendererUserData;
      DtIndirectGeometryRenderer* myIndirectGeometryRenderer = nullptr;

      const DtIndirectRunTimeSettings& myIndirectRunTimeSettings;

      static int theNumUpdateGpuBuffersRanThisFrame;
   };
}