DtOsgArticulatedModel.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/DtArticulatedModelParser.h>

#include <vrvCore/DtMetaFileManager.h>
#include <vrvCore/DtArticulatedModel.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>

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

#include <osg/ref_ptr>
#include <osg/Matrixf>

#include <boost/thread/mutex.hpp>

#include <unordered_map>
#include <unordered_set>

namespace osg
{
   class Matrixd;
   class Sequence;
   class Node;
   class Group;
}

namespace osgSim
{
   class DOFTransform;
   class MultiSwitch;
}

namespace makVrv
{
   class DtOsgIndirectEntityManager;
   class DtOsgSceneConnector;
   class DtModelDefinition;
   class DtOsgModelInstance;

   class DT_DLL_VRVOSG DtOsgArticulatedModel : public DtArticulatedModel
   {
   public:

      typedef std::vector<osg::Node*> NodeList;
      typedef std::unordered_map<int, NodeList> NodePathCache;
      typedef std::map<std::string, std::string> LinkageConfigMap;

      typedef std::unordered_map<std::string, std::pair<float, float> > AnnotationNameToUvsMap;

   public:
      DtOsgArticulatedModel(DtDe&, DtUniqueID id);

      virtual ~DtOsgArticulatedModel();

   private:
      DtOsgArticulatedModel() = delete;

      DtOsgArticulatedModel(const DtOsgArticulatedModel& rhs) = delete;

      DtOsgArticulatedModel& operator=(const DtOsgArticulatedModel& rhs) = delete;

   public:
      virtual void setModelDefinition(const std::string& str);

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

      virtual const std::string& className() const;

      virtual DtUniqueID uniqueId() const;

      virtual void setElementId(DtElementID id) override;

      //@name <Position & Orientation functions: Start>

      virtual void setPosition(int vtx, const DtVector& position);

      virtual void setOrientation(int vtx, const DtTaitBryan& orientation);

      virtual void setPositionOffset(const DtVector& positionOffset);

      virtual void setOrientationOffset(const DtTaitBryan& orientationOffset);

      virtual void setPositionAndOrientation(int vtx, const DtVector& position, const DtTaitBryan& orientation);

      virtual void setVisible(bool isVisible);
      // </Position & Orientation functions: End>


      //@name <Part Management Functions: Start>
      
      virtual void setPartAnimationFlags(int partNumber, int animationFlags);

      virtual void setPartTranslation(int partNumber,
         const DtVector& transform, const DtVector& velocity);

      virtual void setPartOrientation(int partNumber,
         const DtTaitBryan& orientation, const DtVector& rotationalVelocity, PartUpdateType updateType);

      virtual void setPartRotationalVelocity(int partNumber,
          const DtVector& rotationalVelocity, bool forceUpdate, PartUpdateType updateType);

      virtual PartUpdateType setPartOrientationUpdateType(int partNumber, PartUpdateType updateType) override;

      virtual bool findPartPositionAndOrientation(int partNumber, DtVector& position, DtQuat& ori) override;

      virtual bool findCachedPartPositionAndOrientation(int partNumber, DtVector& position, DtTaitBryan& ori) override;

      virtual DtVector partTranslation(int partNumber) const;

      virtual DtTaitBryan partOrientation(int partNumber) const;

      virtual void setPartVisibility(int partNumber, bool onOff);

      const DtArticulatedModelParser::PartMap& parts() const;

      virtual void getParts(PartList& parts) const;

      virtual bool hasPart(int partId) const;

      virtual void addPart(int partNumber, osgSim::DOFTransform* node);
      // </Part Management Functions: End>




      //@name <Animation Management Functions: Start>
      virtual void setAnimationFrame(const std::string& animationName,
         int frameIndex) override;

      virtual void setAnimationRange(const std::string& animationName,
         int firstFrameIndex, int lastFrameIndex) override;

      virtual void setAnimationSpeed(const std::string& animationName,
         double framesPerSecond) override;

      virtual void setAnimationState(const std::string& animationName,
         AnimationState mode) override;

      virtual void setAnimationLastFrameTime(const std::string& animationName, double animationLastFrameTime);

      virtual void setAnimationLoopCount(const std::string& animationName, int loopCount);

      virtual int animationFrameCount(const std::string& animationName) const;

      virtual int animationCurrentFrame(const std::string& animationName) const;

      virtual int animationFirstFrame(const std::string& animationName) const;

      virtual int animationLastFrame(const std::string& animationName) const;

      virtual double animationSpeed(const std::string& animationName) const;

      virtual AnimationState animationState(const std::string& animationName) const;

      virtual double animationLastFrameTime(const std::string& animationName) const;

      //  default param is -1, repeat forever
      virtual int animationLoopCount(const std::string& animationName) const;

      virtual const DtArticulatedModelParser::AnimationMap& animations() const;

      virtual void addAnimation(const std::string& animationName,
         osg::Sequence* node);

      virtual const DtArticulatedModelParser::FlipBookAnimationMap& flipBookAnimations() const;

      virtual const DtArticulatedModelParser::FlipBookAnimationMap& flipBookAnimationsWithVelocityControl() const;

      virtual void setFlipBookAnimationsSpeed(double leftSpeed, double rightSpeed, double mainSpeed);
      
      virtual const DtArticulatedModelParser::ScrollableTextureGroupMap& scrollableTextureGroupMap() const;

      virtual void scrollUvTextures(double leftSpeed, double rightSpeed, double mainSpeed);

      //<Animation Management Functions: End>



      //@name <Model scaling functions: Start>
      virtual void setModelScalingEnabled(bool b);

      virtual bool modelScalingEnabled();

      virtual void setLocalModelScalingEnabled(bool enabled);

      virtual void setLocalModelScalingAmount(float localScl);

      // </Model scaling functions: End>



      //@name <Color and Blending: Start>
      virtual void setColor(float r, float g, float b, float a);

      virtual void enableColorBlending(bool b);

      virtual void setBlendColor(float r, float g, float b, float a);
      //</Color and Blending: End>

      //@name <Instance OtherData0: Start>
      virtual void setOtherData0(float r, float g, float b, float a);
      //</Instance OtherData0: End>



      //@name <Linkage and Config: Start>
      virtual void setLinkageConfigPair(const std::string& linkageName, const std::string& configName);

      virtual LinkageConfigMap& linkageConfigMap();

      virtual const LinkageConfigMap& linkageConfigMap() const;
      //</Linkage and Config: End>


      virtual void weaponFired(const DtUnicode& munitionModelDefName) override;

      //@name <Sensor: Start>
      virtual void setDynamicSensorRegion(const std::string& region, bool state) override;

      virtual bool dynamicSensorRegion(const std::string& region);

      //</Sensor: End>




      virtual void setUvOffset(const std::string& annotation,
         float uOffset, float vOffset);

      virtual const AnnotationNameToUvsMap& annotationsMap(void) const;

      //@name <State setting: Start>
      virtual void setState(int stateNumber, int stateValue);

      virtual void setStateUnfiltered(int stateNumber, int stateValue);

      virtual void reapplyState();

      virtual int state(int stateNumber) const;

      const DtArticulatedModelParser::MapStateNumberToMultiSwitchList& states() const;

      virtual void addState(int stateNumber, osgSim::MultiSwitch* node);

      virtual void setStateValueExists(int stateNumber, int stateValue);
      //</State setting: End>




      //@name <Lights: Start>
      virtual void setLightpointMaxDistance(float distance);

      virtual void setLightPointGroup(const std::string& groupName);

      virtual const std::string& lightPointGroup() const;

      virtual void setLightPointGroupIntensity(const std::string& groupName, float intensity);
      //</Lights: End>



      virtual void setDepthMask(osg::Group& parent);

      virtual void addAnnotationGroup(const std::string& annotation, osg::Group* group);

      virtual void setIsSupportModel(bool isSupport);

      virtual void getBoundingBoxComponents(DtVector& minimum, DtVector& maximum);

      virtual bool applyMetafile(const DtModelDefinition* definition);

      virtual void slot_onShadowStateChanged(bool on);

      virtual void slot_atcModeEnableChanged(bool state);

      
      virtual void setSingleChildOn(osgSim::MultiSwitch* multiSwitch, unsigned int switchIndex, int nodeTypeIndex);

      virtual void setDofHpr(osgSim::DOFTransform* dof, const DtVector& hpr, int animationFlags);

      virtual void setDofHprVel(osgSim::DOFTransform* dof, const DtVector& hprVel, int animationFlags);


      virtual bool areRegisteredModelTextureVariants(void) const;

      virtual void registerModelTextureVariants(const std::vector<std::string>& variants);

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

      virtual const std::string& modelTextureVariant(void);

      boost::signalslib::signal<void(DtOsgArticulatedModel*, int, int)> signal_SetState;
      
   public:
      static void setTrackObjects(bool val);
      static bool trackObjects(void);

      static void trackEntity(const std::string& entityDisplayName, DtModelSetId modelSet, bool track);

   protected:

      virtual void setStateInternal(int stateNumber, int stateValue);

      virtual void setUvOffsetInternal(const std::string& annotation, float uOffset, float vOffset);



      //@name <Part Management Internal Functions: Start>
      virtual void setPartTranslationInternal(int partNumber,
         const DtVector& transform, const DtVector& velocity);

      virtual void setPartOrientationInternal(int partNumber,
         const DtTaitBryan& orientation, const DtVector& rotationalVelocity);

      virtual void setPartRotationalVelocityInternal(int partNumber,
          const DtVector& rotationalVelocity, bool forceUpdate = true);

      virtual void disablePart(int partNumber);

      virtual void enablePart(int partNumber);

      //@name </Part Management Internal Functions: End>


      virtual void addToScene(const DtUniqueID& sceneObjectId, DtModelSetId modelSet,
         int visualizerType);

      virtual void removeFromScene();

      virtual void modelInstanceToBeDeleted();


      virtual void modelInstanceCreatedInternal(osg::Node* root, DtOsgModelInstance* osgModelInstance, bool daylightControlledLights, float scale);

      virtual void modelInstanceCreated(bool castShadows, bool daylightControlledLights, float scale);

      virtual void mergeCurrentStateWithDefaults(DtArticulatedModelParser* parser);

      virtual void parseModel(osg::Node* root);

      virtual void backgroundLoad();

      virtual void discoverDynamicRegions(const DtModelDefinition* definition);

      virtual void foregroundLoad();

      virtual void backgroundLoadInternal(DtModelDefinition* definition);

      virtual void backgroundLoadFirstLoadInternal(DtModelDefinition* definition);

      virtual void foregroundLoadInternal();
      
      virtual void processAutomaticallyArticulatedParts();

      virtual int lightPointGroupIdToUse(bool increaseReferenceCount=false) const;

      virtual void updateGeneratedUniqueLightPointGroupName();

      virtual void modelInstanceToBeDeletedInternal(void);

   protected:

      struct PartOrientationData
      {
         PartOrientationData()
            : myOrientation(0, 0, 0)
            , myRotationalVelocity(0, 0, 0)
            , myUpdateType(PartUpdateTypeManual)
         {
            // intentional noop
         }

         DtTaitBryan myOrientation;
         DtVector myRotationalVelocity;
         PartUpdateType myUpdateType;
      };


      DtArticulatedModelParser::MapStateNumberToStateExistenceList myMapStateNumberToStateExistenceList;
      DtArticulatedModelParser::MapStateNumberToStateValue myMapStateNumberToStateValue;
      DtArticulatedModelParser::PartMap myPartMap;
      DtArticulatedModelParser::MapStateNumberToMultiSwitchList myMapStateNumberToMultiSwitchList;
      DtArticulatedModelParser::AnimationMap myAnimationMap;
      DtArticulatedModelParser::FlipBookAnimationMap myFlipBookAnimationMap;
      DtArticulatedModelParser::FlipBookAnimationMap myFlipBookAnimationMapWithVelocityControl; // This is a subset of the map of all flip book animations above
      DtArticulatedModelParser::AnnotationMap myAnnotationMap;
      DtArticulatedModelParser::ScrollableTextureGroupMap myScrollableTextureGroupMap;
 
      DtOsgSceneConnector* mySceneConnector;

      NodePathCache myNodePathCache;
      static const unsigned int theNodePathCacheSize = 4;
      bool myUseSwitch;

      AnnotationNameToUvsMap myAnnotationsUvMap;

      typedef std::unordered_map<std::string, bool> SensorRegionStateMap;
      SensorRegionStateMap mySensorRegionMap;

      DtOsgIndirectEntityManager& myIndirectEntityManager;

      DtMetaFileManager::LinkageValueVec myModelMetaFeatures;

      LinkageConfigMap myLinkageConfigMap;

      std::vector<DtVirtualBaseClass*> myModelMetaAttachments;

      typedef std::map<int, PartOrientationData> PartOrientationMap;
      PartOrientationMap myPartOrientationMap;

      typedef std::map<int, std::pair<DtVector, DtVector> > PartTranslationMap;
      PartTranslationMap myPartTranslationMap;
      
      DtVector myBoundMin, myBoundMax;

      DtVector myScaleArtPartTransform;

      // These are used for backwards compatibility only.  Even though you 
      // always call setModelDefinition (to finish constructing the model)
      // before calling anything else, you used to be able to get away with
      // calling setPosition() or setOrientation() first.  That's no longer
      // strictly true, so we have to store any position or orientation that
      // gets set and then explicitly use them after setModelDefinition is
      // called.

      DtVector mySetPosition;
      DtTaitBryan mySetOrientation;
      bool myInitialPositionSet;
      bool myInitialOrientationSet;

      bool myInitialPositionOffsetSet;
      bool myInitialOrientationOffsetSet;
      bool myHandlersRegisterered;

      //needed to keep track of the initial state of the model scaling flag
      bool myModelScalingEnabled;

      DtSignalConnectionManager myConnections;

      std::string myLightPointGroupName;


      std::list<std::string> myMovingDynamicRegions;
      std::list<std::string> myPowerPlantDynamicRegions;
      std::list<std::string> myWeaponFireDynamicRegions;

   protected:
      static boost::mutex theBackgroundLoadCloneMutex;

      static const std::unordered_set<int> theStatesToFilter;

      static bool theTrackObjects;
      static std::atomic<int> theTotalObjects;

      // Used for debugging
      static std::unordered_map<std::string, DtModelSetId> theSetEntitiesToTrack;

      std::string myModelTextureVariant;
   };
}