DtOsgArticulatedModel.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2016 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>

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;

      DtOsgArticulatedModel(DtDe&, DtUniqueID id);

      virtual ~DtOsgArticulatedModel();


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

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


      DtUniqueID sceneObjectId();

      virtual void setElementId(DtUniqueID id);

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

      void parseModel(osg::Node* root);

   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, bool> SensorRegionStateMap;
      SensorRegionStateMap mySensorRegionMap;

      DtInstanceManager& myInstanceManager;

      std::string myModelDefinition;

      DtUniqueID mySceneObjectId;

      DtMetaFileManager::LinkageValueVec myModelMetaFeatures;

      std::vector<DtVirtualBaseClass*> myModelMetaAttachments;

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

      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;

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