SO3Skeleton.cpp

Go to the documentation of this file.

 
#include "SO3SceneGraph/SO3Skeleton.h"
#include "SO3SceneGraph/SO3Entity.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Bone.h"
#include "SO3Animation/SO3SkeletonAnimation.h"
 
namespace SO3
{
 
SSkeleton::SSkeleton(SScene* parent, const std::string& skeletonName, SEntity* parentEntity) : SNode(parent, skeletonName, SNode::SKELETON_TYPE_ID)
{
  assert(parentEntity != 0);
  linkedEntity = parentEntity;
 
  ogreLinkedEntity = linkedEntity->getOgreEntityPointer();
  
  // debug skeletons
  //parentEntity->getOgreEntityPointer()->setDebugDisplayEnabled(true);
  //parentEntity->getOgreEntityPointer()->setDisplaySkeleton(true);
}
 
SSkeleton::SSkeleton() : SNode(0, "", SNode::SKELETON_TYPE_ID)
{
  // Forbiden (private)
}
 
void SSkeleton::Initialise()
{
  // Create bones
  Ogre::SkeletonInstance* O3SkeletonInstance = ogreLinkedEntity->getSkeleton();
  if (!O3SkeletonInstance)
    return;
 
  unsigned short numBones = O3SkeletonInstance->getNumBones();
  for (unsigned short i=0; i<numBones; i++)
  {
    Ogre::Bone* ogreBone = O3SkeletonInstance->getBone(i);
 
    std::string tmpBoneName(linkedEntity->GetName() + "." + ogreBone->getName());
    SBone* newBone = currentScene->CreateBone(tmpBoneName, this,  i);
    AddBone(newBone);
  }
 
  // Once all our bones are created, reconstruct the hierarchy.
  rootBonesList.clear();
  for (unsigned short i=0; i<numBones; i++)
  {
    SBone* newBone = GetBone(i);
    Ogre::Bone* ogreBone = O3SkeletonInstance->getBone(i);
    
    Ogre::Bone* parentBone = static_cast<Ogre::Bone*> (ogreBone->getParent());
    if (parentBone == 0)
    {
      newBone->AttachToParent(this);
      rootBonesList.insert(SBoneMap::value_type(newBone->GetName(), newBone));
    }
    else
      newBone->AttachToParent(GetBone(parentBone->getHandle()));
  }
 
  // Create animations
  unsigned short numAnimations = O3SkeletonInstance->getNumAnimations();
  for (unsigned short i=0; i<numAnimations; i++)
  {
    Ogre::Animation* ogreAnimation = O3SkeletonInstance->getAnimation(i);
    SAnim* anim = new SSkeletonAnimation(GetParentScene(), ogreAnimation->getName(), this, i);
    AddAnimation(anim);
 
    // TODO vertex track animations
    /*Ogre::Animation::VertexTrackIterator it = ogreAnimation->getVertexTrackIterator();
                while(it.hasMoreElements())
                {
                        Ogre::VertexAnimationTrack* ogreVertexTrack = it.getNext();
                        SAnimTrack* animationTrack = new SAnimTrack("TODO JEFF", anim, myTrack);
                        anim->listOfAnimationTrack.insert(SAnimTrackMap::value_type("TODO JEFF", animationTrack));
                        int     at = createAnimTrack(m,animationTrack, anim);
                }*/
  }
 
        // Create animations
        /*for(int i=0; i<O3SkeletonInstance->getNumAnimations(); i++)
        {
                // get all animations from list by entity and by type
                SAnim* anim = NULL;
 
                GetAnimByName(scene, &anim, node, entity->getOgreEntityPointer()->getName()+"."+oanim->getName());
                if(anim == NULL)
                {
                        anim = new SAnim(oanim->getName(), SAnim::SO3_VERTEX_ANIM); // TODO JEFF: bizarre, j'aurais mis SO3_SKELETON_ANIM ici.
                        anim->setOgreAnimationPointer(oanim);
 
                        anim->setAssociatedNodePointer(node);
                        anim->sceneName = scene->O3SceneManager->getName().c_str();
 
                        // Create AnimationTrack for each anim
      scene->listOfAnim.insert(SAnimMap::value_type(, anim));
                        int     a = createAnim(m,anim, entity);
 
 
                        Ogre::Animation::VertexTrackIterator it = anim->getOgreAnimationPointer()->getVertexTrackIterator();
                        while(it.hasMoreElements())
                        {
                                Ogre::VertexAnimationTrack* myTrack = static_cast <Ogre::VertexAnimationTrack*> (it.getNext());
                                SAnimTrack* animationTrack = new SAnimTrack("TODO JEFF", anim, myTrack);
                                anim->listOfAnimationTrack.insert(SAnimTrackMap::value_type("TODO JEFF", animationTrack));
                                int     at = createAnimTrack(m,animationTrack, anim);
                        }
                }
                else
                {
                        //TODO update tracks
                        anim->setOgreAnimationPointer(oanim);
                }
        }*/
  ogreLinkedEntity->setUpdateBoundingBoxFromSkeleton((O3SkeletonInstance->getNumBones() > 1) ? true : false);
  ogreLinkedEntity->getMesh()->_setBoneBoundingRadius(std::max(ogreLinkedEntity->getMesh()->getBoneBoundingRadius(), 0.1f));
 
  linkedEntity->_SetSkeleton(this);
}
 
SSkeleton::~SSkeleton()
{
  // Animation deletion is done by SNode destructor,
  // No need to be done there.
 
  // Erase all bones
  SBoneMap boneListCopy = boneList;
  SBoneMap::const_iterator iBone = boneListCopy.begin();
  while(iBone != boneListCopy.end())
  {
    RemoveBone(iBone->second);
    
    //scol must do this
    //currentScene->DeleteBone(iBone->second);
    iBone++;
  }
 
  linkedEntity = 0;
}
 
void SSkeleton::SetBindingPose()
{
  Ogre::SkeletonInstance* O3SkeletonInstance = ogreLinkedEntity->getSkeleton();
  O3SkeletonInstance->setBindingPose();
}
 
SSkeleton::SkeletonAnimationMode SSkeleton::GetBlendMode()
{
  Ogre::SkeletonInstance* O3SkeletonInstance = ogreLinkedEntity->getSkeleton();
  return static_cast <SkeletonAnimationMode> (O3SkeletonInstance->getBlendMode());
}
 
void SSkeleton::SetBlendMode(const SSkeleton::SkeletonAnimationMode& newBlendMode)
{
  Ogre::SkeletonInstance* O3SkeletonInstance = ogreLinkedEntity->getSkeleton();
  O3SkeletonInstance->setBlendMode(static_cast <Ogre::SkeletonAnimationBlendMode> (static_cast <int> (newBlendMode)));
}
 
void SSkeleton::AddBone(SBone* existingBone)
{
  string boneName = existingBone->GetName();
  SBoneMap::iterator iBoneSearched = boneList.find(boneName);
  if (iBoneSearched == boneList.end())
  {
    boneList.insert(SBoneMap::value_type(boneName, existingBone));
    boneListByIndex.insert(SBoneIndexMap::value_type(existingBone->GetIndex(), existingBone));
  }
  else
  {
    // Bone already exist in the handled bones list.
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Can not add bone named \""+ boneName +"\", an element with the same name already exist!", "SSkeleton::AddBone");
  }
}
 
void SSkeleton::RemoveBone(SBone* existingBone)
{
  RemoveBone(existingBone->GetName());
}
 
void SSkeleton::RemoveBone(const std::string& boneName)
{
  SBoneMap::iterator iBoneSearched = boneList.find(boneName);
  if (iBoneSearched != boneList.end())
  {
    SBone* findedBone = iBoneSearched->second;
    boneList.erase(iBoneSearched);
 
    //reset skeleton
    findedBone->UnsetSkeleton();
 
    // Delete from index map too
    SBoneIndexMap::iterator iBoneIndexSearched = boneListByIndex.find(findedBone->GetIndex());
    boneListByIndex.erase(iBoneIndexSearched);
 
    // Remove from the root bone list if in.
    SBoneMap::iterator iBoneRootSearched = rootBonesList.find(boneName);
    if(iBoneRootSearched != rootBonesList.end())
      rootBonesList.erase(iBoneRootSearched);
  }
  else
  {
    // Bone not found in the handled bones list
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Can not remove Bone named \""+ boneName +"\", element not found!", "SSkeleton::RemoveBone");
  }
}
 
void SSkeleton::_OnBoneDeletion(SBone* boneInstance)
{
  assert(boneInstance != 0);
  if(GetBone(boneInstance->GetName()) != boneInstance)
    return;
    //OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Cannot remove a bone that is not handled by this skeleton, or bone already removed", "SSkeleton::_OnBoneDeletion");
 
  RemoveBone(boneInstance);
}
 
unsigned short SSkeleton::GetNumBones()
{
  return boneList.size();
}
 
SBone* SSkeleton::GetBone(const std::string& boneName)
{
  SBoneMap::iterator iBoneSearched = boneList.find(boneName);
  if (iBoneSearched != boneList.end())
    return iBoneSearched->second;
  else
    return 0;
}
 
SBone* SSkeleton::GetBone(const unsigned short& boneIndex)
{
  SBoneIndexMap::iterator iBoneSearched = boneListByIndex.find(boneIndex);
  if (iBoneSearched != boneListByIndex.end())
    return iBoneSearched->second;
  else
    return 0;
}
 
SBoneMap SSkeleton::GetBones() const
{
  return boneList;
}
 
Ogre::SkeletonInstance* SSkeleton::GetOgreSkeletonPointer()
{
  return ogreLinkedEntity->getSkeleton();;
}
 
SEntity* SSkeleton::GetParentEntity()
{
  return linkedEntity;
}
 
SBoneMap SSkeleton::GetRootBones()
{
  return rootBonesList;
}
 
Ogre::Vector3 SSkeleton::GetGlobalPosition()
{
  return Ogre::Vector3::ZERO;
}
 
Ogre::Quaternion SSkeleton::GetGlobalOrientation()
{
  return Ogre::Quaternion::IDENTITY;
}
 
Ogre::Vector3 SSkeleton::GetGlobalScale()
{
  return Ogre::Vector3::UNIT_SCALE;
}
 
void SSkeleton::SetGlobalPosition(const Ogre::Vector3& pos, bool updateBody)
{
  //Invalid on skeleton
}
 
void SSkeleton::SetGlobalOrientation(const Ogre::Quaternion& quat, bool updateBody)
{
  //Invalid on skeleton
}
 
}