DtArticulatedModelParser.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2021 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
 
#pragma once
#include <vrvCore/DtArticulatedModel.h>
#include <vrvCore/DtModelSemanticsMapper.h>

#include <vrvOsg/DtModelParser.h>

#include <vrvGraphicsUtils/DtVector2.h>

#include <osg/Group>
#include <osg/Sequence>
#include <osgSim/DOFTransform>
#include <osgSim/MultiSwitch>

#include <stack>
#include <unordered_map>

namespace osg
{
   class Group;
   class Sequence;
}

namespace makVrv 
{ 
   class DtOsgArticulatedModel;
   class DtModelSemanticsMapper;

   class DT_DLL_VRVOSG DtArticulatedModelParser : public DtModelParser
   { 
   public:
      typedef std::vector<osg::ref_ptr<osgSim::DOFTransform> > PartTransformList;
      typedef std::unordered_map<int, PartTransformList > PartMap;

      typedef std::vector< osg::ref_ptr<osgSim::MultiSwitch> > MultiSwitchList;
      typedef std::unordered_map<int, MultiSwitchList > MapStateNumberToMultiSwitchList;

      typedef std::vector< osg::ref_ptr<osg::Sequence> > AnimationList;
      typedef std::unordered_map<std::string, AnimationList > AnimationMap;

      typedef std::map<int, int > MapStateNumberToStateValue;
      typedef std::vector<bool> StateExistenceList;
      typedef std::unordered_map<int, StateExistenceList> MapStateNumberToStateExistenceList;

      typedef std::vector< osg::ref_ptr<osg::Group> > GroupList;
      typedef std::unordered_map<std::string, GroupList > AnnotationMap;

      typedef std::vector<bool> ValueList;
      typedef std::vector<ValueList>   SwitchSetList;
      typedef std::map<osgSim::MultiSwitch*, SwitchSetList>   MapMultiSwitchToSwitchSetList;

      enum TrackSide
      {
         TS_LEFT = 0, TS_RIGHT, TS_UKNOWN
      };

      struct SequenceAndParams
      {
      public:
         SequenceAndParams(osg::Sequence* sequence, float multiplier, float duration, float defaultSpeed, TrackSide trackSide)
            : mySequence(sequence)
            , myMuliplier(multiplier)
            , myDuration(duration)
            , myDefaultSpeed(defaultSpeed)
            , myTrackSide(trackSide)
         {
            // nothing else
         }
         SequenceAndParams()
            : myMuliplier(-1)
            , myDuration(0)
            , myDefaultSpeed(0)
            , myTrackSide(TS_UKNOWN)
         {
            // nothing else
         }
      public:
         osg::ref_ptr<osg::Sequence> mySequence;
         
         float myMuliplier;

         float myDuration;

         float myDefaultSpeed;

         TrackSide myTrackSide;
      };

      typedef std::vector< SequenceAndParams> VectorSequenceAndMultipliers;
      typedef std::unordered_map<std::string, VectorSequenceAndMultipliers> FlipBookAnimationMap;

      struct ScrollableTextureGroupAndParams
      {
         ScrollableTextureGroupAndParams(osg::Group* group, Vector2_32 uvMultiplier, TrackSide trackSide)
            : myGroup(group)
            , myMultiplier(uvMultiplier)
            , myTrackSide(trackSide)
         {
            // nothing else
         }

         ScrollableTextureGroupAndParams()
            : myMultiplier(Vector2_32::theZeroVector)
            , myTrackSide(TS_UKNOWN)
         {
            // nothing else
         }
      public:
         osg::ref_ptr<osg::Group> myGroup;

         Vector2_32 myMultiplier;

         TrackSide myTrackSide;
      };

      typedef std::vector< ScrollableTextureGroupAndParams> VectorScrollableTextureGroupAndParams;
      typedef std::map<std::string, VectorScrollableTextureGroupAndParams> ScrollableTextureGroupMap;


      DtArticulatedModelParser(DtDe& de, DtModelSemanticsMapper& modelSematicsMapper);

      virtual ~DtArticulatedModelParser();

      static std::string parserFormat();

      virtual void apply(osg::Group& group);
      virtual void apply(osg::Sequence& sequence);
      virtual void apply(osgSim::MultiSwitch& multiswitch);
      virtual void apply(osgSim::DOFTransform& transform);
      virtual void apply(osg::Transform& transform);

   protected:

      virtual bool parseSwitchDeclaration( const std::string& desc, 
         osgSim::MultiSwitch& multiswitch );

      virtual bool parseDefaultMultiSwitchValues(osgSim::MultiSwitch& multiswitch);

      const DtModelSemanticsMapper::States::Id* createCustomStateId(const std::string& stateName);

      virtual bool parseStateDeclaration( const std::string& desc, 
         osg::Group& group );

      virtual bool parseAnnotationDeclaration( const std::string& desc, 
         osg::Group& group );

      virtual bool parseScrollableTextureDeclaration(const std::string& desc,
         osg::Group& group);

      virtual bool parsePartDeclaration(const std::string& desc,
         osgSim::DOFTransform& transform);

      virtual bool parseAnimationDeclaration(const std::string& desc, osg::Sequence& sequence);

      virtual bool parseFlipBookAnimationDeclaration(const std::string& desc, osg::Sequence& sequence);

      std::vector<int> parseValueList(const std::string& valueList);
     
      void pushStateId(int idNumber, osgSim::MultiSwitch*  lastStateId);

      void popStateId();

      osgSim::MultiSwitch* lastStateId() const;

      int lastStateIdNumber() const;

      void getParts( DtArticulatedModel::PartList& parts ) const;
      const PartMap& parts() const;
      const MapStateNumberToMultiSwitchList& states() const;
      const AnimationMap& animations() const;
      const FlipBookAnimationMap& flipBookAnimations(void) const;
      const FlipBookAnimationMap& flipBookAnimationsWithVelocityControl(void) const;
      void addPart( int partNumber,osgSim::DOFTransform* node );
      void addState( int stateNumber ,osgSim::MultiSwitch* node );
      void addAnimation( const std::string& animationName,osg::Sequence* node );
      void setStateValueExists( int stateNumber, int stateValue );
      void addAnnotationGroup(const std::string& annotation, osg::Group* group);
      void addScrollableTextureGroup(osg::Group* group);
      void setDepthMask( osg::Group& parent );

   protected:
           
      const std::string mySwitchTag;
      const std::string myStateTag;
      const std::string myPartTag;
      const std::string myAnimationTag;
      const std::string mySkipTag;
      const std::string myNoSkipTag;
      const std::string myAnnotationTag;
      const std::string myLoopCountTag;
      const std::string myScrollableTextureTag;
      const std::string myLastFrameTimeTag;

      const std::string myFlipBookAnimationTag;
      const std::string myLoopDurationMultiplierTag;

      std::stack<osg::ref_ptr<osgSim::MultiSwitch> > myStateIds;
      std::stack<int> myStateIdNumbers;

      DtDe& myDe;

   public:
      PartMap myPartMap;
      AnimationMap myAnimationMap;
      FlipBookAnimationMap myFlipBookAnimationMap;
      FlipBookAnimationMap myFlipBookAnimationMapWithVelocityControl;
      AnnotationMap myAnnotationMap;
      ScrollableTextureGroupMap myScrollableTextureGroupMap;

      MapStateNumberToStateExistenceList myMapStateNumberToStateExistenceList;
      MapStateNumberToStateValue myMapStateNumberToStateValue;
      MapStateNumberToMultiSwitchList myMapStateNumberToMultiSwitchList;
      MapMultiSwitchToSwitchSetList myDefaultActiveSwitchState;

      DtModelSemanticsMapper& myModelSematicsMapper;
   }; 

   class DT_DLL_VRVOSG DtArticulatedModelParserCreator : public PrModelParserCreator
   {
   public:

      static void registerCreator(DtDe& de);
      
      DtArticulatedModelParserCreator();

      virtual ~DtArticulatedModelParserCreator();

      virtual DtModelParser* create(DtDe& de);
   };
  
}