DtOsgArticulatedModel.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvCore/DtArticulatedModel.h>

#include <vrvOsg/DtInstanceState.h>
#include <vrvOsg/DtInstanceUtils.h>

#include <boost/unordered_map.hpp>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvCore/DtMetaFileManager.h>

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

#include <osg/ref_ptr>
#include <osg/Matrixf>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <boost/thread/mutex.hpp>

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

namespace osgSim
{
   class DOFTransform;
   class MultiSwitch;
}

namespace makVrv
{
   class DtInstanceManager;
   class DtOsgSceneConnector;
   class DtModelDefinition;

   class DT_DLL_VRVOSG DtOsgArticulatedModel : public DtArticulatedModel
   {
   public:

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

      DtOsgArticulatedModel(DtDe&, DtUniqueID id);

      virtual ~DtOsgArticulatedModel();


      virtual void setModelDefinition(const std::string& str);
      virtual const std::string& modelDefinition() { return myModelDefinitionName; }

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

      virtual void setModelScalingEnabled(bool b);

      virtual bool modelScalingEnabled();

      virtual void setLocalModelScalingEnabled(bool enabled);

      virtual void setLocalModelScalingAmount(float localScl);

      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 setVisible(bool isVisible);


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

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

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

      virtual void setState(int stateNumber, int stateValue);
      
      virtual void reapplyState();

      int state(int stateNumber) const;

      virtual void setLightpointMaxDistance( float distance );

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

      virtual void setAnimationFrame(const std::string& animationName,
         int frameIndex);

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

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

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

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

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

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

      virtual void setDynamicSensorRegion(const std::string& region, bool state);

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

      virtual void setLinkageConfigPair(const std::string& linkageName, const std::string& configName);


      //@name Non-distributed functions

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

      virtual DtVector partTranslation(int partNumber) const;

      virtual DtTaitBryan partOrientation(int partNumber) const;

      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;

      const DtArticulatedModelParser::PartMap& parts() const;

      virtual void getParts(PartList& parts) const;

      const DtArticulatedModelParser::StateMap& states() const;

      const DtArticulatedModelParser::AnimationMap& animations() const;

      virtual void addPart(int partNumber, osgSim::DOFTransform* node);

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

      virtual void setStateValueExists(int stateNumber, int stateValue);

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

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

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

      virtual void setPartVisibility(int partNumber, bool onOff);

      virtual void setIsSupportModel(bool isSupport);

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

      std::vector<DtVirtualBaseClass*>& modelAttachments();

      virtual bool applyMetafile(const DtModelDefinition* definition);

      virtual void slot_onShadowStateChanged(bool on);

      virtual void slot_atcModeEnableChanged(bool state);


      DtUniqueID sceneObjectId();

      virtual void setElementId(DtUniqueID id);

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

      virtual std::string lightPointGroup();

      virtual LinkageConfigMap& linkageConfigMap();

      virtual const LinkageConfigMap& linkageConfigMap() const;

   protected:

      virtual void setStateInternal(int stateNumber, int stateValue);

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

      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 addToScene(const DtUniqueID& sceneObjectId, int modelSet,
         int visualizerType);
      virtual void removeFromScene();

      virtual void disablePart(int partNumber);
      virtual void enablePart(int partNumber);

      virtual void modelInstanceToBeDeleted();

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

   protected:

      DtInstanceUtils::InstancedAnimationMap myInstancedAnimationMap;
      DtInstanceUtils::InstancedAnnotationMap myInstancedAnnotationMap;
      DtArticulatedModelParser::StateExistenceMap myStateExistenceMap;
      DtArticulatedModelParser::StateValueMap myStateValueMap;

      DtOsgSceneConnector* mySceneConnector;
      DtArticulatedModelParser::PartMap myPartMap;
      DtArticulatedModelParser::StateMap myStateMap;
      DtArticulatedModelParser::AnimationMap myAnimationMap;
      DtArticulatedModelParser::AnnotationMap myAnnotationMap;
      NodePathCache myNodePathCache;
      static const unsigned int theNodePathCacheSize = 4;
      bool myUseSwitch;


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

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

      DtInstanceManager& myInstanceManager;

      DtUniqueID mySceneObjectId;

      DtMetaFileManager::LinkageValueVec myModelMetaFeatures;

      LinkageConfigMap myLinkageConfigMap;

      std::vector<DtVirtualBaseClass*> myModelMetaAttachments;

      DtInstanceUtils::PartMapCache* myPartMapCache;
      DtInstanceUtils::PartMapCache* myStateMapCache;

      typedef std::map<int, std::pair<DtTaitBryan, DtVector> > PartOrientationMap;
      PartOrientationMap myPartOrientationMap;

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

      bool myIsInstanced;

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

      // 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;
      bool myInitialPositionSet;
      DtTaitBryan mySetOrientation;
      bool myInitialOrientationSet;

      bool myInitialPositionOffsetSet;
      bool myInitialOrientationOffsetSet;


      // The model needs to hold on to this so it can provide it to the instance
      // manager if the model is eventually instanced
      DtUniqueID myElementId;
      DtSignalConnectionManager myConnections;

      std::string myLightPointGroup;

      friend class DtArticulatedModelAnimationHelper;

      static boost::mutex theBackgroundLoadCloneMutex;

   };
}