DtOsgArticulatedModel.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvCore/DtArticulatedModel.h>

#include <vrvOsg/DtInstanceState.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>

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::vector<osg::ref_ptr<osgSim::DOFTransform> > PartTransformList;
      typedef boost::unordered_map<int, PartTransformList > PartMap;

      typedef std::vector< osg::ref_ptr<osgSim::MultiSwitch> > StateList;
      typedef boost::unordered_map<int, StateList > StateMap;

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

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

      DtOsgArticulatedModel(DtDe&, DtUniqueID id);

      virtual ~DtOsgArticulatedModel();


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

      virtual std::string className() const;

      virtual void setModelScalingEnabled( bool b );

      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 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 setState(int stateNumber, int stateValue);

      int state( int stateNumber ) const;

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


      //@name Non-distributed functions

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

      DtVector partTranslation(int partNumber);

      DtTaitBryan partOrientation(int partNumber);

      int state(int stateNumber);

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

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

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

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

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

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

      const PartMap& parts() const;

      virtual void getParts(PartList& parts) const;

      const StateMap& states() const;

      const 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 setBlendColor(float r, float g, float b, float a);
      
      virtual void setPartVisibility(int partNumber, bool onOff);

      virtual void setSolid(bool isSolid);

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

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

      virtual bool applyMetafile(const DtModelDefinition* definition);


      DtUniqueID sceneObjectId();

   protected:

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

      virtual void calculateInstancedBounds(double& radius, DtVector& center );

      static void matrixdToTaitBryan( const osg::Matrixd& rotation, DtTaitBryan& tb );
      static double clampUnity( double x );

      
   protected:



      typedef std::map<std::string, unsigned int> InstancedAnimationMap;
      InstancedAnimationMap myInstancedAnimationMap;

      typedef std::vector<ArrayRange> ArrayRangeList;
      typedef std::map<std::string, ArrayRangeList> InstancedAnnotationMap;
      InstancedAnnotationMap myInstancedAnnotationMap;

      typedef std::vector<bool> StateExistenceList;
      typedef boost::unordered_map<int, StateExistenceList> StateExistenceMap;
      StateExistenceMap myStateExistenceMap;

      typedef std::map<int, int > StateValueMap;
      StateValueMap myStateValueMap;

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

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

      DtInstanceManager& myInstanceManager;

      std::string myModelDefinition;

      DtUniqueID mySceneObjectId;

      DtMetaFileManager::LinkageValueVec myModelMetaFeatures;
      std::vector<DtVirtualBaseClass*> myModelMetaAttachments;

      typedef std::vector<unsigned int> InstancedPartVec;

      typedef std::map<unsigned int, InstancedPartVec> PartToInstancedPartMap;

      class PartMapCache : public DtVirtualBaseClass
      {
      public:
         virtual ~PartMapCache();
         PartToInstancedPartMap myPartMap;
      };

      class AnimationMapCache : public DtVirtualBaseClass
      {
      public:
         virtual ~AnimationMapCache();
         InstancedAnimationMap myAnimationMap;
      };

      class BoundingBoxCache : public DtVirtualBaseClass
      {
      public:
         virtual ~BoundingBoxCache();
         DtVector boundMin;
         DtVector boundMax;
      };

      class AnnotationCache : public DtVirtualBaseClass
      {
      public:
         virtual ~AnnotationCache();
         InstancedAnnotationMap myAnnotationMap;
      };

      PartMapCache* myPartMapCache;
      PartMapCache* myStateMapCache;

      DtVector myBoundMin, myBoundMax;

      bool myIsInstanced;

      // 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;
   }; 
}