SO3Bone.cpp

Go to the documentation of this file.

 
#include "SO3SceneGraph/SO3Bone.h"
#include "SO3SceneGraph/SO3Skeleton.h"
#include "SO3SceneGraph/SO3Entity.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Animation/SO3Anim.h"
 
namespace SO3
{
 
  SBone::SBone(SScene* parent, const std::string& boneName, SSkeleton* skeleton, const unsigned short& id) : SNode(parent, boneName, SNode::BONE_TYPE_ID)
  {
    parentSkeleton = skeleton;
    ogreLinkedEntity = parentSkeleton->GetParentEntity()->getOgreEntityPointer();
    boneIndex = id;
 
    //Do not get the Ogre::bone pointer here, it can change on resource reload
 
    /* TODO Jeff: use BaseMeshUtils to generate a mesh corresponding to this bone, to show it with SNode SetVisible function.
    // Create a visualization for debugging.
    Ogre::Vector3 parentPosition;
    Ogre::Bone* ogreParentBone = static_cast <Ogre::Bone*> (O3Bone->getParent());
    if (ogreParentBone == 0)
    {
      parentPosition = Ogre::Vector3::ZERO;
      // TODO: orientation (bone turned along is local y axis).
    }
    else
    {
      parentPosition = ogreParentBone->getPosition();
      // TODO: orientation (bone turned along is local y axis).
    }
    float boneLength = parentPosition.distance(O3Bone->getPosition());
 
    Ogre::Entity* boneHelperEntity = currentScene->GetOgreScenePointer()->createEntity(boneName, "SO3/Bone/Helper/Mesh", SO3_INTERNAL_RESOURCE_GROUP);
    boneHelperEntity->setMaterialName("SO3/Bone/Helper/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::SceneNode* tempNode = currentScene->GetOgreScenePointer()->getRootSceneNode()->createChildSceneNode("test_"+boneName);
 
    O3SceneNode->attachObject(boneHelperEntity);
    O3SceneNode->setScale(Ogre::Vector3::UNIT_SCALE * boneLength);
    O3SceneNode->setVisible(true, true);*/
  }
 
  SBone::SBone() : SNode(0, "", SNode::BONE_TYPE_ID)
  {
    // Forbiden (private)
  }
 
  SBone::~SBone()
  {
    // Be sure that skeleton will not have this instance in is list after the deletion.
    if (parentSkeleton)
      parentSkeleton->_OnBoneDeletion(this);
 
    parentSkeleton = 0;
    ogreLinkedEntity = 0;
  }
 
  void SBone::UnsetSkeleton()
  {
    parentSkeleton = 0;
    ogreLinkedEntity = 0;
  }
 
  Ogre::Bone* SBone::GetOgreBonePointer()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return NULL;
 
    return parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
  }
 
  SSkeleton* SBone::GetSkeleton()
  {
    return parentSkeleton;
  }
 
  void SBone::Rotate(const Ogre::Vector3& axis, const float& radianAngle, const SNode::NodeTransformSpace& relativeTo)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    O3Bone->setManuallyControlled(true);
    O3Bone->rotate(axis, Ogre::Radian(radianAngle), static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
    //currentEntity->verticesNeedUpdate = true;
    UpdateNodeBody(false);
  }
 
  void SBone::SetOrientation(const Ogre::Quaternion& quat)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Quaternion tempQuat(quat);
    tempQuat.normalise();
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    O3Bone->setManuallyControlled(true);
    O3Bone->setOrientation(tempQuat);
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
    UpdateNodeBody(false);
  }
 
  void SBone::AddOrientation(const Ogre::Quaternion& quat)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Quaternion tempQuat(quat);
    tempQuat.normalise();
 
    if (tempQuat != Ogre::Quaternion::ZERO)
      SetOrientation(GetOrientation() * tempQuat);
 
    UpdateNodeBody(false);
  }
 
  void SBone::ResetToInitialOrientation()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
 
    O3Bone->setManuallyControlled(true);
    O3Bone->resetOrientation();
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
    UpdateNodeBody(false);
  }
 
  void SBone::SetPosition(const Ogre::Vector3& pos)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
 
    O3Bone->setManuallyControlled(true);
    O3Bone->setPosition(pos);
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
    UpdateNodeBody(false);
  }
 
  void SBone::Translate(const Ogre::Vector3& d, const SNode::NodeTransformSpace& relativeTo)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
 
    O3Bone->setManuallyControlled(true);
    O3Bone->translate(d, static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
    UpdateNodeBody(false);
  }
 
  void SBone::SetScale(const Ogre::Vector3& scale)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
 
    O3Bone->setManuallyControlled(true);
    O3Bone->setScale(scale);
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
    UpdateNodeBody(false);
  }
 
  Ogre::Vector3 SBone::GetPosition()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return Ogre::Vector3::ZERO;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    return O3Bone->getPosition();
  }
 
  Ogre::Quaternion SBone::GetOrientation()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return Ogre::Quaternion::IDENTITY;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    return O3Bone->getOrientation();
  }
 
  Ogre::Vector3 SBone::GetScale()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return Ogre::Vector3::UNIT_SCALE;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    return O3Bone->getScale();
  }
 
  Ogre::Vector3 SBone::GetInitialPosition()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return Ogre::Vector3::ZERO;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    return O3Bone->getInitialPosition();
  }
 
  Ogre::Quaternion SBone::GetInitialOrientation()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return Ogre::Quaternion::IDENTITY;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    return O3Bone->getInitialOrientation();
  }
 
  Ogre::Vector3 SBone::GetInitialScale()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return Ogre::Vector3::ZERO;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    return O3Bone->getInitialScale();
  }
 
  //VERIFIED OK
  Ogre::Vector3 SBone::GetGlobalPosition()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return Ogre::Vector3::ZERO;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    Ogre::SceneNode* parent = ogreLinkedEntity->getParentSceneNode();
    parent->_update(false, true);
    Ogre::Quaternion parentQuat = parent->_getDerivedOrientation();
    Ogre::Vector3 parentPos = parent->_getDerivedPosition();
    Ogre::Vector3 parentScale = parent->_getDerivedScale();
    O3Bone->_update(false, true);
    Ogre::Vector3 bonePos = O3Bone->_getDerivedPosition();
 
    Ogre::Vector3 globalPosition = parentPos + (parentQuat * (bonePos * parentScale));
    return globalPosition;
  }
 
  Ogre::Quaternion SBone::GetGlobalOrientation()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return Ogre::Quaternion::IDENTITY;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    Ogre::SceneNode* parent = ogreLinkedEntity->getParentSceneNode();
    parent->_update(false, true);
    Ogre::Quaternion parentQuat = parent->_getDerivedOrientation();
    O3Bone->_update(false, true);
    Ogre::Quaternion boneQuat = O3Bone->_getDerivedOrientation();
 
    Ogre::Quaternion globalOrientation = parentQuat * boneQuat;
 
    //Ogre::Quaternion testLocQuat = globalOrientation * parentQuat.Inverse();
 
    return globalOrientation;
  }
 
  Ogre::Vector3 SBone::GetGlobalScale()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return Ogre::Vector3::UNIT_SCALE;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    Ogre::Matrix4 mat = ogreLinkedEntity->_getParentNodeFullTransform();
    Ogre::Vector3 col1(mat[0][0], mat[1][0], mat[2][0]);
    Ogre::Vector3 col2(mat[0][1], mat[1][1], mat[2][1]);
    Ogre::Vector3 col3(mat[0][2], mat[1][2], mat[2][2]);
 
    Ogre::Vector3 sc;
    sc.x = col1.length();
    sc.y = col2.length();
    sc.z = col3.length();
 
    return O3Bone->_getDerivedScale() * sc;
  }
 
  //VERIFIED OK
  void SBone::SetGlobalPosition(const Ogre::Vector3& pos, bool updateBody)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    Ogre::SceneNode* parent = ogreLinkedEntity->getParentSceneNode();
    parent->_update(false, true);
    Ogre::Quaternion parentQuat = parent->_getDerivedOrientation();
    Ogre::Vector3 parentPos = parent->_getDerivedPosition();
    Ogre::Vector3 parentScale = parent->_getDerivedScale();
 
    //to avoid division by 0
    if (parentScale == Ogre::Vector3::ZERO)
      parentScale = Ogre::Vector3(0.000001f, 0.000001f, 0.000001f);
 
    Ogre::Vector3 globalPosition = parentQuat.Inverse() * ((pos - parentPos) * (1.0 / parentScale));
 
    O3Bone->setManuallyControlled(true);
 
    //Ogre bug do not verify that a parent is available
    if (O3Bone->getParent() == 0)
      O3Bone->setPosition(globalPosition);
    else
      O3Bone->_setDerivedPosition(globalPosition);
 
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
 
    if (updateBody)
      UpdateNodeBody(false);
  }
 
  void SBone::SetGlobalOrientation(const Ogre::Quaternion& quat, bool updateBody)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    Ogre::SceneNode* parent = ogreLinkedEntity->getParentSceneNode();
    parent->_update(false, true);
    Ogre::Quaternion parentQuat = parent->_getDerivedOrientation();
 
    Ogre::Quaternion globalOrientation = parentQuat.Inverse() * quat;
 
    O3Bone->setManuallyControlled(true);
 
    //Ogre bug do not verify that a parent is available
    if (O3Bone->getParent() == 0)
      O3Bone->setOrientation(globalOrientation);
    else
      O3Bone->_setDerivedOrientation(globalOrientation);
 
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
 
    if (updateBody)
      UpdateNodeBody(false);
  }
 
  void SBone::SetGlobalScale(const Ogre::Vector3& scale, bool updateBody)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    Ogre::SceneNode* parent = ogreLinkedEntity->getParentSceneNode();
    parent->_update(false, true);
 
    O3Bone->setManuallyControlled(true);
    if (O3Bone->getParent() == 0)
      O3Bone->setScale(scale / parent->_getDerivedScale());
    else
      O3Bone->setScale(scale / parent->_getDerivedScale() / O3Bone->getParent()->_getDerivedScale());
 
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
 
    if (updateBody)
      UpdateNodeBody(false);
  }
 
  Ogre::Matrix4 SBone::GetTransformationMatrix()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return Ogre::Matrix4::IDENTITY;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    return O3Bone->_getFullTransform();
  }
 
  void SBone::Pitch(const float& radianAngle, const SNode::NodeTransformSpace& relativeTo)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    O3Bone->setManuallyControlled(true);
    O3Bone->pitch(Ogre::Radian(radianAngle), static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
    UpdateNodeBody(false);
  }
 
  void SBone::Yaw(const float& radianAngle, const SNode::NodeTransformSpace& relativeTo)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    O3Bone->setManuallyControlled(true);
    O3Bone->yaw(Ogre::Radian(radianAngle), static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
    UpdateNodeBody(false);
  }
 
  void SBone::Roll(const float& radianAngle, const SNode::NodeTransformSpace& relativeTo)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    O3Bone->setManuallyControlled(true);
    O3Bone->roll(Ogre::Radian(radianAngle), static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
    UpdateNodeBody(false);
  }
 
  int SBone::GetNumChildren()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return 0;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    return O3Bone->numChildren();
  }
 
  void SBone::StoreInitialPRS()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    O3Bone->setManuallyControlled(true);
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
 
    initialPosition = O3Bone->_getDerivedPosition();
    initialOrientation = O3Bone->_getDerivedOrientation();
    initialScale = GetGlobalScale();
  }
 
  void SBone::ResetToInitialPRS()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
 
    O3Bone->setManuallyControlled(true);
    //O3Bone->resetToInitialState();
 
    if (O3Bone->getParent())
    {
      O3Bone->_setDerivedPosition(initialPosition);
      O3Bone->_setDerivedOrientation(initialOrientation);
    }
    else
    {
      O3Bone->setPosition(initialPosition);
      O3Bone->setOrientation(initialOrientation);
    }
    O3Bone->setInitialState();
    O3Bone->setManuallyControlled(false);
    SetGlobalScale(initialScale);
  }
 
  unsigned short SBone::GetIndex()
  {
    return boneIndex;
  }
 
  void SBone::AttachToBone(SNode* newChild)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    Ogre::MovableObject* ogreObject = newChild->GetMovableObjectPointer();
    if (ogreObject != 0)
    {
      // Detach from previous parent
      // If our ogre is anterior to v1.7
#if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
      ogreObject->detatchFromParent();
#else
      ogreObject->detachFromParent();
#endif
 
      // Re-attach to bone.
      ogreLinkedEntity->attachObjectToBone(O3Bone->getName(), ogreObject, O3SceneNode->getOrientation(), O3SceneNode->getPosition());
    }
  }
 
  void SBone::DetachFromBone(SNode* existingChild)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::MovableObject* ogreObject = existingChild->GetMovableObjectPointer();
 
    if (ogreObject != 0)
    {
      bool isBoneAttached = false;
 
      // If our ogre is anterior to v1.7
#if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
      if (ogreObject->isAttached())
      {
        Ogre::Node* np = ogreObject->getParentNode();
        Ogre::SceneNode* snp = ogreObject->getParentSceneNode();
 
        if (snp != np)  // attached to TagPoint
          isBoneAttached = true;
      }
#else
      isBoneAttached = ogreObject->isParentTagPoint();
#endif
 
      // Check if the entity is really attached to the bone.
      if (isBoneAttached)
      {
        // Detach from bone.
        ogreLinkedEntity->detachObjectFromBone(ogreObject);
 
        // Re-attach to the original SNode's ogre scene node
        existingChild->GetOgreSceneNodePointer()->attachObject(ogreObject);
      }
    }
  }
 
  void SBone::AttachToBone(Ogre::MovableObject* ogreObject)
  {
    if (!ogreLinkedEntity || !parentSkeleton || !ogreObject)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    ogreObject->detachFromParent();
 
    // Re-attach to bone.
    ogreLinkedEntity->attachObjectToBone(O3Bone->getName(), ogreObject, Ogre::Quaternion::IDENTITY, Ogre::Vector3::ZERO);
  }
 
  void SBone::DetachFromBone(Ogre::MovableObject* ogreObject)
  {
    if (!ogreLinkedEntity || !parentSkeleton || !ogreObject)
      return;
 
    ogreLinkedEntity->detachObjectFromBone(ogreObject);
  }
 
  Ogre::Quaternion SBone::ConvertWorldToLocalOrientation(const Ogre::Quaternion& quat)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return Ogre::Quaternion::IDENTITY;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    return O3Bone->convertWorldToLocalOrientation(quat);
  }
 
  void SBone::SetInheritOrientation(const bool& state)
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    O3Bone->setInheritOrientation(state);
  }
 
  bool SBone::GetInheritOrientation()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return false;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    return O3Bone->getInheritOrientation();
  }
 
  void SBone::ResetOrientation()
  {
    if (!ogreLinkedEntity || !parentSkeleton)
      return;
 
    Ogre::Bone* O3Bone = parentSkeleton->GetOgreSkeletonPointer()->getBone(boneIndex);
    O3Bone->resetOrientation();
  }
 
}