DtIndirectGeometry.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/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 <vrvUtil/DtVirtualBaseClass.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>

#define INDIRECTGEOMETRY_CONSTRUCT_DESTRUCT_DEBUG 0

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

   class DT_DLL_VRVOSG DtIndirectGeometry : public osg::Drawable
   {
   public:

      
      template<class T>
      struct CloneMasterPair
      {
         osg::ref_ptr<T> myClone;
         osg::ref_ptr<T> myMaster;
      };

      friend class DtIndirectGeometryCreator;
      typedef std::unordered_map<int, Matrix4_32> MapInstanceIdToXform;
      
      typedef CloneMasterPair<osgSim::MultiSwitch> MultiSwitchPair;
      typedef std::unordered_map< osgSim::MultiSwitch*, MultiSwitchPair> MapCloneToMultiSwitchPair;
      typedef std::unordered_map< int, MapCloneToMultiSwitchPair> MapInstanceToMapCloneToMasterMultiSwitches;
      
      //Use the pair to hold the refs and the raw pointer to index into the map
      typedef CloneMasterPair<osgSim::DOFTransform> DofTransformPair;
      typedef std::unordered_map< osgSim::DOFTransform*, DofTransformPair > MapCloneToDofTransformPair;
      typedef std::unordered_map< int, MapCloneToDofTransformPair> MapInstanceToMapCloneToMasterDofs;
      
      //Use the pair to hold the refs and the raw pointer to index into the map
      typedef CloneMasterPair<osg::Sequence> SequencePair;
      typedef std::unordered_map< osg::Sequence*, SequencePair > MapCloneToSequencePair;
      typedef std::unordered_map< int, MapCloneToSequencePair> MapInstanceToMapCloneToMasterSequences;
      
      typedef std::map< const std::string, DtIndirectUvOffsetManager::UvOffset> MapAnnotationToUvOffsetData;
      typedef std::unordered_map< int, MapAnnotationToUvOffsetData> MapInstanceToMapAnnotationToUvOffsetData;

      typedef std::unordered_map< int, DtIndirectUvOffsetManager::UvOffset> MapInstanceToUvOffset;
      
   protected:
      DtIndirectGeometry(DtDe& de, bool terrainPatch);

      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 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 int addInstance(const DtIndirectGeometryInstance& instance);

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

      virtual void setInstanceMatrixTransform(int instanceId, const Matrix4_32& xForm);

      virtual Matrix4_32 instanceMatrixTransform(int instanceId) const;

      virtual void removeInstance(int id);

      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 setManagesIndividualInstances(bool val);

      virtual bool managesIndividualInstances() const;

      virtual void setPureSignalBasedUpdates(bool val);

      virtual bool pureSignalBasedUpdates(void) const;

      virtual void setInstanceMultiSwitch(int id, osgSim::MultiSwitch* clone, osgSim::MultiSwitch* master);

      virtual void instanceMultiSwitches(int instanceIdIndirect, MapCloneToMultiSwitchPair& mapCloneToMasterMultiSwitches) const;

      virtual void setInstanceUvOffset(int id, const std::string& annotation, float uOffset, float vOffset);

      virtual void scrollUv(int id, float uOffset, float vOffset);

      virtual void instanceAnnotationsAndUvOffsets(int instanceIdIndirect, std::vector<DtIndirectAnnotationAndUvOffset>& annotations) const;

      virtual void setInstanceColor(int instanceIdIndirect, const Vector4_32& color);
      virtual Vector4_32 instanceColor(int instanceIdIndirect) const;

      virtual void setInstanceOtherData0(int instanceIdIndirect, const Vector4_32& data);
      virtual Vector4_32 instanceOtherData0(int instanceIdIndirect) const;

      virtual void setInstanceVisibility(int instanceIdIndirect, bool visible);
      virtual bool instanceVisibility(int instanceIdIndirect) const;

      virtual void setInstanceLightPointMaxDistance(int instanceIdIndirect, float lightPointMaxDistance);
      virtual float instanceLightPointMaxDistance(int instanceIdIndirect) const;

      virtual void setInstanceDof(int id, osgSim::DOFTransform* clone, osgSim::DOFTransform* master);

      virtual void setInstanceDofTranslation(int id, osgSim::DOFTransform* clone, osgSim::DOFTransform* master
         , const Vector3_64& trans
         , const Vector3_64& transVel);

      virtual void setInstanceDofOrientation(int id, osgSim::DOFTransform* clone, osgSim::DOFTransform* master
         , const Vector3_64& hpr
         , const Vector3_64& hprVel);

      virtual void setInstanceDofOrientation(int id, osgSim::DOFTransform* clone, osgSim::DOFTransform* master
         , const Vector3_64& hprVel
         , bool forceUpdate);

      virtual void instanceDofs(int instanceIdIndirect, MapCloneToDofTransformPair& mapCloneToDofTransformPair) const;
      
      virtual void setInstanceSequence(int id, osg::Sequence* clone, osg::Sequence* master);

      virtual void instanceSequences(int instanceIdIndirect, MapCloneToSequencePair& mapCloneToMasterSequences) const;

      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 setUpdateBuffersJobsRequiredCurrentFrame(bool requiredCurrentFrame);
      virtual bool updateBuffersJobsRequiredCurrentFrame(void) const;

      virtual bool readyToRender(const int instanceIdInIndirect) const;

      virtual bool hasInProgressInstanceMove() const;
      virtual void addInProgressInstanceMove();
      virtual void subtractInProgressInstanceMove();

      virtual bool instanceEverAdded(void) const;

      virtual int numValidInstances(void) const;

   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 DtAggregateModelInfo& modelInfo, int instanceContainerIndex);
      
      virtual void removeInstanceFromIndicesCount(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 setMultiSwitchOnInstanceInInstanceContainer(int instanceContainerId, osgSim::MultiSwitch* clone, osgSim::MultiSwitch* master);

      virtual void setDofOnInstanceInInstanceContainer(int instanceContainerId, osgSim::DOFTransform* clone, osgSim::DOFTransform* master);

      
      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 setUvOffsetOnInstanceInInstanceContainer(const int instanceId, const std::string& annotation, float uOffset, float vOffset);
      
      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 removeInstanceInInstanceContainer(int instanceContainerId);

      virtual void reloadShadersIfNecessary(void) const;

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

      virtual DtIndirectDrawComponent* drawComponent(int stateId) const;

      virtual bool hasLightPoints(void) 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 DtIndirectModelScalingAlgorithm scalingAlgorithm(const DtOsgCullVisitorParameters* params) const;

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

   protected:
      osg::ref_ptr<DtIndirectGeometryRegistrar> myRegistrar;

      tbb::concurrent_queue<DtIndirectGeometryInstance> myQueueInstancesToAdd;

      DtGpuCulling* myGpuCulling;

      MapIntToInt myModelIDsToInstances;

      MapIntToInt myInstancesToModelIds;

      const bool myIsTerrainPatch;

      DtIndirectEffectTexturesTemplate myEffectTexturesState;
      unsigned int myNumTextCoordArrays;

      DtSignalConnectionManager myConnections;

      osg::Matrixd myLocalOriginTransformMatrix;

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

      bool myLastDebugIndirectColorOn;
      bool myLastDebugIndirectColorByGeomIndex;
      bool myLastMissingTextureColorOn;

      // friend so it can access registrar, culling to make the vaos
      friend class DtIndirectVaoManager;
      DtIndirectVaoManager* myVaoManager;

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

      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;

      //Left the typedefs here commented out so they are easier to follow. They need to be at the
      // top so they can be used as arguments in the functions.

      //typedef std::unordered_map<int, Matrix4_32> MapInstanceIdToXform;
      MapInstanceIdToXform myMapInstanceIdToXform;

      //typedef CloneMasterPair<osgSim::MultiSwitch> MultiSwitchPair;
      //typedef std::map< osgSim::MultiSwitch*, MultiSwitchPair> MapCloneToMultiSwitchPair;
      //typedef std::map< int, MapCloneToMultiSwitchPair> MapInstanceToMapCloneToMasterMultiSwitches;
      MapInstanceToMapCloneToMasterMultiSwitches myMapInstanceToMapCloneToMasterMultiSwitches;

      //Use the pair to hold the refs and the raw pointer to index into the map
      //typedef CloneMasterPair<osgSim::DOFTransform> DofTransformPair;
      //typedef std::unordered_map< osgSim::DOFTransform*, DofTransformPair > MapCloneToDofTransformPair;
      //typedef std::unordered_map< int, MapCloneToDofTransformPair> MapInstanceToMapCloneToMasterDofs;
      MapInstanceToMapCloneToMasterDofs myMapInstanceToMapCloneToMasterDofs;

      //Use the pair to hold the refs and the raw pointer to index into the map
      //typedef CloneMasterPair<osg::Sequence> SequencePair;
      //typedef std::unordered_map< osg::Sequence*, SequencePair > MapCloneToSequencePair;
      //typedef std::unordered_map< int, MapCloneToSequencePair> MapInstanceToMapCloneToMasterSequences;
      MapInstanceToMapCloneToMasterSequences myMapInstanceToMapCloneToMasterSequences;

      //typedef std::unordered_map< const std::string, DtIndirectUvOffsetManager::UvOffset> MapAnnotationToUvOffsetData;
      //typedef std::unordered_map< int, MapAnnotationToUvOffsetData> MapInstanceToMapAnnotationToUvOffsetData;
      MapInstanceToMapAnnotationToUvOffsetData myMapInstanceToMapAnnotationToUvOffsetData;

      //typedef std::unordered_map< int, DtIndirectUvOffsetManager::UvOffset> MapInstanceToUvOffset;
      MapInstanceToUvOffset myMapInstanceToUvOffset;


      std::unordered_map<int, Vector4_32> myMapInstanceToColor;
      
      std::unordered_map<int, Vector4_32> myMapInstanceToOtherData0;

      std::unordered_map<int, bool> myMapInstanceToVisibility;

      std::unordered_map<int, float> myMapInstanceToLightPointMaxDistance;

      typedef std::unordered_set<int> SetInstancesToDelete;
      SetInstancesToDelete mySetInstancesIndirectIdsToDelete;

      bool myManagesIndividualInstances;

      DtDe& myDe;

      //osg state management
      osg::ref_ptr<osg::Uniform> myModelViewMatrixUniform;
      osg::ref_ptr<osg::Uniform> myProjectionMatrixUniform;

      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;

      bool myUpdateBuffersJobsRequiredCurrentFrame;

      unsigned int myLastFrameUpdateTraversed;

      int myNumInProgressInstanceMoves;
   
   protected:
      // shared across multiple indirect geometries
      static DtVirtualProgramCache* theVirtualProgramCache;

   };

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

      virtual ~DtIndirectGeometryCreator();

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

   public:
      virtual DtIndirectGeometry* create(bool terrainPatch) const;

      static DtIndirectGeometryCreator& instance(DtDe& de);

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