HBTAvatarMesh.cpp

Go to the documentation of this file.

#include "HBTAvatarMesh.h"
#include "OBT_ASSERT.h"
#include "HBTDataTypes.h"

using namespace std;
using namespace Ogre;
using namespace HBT ;

//------------------------------------------------------------
AvatarMesh::AvatarMesh() 
: _pObjectSceneNode( NULL ), 
  _meshNode( NULL ), 
  _entity( NULL ), 
  _hidden( false ),
  _initialised( false )
{
}

//------------------------------------------------------------
void AvatarMesh::close()
{
  if( _initialised )
  {
    hide( true ) ;
    _pObjectSceneNode->removeChild( _meshNode->getName() ) ;
    _pObjectSceneNode->getParentSceneNode()->removeChild( _pObjectSceneNode->getName() ) ;

    _initialised = false ;
  }
}

//------------------------------------------------------------
AvatarMesh::~AvatarMesh()
{
  close() ;
}

//------------------------------------------------------------
bool AvatarMesh::init( Ogre::SceneManager *ogreSceneManager, 
                       const InitialisationSequence *initSequence )
{
  OBT_ASSERT( ogreSceneManager && "The Scene Manager is invalid" ) ;
  OBT_ASSERT( initSequence->boneNumber.size() == initSequence->postureQuat.size() 
           && "The number of bones and quaternion don't match" ) ;

  if( _initialised ) close() ;

  //verification que le nom de l'entitée n'existe pas déjà, si oui on ajout un suffixe
  std::string changedName( initSequence->humanName ) ;
  std::string sceneMeshName( initSequence->humanName ) ;
  
  for( unsigned int counter = 0u ;ogreSceneManager->hasSceneNode( changedName ); counter++ )
  {
    ostringstream buffer ; 
    buffer << initSequence->humanName << "_#_" << counter ;
    changedName = buffer.str() ;
  }

  //on attache l'objet à la scene
  _entity = ogreSceneManager->createEntity( changedName, initSequence->meshFile ) ;

  if(initSequence->useShadows)
  {
    _entity->setCastShadows( true ) ;
    _entity->getMesh()->buildEdgeList() ;
  }

  //ajout des noeuds de scène
  _pObjectSceneNode = ogreSceneManager->getRootSceneNode()->createChildSceneNode( changedName ) ;
  _meshNode = _pObjectSceneNode->createChildSceneNode(string("mesh") + changedName) ;
  _meshNode->attachObject( _entity ) ;
  _meshNode->setInheritOrientation( true ) ;
  _meshNode->setPosition( Ogre::Vector3::ZERO ) ;  //position 0 par rapport au noeud root MKM: c'est le noeud root MKM qui prendra en charge toutes les orientations et translations
  _meshNode->setOrientation( Ogre::Quaternion::IDENTITY ) ;
  _meshNode->setScale( Ogre::Vector3::UNIT_SCALE ) ;
  
  //contrôle manuel des bones
  _nbBones = _entity->getSkeleton()->getNumBones() ;
  for( unsigned int i = 0u ; i < _nbBones; i++ )
  {
    Bone * bone = _entity->getSkeleton()->getBone( i ) ;
    bone->setManuallyControlled( true ) ;
  }

  //initialisation de la posture et des bones
  setScl( initSequence->generalScale ) ;  // global scale
  setRot( initSequence->rootQuat ) ;      // root orientation
  setPos( initSequence->rootPos ) ;       // root position

  for( unsigned int pos = 0; pos < initSequence->boneNumber.size() ; pos++ )
  {
    Bone * bone =_entity->getSkeleton()->getBone( initSequence->boneNumber.at( pos ) ) ;
    bone->setInheritOrientation( false ) ;

    //il faut multiplier par l'inverse du world orientation de l'entitée car le setOrientation du bones se fait dans le repère de l'entitée en mode inheritOrientation(false)
    bone->setOrientation( _sceneNodeInverseQuat * initSequence->postureQuat.at( pos ) ) ;
    bone->_update( true, true ) ;
  }

  _initialised = true;
  return true;
}

//------------------------------------------------------------
void AvatarMesh::hide( const bool hide )
{
  if( _initialised && _hidden != hide)
  {
    _hidden = hide;
    _entity->setVisible( !_hidden ) ;
  }
}


//------------------------------------------------------------
void AvatarMesh::update( const PostureData& postureData )
{
  if( _initialised )
  {
    setScl(postureData.generalScale) ;  //scale global
    setRot(postureData.rootQuat) ;  //orientation du root
    setPos(postureData.rootPos+Vector3(0,0,0) ) ;    //position du root

    //on applique l'orientation pour les bones:
    for( unsigned int cBone = 0; 
         cBone < postureData.quatModified.size() ; cBone ++ )
    {
      if( postureData.quatModified.at(cBone) )
        setBoneOrientation(cBone, postureData.postureQuat.at( cBone ), true ) ;
    }
  }//fin if initialized
}

//------------------------------------------------------------
Ogre::Vector3 AvatarMesh::getPos() const
{
  Ogre::Vector3 v( Ogre::Vector3::ZERO ) ;
  if( _initialised ) 
  {
    v = _entity->getSkeleton()->getRootBone()->getWorldPosition() ;
    Matrix4 sceneNodeTransform ;
    _meshNode->getWorldTransforms( &sceneNodeTransform ) ;
    v = sceneNodeTransform * v;
  }

  return v;
}

//------------------------------------------------------------
Ogre::Quaternion AvatarMesh::getRot() const
{
  
  return _initialised ?
    _pObjectSceneNode->getWorldOrientation() :
    Ogre::Quaternion::IDENTITY ;
}

//------------------------------------------------------------
Ogre::Vector3 AvatarMesh::getScl() const
{
   return  _initialised ? 
     _pObjectSceneNode->_getDerivedScale() : 
     Ogre::Vector3::UNIT_SCALE ;
}

//------------------------------------------------------------
void AvatarMesh::setPos( const Ogre::Vector3& pos )
{
  assert(_pObjectSceneNode) ;

  Ogre::Vector3 newPos( pos ) ;
  Ogre::Vector3 rootBonePos( _entity->getSkeleton()->getRootBone()->getWorldPosition() ) ;
  Ogre::Vector3 sceneNodeScale( _pObjectSceneNode->getScale() ) ;
  Quaternion sceneNodeOri( _pObjectSceneNode->getWorldOrientation() ) ;

  newPos = newPos - sceneNodeOri * ( rootBonePos * sceneNodeScale ) ;
  _pObjectSceneNode->setPosition( newPos ) ;
  _pObjectSceneNode->_update( true, true ) ;
}

//------------------------------------------------------------
void AvatarMesh::setRot( const Ogre::Quaternion& q )
{
  OBT_ASSERT( _pObjectSceneNode ) ;
  _pObjectSceneNode->setOrientation( q ) ;

  _sceneNodeInverseQuat = _meshNode->getWorldOrientation().Inverse() ;
}

//------------------------------------------------------------
void AvatarMesh::setScl(const Ogre::Vector3& scl)
{
  assert(_pObjectSceneNode) ;
  ( (SceneNode*)_pObjectSceneNode)->setScale(scl[0],scl[1],scl[2]) ;
}

//------------------------------------------------------------  
int AvatarMesh::getBoneID( const string& boneName ) const
{
  return !_initialised ? 
    _entity->getSkeleton()->getBone( boneName )->getHandle() : -1 ;
}

//------------------------------------------------------------
unsigned short AvatarMesh::getNbBones() const
{
  return _initialised ? _nbBones : 0u ;
}
//------------------------------------------------------------
void AvatarMesh::setBoneOrientation( const int boneID, 
                                     const Ogre::Quaternion &q, 
                                     const bool inWorldFrame )
{
  if( _initialised )
  {
    Ogre::Quaternion quat( q ) ;
    Bone * bone = _entity->getSkeleton()->getBone( boneID ) ;

    if( inWorldFrame )
    {
      //il faut multiplier par l'inverse du world orientation de l'entitée car il semblerais que le setOrientation du bones se fait dans le repère de l'entitée en mode inheritOrientation(false)
      quat = _meshNode->getWorldOrientation().Inverse() * quat;
    }

    bone->setOrientation( quat ) ;

    bone->_update( true, true ) ;
  }
}

---