DtOsgIndirectEntityManager.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2025 MAK Technologies, Inc.
 * All rights reserved.
 *****************************************************************************/


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtIndirectGeometry.h>
#include <vrvOsg/DtArticulatedModelParser.h>
#include <vrvOsg/DtIndirectEntityManagerInstance.h>
#include <vrvOsg/DtIndirectCellHasher.h>
#include <vrvOsg/DtIndirectGridCellTime.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvMath/DtAxisAlignedBoundingBox.h>
#include <vrvMath/DtVector3.h>

#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtIndirectEntityManager.h>

#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>

#include <boost/thread.hpp>

#include <unordered_map>
#include <tuple>
#include <unordered_set>

#include <tbb/concurrent_hash_map.h>

namespace osg
{
   class StateSet;
}

namespace makVrv
{
   class DtIndirectModelsContainer;
   class DtModelDefinition;
   class DtOsgModelInstance;
   class DtIndirectGeometryGrid;

   class DtIndirectEntityManagerInstanceMoveInfo;
   class DtIndirectEntityLimitTextureStrategy;

   class DtIndirectModelMasterMappings;

   class DT_DLL_VRVOSG DtOsgIndirectEntityManager : public DtIndirectEntityManager
   {
   public:
      struct DtLightPointGroupInfo
      {
         int myLightPointGroupId = 0;
         std::string myLightPointGroupName = "";
      };

   public:
      virtual ~DtOsgIndirectEntityManager();

      static void registerInstance(DtDe& de);

      static DtOsgIndirectEntityManager& instance(DtDe& de);


   protected:
      DtOsgIndirectEntityManager(DtDe& de);

      DtOsgIndirectEntityManager() = delete;

      DtOsgIndirectEntityManager(const DtOsgIndirectEntityManager&) = delete;

      DtOsgIndirectEntityManager& operator=(const DtOsgIndirectEntityManager&) = delete;
   public:

      virtual bool addInstance(DtUniqueID uniqueId, const DtModelDefinition& modelDefinition
         , const DtOsgModelInstance& modelInstance, DtModel* model
         , DtModelSetId modelSet, float modelScale, float modelRadius
         , bool daylightControlled, bool mapDofsSwitchesSequences
         , const DtLightPointGroupInfo& lightPointGroupInfo
         , bool trackLifeTime
         , const std::string& trackName);

      virtual bool addInstanceAsProp(DtUniqueID uniqueId, const DtModelDefinition& modelDefinition
         , const DtOsgModelInstance& modelInstance, DtModel* model
         , float modelScale, float modelRadius
         , bool daylightControlled, bool mapDofsSwitchesSequences
         , int lightPointGroupId);

      virtual bool hasInstance(DtUniqueID uniqueId) const;

      virtual void removeInstance(DtUniqueID uniqueID);

      virtual int numInstances(void) const;

      virtual void mapMultiSwitches(DtUniqueID uniqueID
         , DtArticulatedModelParser::MapStateNumberToMultiSwitchList& multiSwitchesOfInstance);

      virtual void unMapMultiSwitches(DtUniqueID uniqueID);

      virtual void mapSequences(DtUniqueID uniqueID, DtArticulatedModelParser::AnimationMap& animationMap);

      virtual void unMapSequences(DtUniqueID uniqueID);

      virtual void mapDofs(DtUniqueID uniqueID, DtArticulatedModelParser::PartMap& partMap);

      virtual void unMapDofs(DtUniqueID uniqueID);

      virtual void setMultiSwitchActiveSwitchSet(DtUniqueID id, osgSim::MultiSwitch* multiSwitchOfInstance);

      virtual void setSequenceUpdate(DtUniqueID uniqueID, osg::Sequence* dof);

      virtual void setUvOffsetUpdate(DtUniqueID uniqueID, const std::string& annotation,
         float uOffset, float vOffset);

      virtual void scrollUvTextures(DtUniqueID uniqueID, const std::tuple<float, float, float>& uvspeeds);

      virtual void setDofUpdate(DtUniqueID uniqueID, osgSim::DOFTransform* dof);

      virtual void setDofAnimationFlags(DtUniqueID uniqueID, osgSim::DOFTransform* dof, int animationFlags);

      virtual void setDofTranslation(DtUniqueID uniqueID, osgSim::DOFTransform* dof
         , const Vector3_64& trans
         , const Vector3_64& transVel);

      virtual void setDofOrientation(DtUniqueID uniqueID, osgSim::DOFTransform* dof
         , const Vector3_64& hpr
         , const Vector3_64& hprVel
         , int animationFlags);

      virtual void setDofOrientation(DtUniqueID uniqueID, osgSim::DOFTransform* dof
         , const Vector3_64& hprVel
         , bool forceUpdate
         , int animationFlags);

      void slot_atcGlobalModelEnableChanged();

      virtual void setPositionAndOrientation(DtUniqueID uniqueId
         , const DtVector& position, const DtTaitBryan& orientation
         , const DtVector& positionOffset, const DtTaitBryan& orientationOffset);

      virtual void setColor(DtUniqueID uniqueId, const Vector4_32& color);

      virtual void setOtherData0(DtUniqueID uniqueId, const Vector4_32& data);

      virtual void setVisible(DtUniqueID uniqueId, bool visible);

      virtual void setLightPointGroupId(DtUniqueID uniqueId, int groupId);

      virtual void setLightPointMaxDistance(DtUniqueID uniqueId, float maxDistance);

      virtual void setCellPageOutTime(double val);
      virtual double cellPageOutTime(void) const;

      virtual void tick(void) override;

      virtual void slot_releaseResources();

      virtual void slot_postTick();

      virtual void slot_postInit();

      virtual void excludeTextureFromLimits(const std::string& textureFileAbolutePath);

      virtual void excludeModelDefinitionFromLimits(const std::string& modelDefinition);

      virtual DtIndirectLimitTextureStrategy* limitTextureStrategy(DtModelSetId modelSet);

      virtual bool isCopyingData(void) const;


      virtual bool areRegisteredModelTextureVariants(DtModelSetId modelSet, const std::string& fileName) const;

      virtual void registerModelTextureVariants(DtModelSetId modelSet, const DtModelDefinition* modelDefinition
         , const std::vector<std::string>& variantPaths);

      virtual void setModelTextureVariant(DtUniqueID uniqueId, const std::string& variant);


      boost::signalslib::signal<void(DtModel*, DtUniqueID)>  signal_instanceAdded;


   protected:

      virtual DtIndirectEntityManagerInstanceMoveInfo* createMoveInfoIfNecessary(const DtVector& position
         , DtIndirectEntityManagerInstance& currentEntityManagerInstance
         , DtUniqueID uniqueId);

      virtual osgSim::DOFTransform* findMasterDof(DtUniqueID uniqueID, osgSim::DOFTransform* dof) const;

      virtual DtIndirectEntityGeometry* findIndirectGeometryAndInstanceId(DtUniqueID uniqueID, int& instanceId) const;

      virtual void calculateAndSetInstanceMatrixTransform(const DtVector& position
         , const DtTaitBryan& orientation, const DtVector& positionOffset, const DtTaitBryan& orientationOffset
         , DtIndirectEntityGeometry* indirectGeometry, int instanceId);

      virtual void reset();

   protected:
      virtual void tickEntityMoves(void);

      virtual void tickPaging(void);

      virtual bool instanceIsBeingMovedTo(const Vector3_int& cellId);

      void setupRootNodes();

      virtual void setupReductionExcludeTextures();

      virtual void updateStats();

      virtual void disableModelSet(DtModelSetId modelSet);
      virtual bool modelSetDisabled(DtModelSetId modelSet) const;

      virtual void setAlpha2Coverage(osg::Node* node, bool on);

      virtual void clearMasterMappingsMap(void);

      virtual bool parseNodeAndRegisterMasterMappings(osg::Node* modelNodeMaster, const std::string& modelName);
   protected:


      DtSignalConnectionManager myConnections;

      boost::signalslib::connection myPostInitializeConnection;

      typedef std::unordered_map<DtModelSetId, DtIndirectGeometryGrid* > MapModelSetToDtIndirectGeometryGrids;
      MapModelSetToDtIndirectGeometryGrids myMapModelSetToDtIndirectGeometryGrids;

      using MapUniqueIdsToEntityManagerInstances = tbb::concurrent_hash_map<DtUniqueID, DtIndirectEntityManagerInstance>;
      MapUniqueIdsToEntityManagerInstances myMapUniqueIdsToEntityManagerInstances;

      typedef std::unordered_map< osgSim::MultiSwitch*, osg::ref_ptr<osgSim::MultiSwitch> > MapMultiSwitchesToMultiSwitches;
      typedef std::unordered_map<DtUniqueID, MapMultiSwitchesToMultiSwitches > MapInstanceMultiSwitchesToMasterMultiSwitches;

      std::unordered_map<std::string, DtIndirectModelMasterMappings*> myModelNameToModelMasterMappings;

      MapInstanceMultiSwitchesToMasterMultiSwitches myMapInstanceMultiSwitchesToMasterMultiSwitches;

      typedef std::unordered_map< osgSim::DOFTransform*, osg::ref_ptr<osgSim::DOFTransform> > MapDofToDof;
      typedef std::unordered_map<DtUniqueID, MapDofToDof > MapInstanceDofToMasterDof;

      MapInstanceDofToMasterDof myMapInstanceDofToMasterDof;

      typedef std::unordered_map< osg::Sequence*, osg::ref_ptr<osg::Sequence> > MapSequenceToSequence;
      typedef std::unordered_map<DtUniqueID, MapSequenceToSequence > MapInstanceSequenceToMasterSequence;

      MapInstanceSequenceToMasterSequence myMapInstanceSequenceToMasterSequence;

      using InstancesBeingMovedMap = tbb::concurrent_hash_map<DtUniqueID, DtIndirectEntityManagerInstanceMoveInfo*>;
      InstancesBeingMovedMap myInstancesBeingMoved;

      InstancesBeingMovedMap myInstanceMovesToDelete;

      using IndirectEntityGeometryMap = tbb::concurrent_unordered_map<unsigned int, DtIndirectEntityGeometry*>;
      IndirectEntityGeometryMap myIndirectEntityGeometryMap;

      typedef std::unordered_map<Vector3_int, DtIndirectGridCellTime, DtIndirectCellHasher> CellIdsWithZeroInstancesUpTime;

      typedef std::unordered_map<DtModelSetId, CellIdsWithZeroInstancesUpTime> GridToCellIdsWithZeroInstancesUpTime;

      GridToCellIdsWithZeroInstancesUpTime myGridToCellIdsWithZeroInstancesUpTime;

      // The time after which inactive cells are removed
      double myCellPageOutTime;

      Vector3_64 myLastObserverLocation;

      std::set<int> myDisabledModelSets;

      struct ModelVariantInformation
      {
         int myMasterModelId;
         std::unordered_map<std::string, int> myVariantToModelId;
      };

      std::unordered_map < DtModelSetId, std::unordered_map<std::string, ModelVariantInformation> > myModelSetToModelVariantInformationMap;
   };
}