SO3Engine/SO3SceneGraph/SO3Bone.cpp

Go to the documentation of this file.

#include "SO3Bone.h"
#include "SO3Skeleton.h"
#include "SO3Entity.h"
#include "SO3Scene.h"

namespace SO3
{

SBone::SBone(SScene* parent, std::string boneName, SSkeleton* skeleton, unsigned short id) : SNode(parent, boneName, SNode::BONE_TYPE_ID)
{
  parentSkeleton = skeleton;
  ogreLinkedEntity = parentSkeleton->GetParentEntity()->getOgreEntityPointer();
  O3Bone = skeleton->GetOgreSkeletonPointer()->getBone(id);

  assert(O3Bone != 0);
  boneIndex = id;

  /* 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.
  parentSkeleton->_OnBoneDeletion(this);

  parentSkeleton = 0;
  ogreLinkedEntity = 0;
        O3Bone = 0;
}

Ogre::Bone* SBone::GetOgreBonePointer() 
{
        return O3Bone;
}

void SBone::Rotate(Ogre::Vector3 axis, float radianAngle, SNode::NodeTransformSpace relativeTo)
{
        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;
}

void SBone::SetOrientation(Ogre::Quaternion quat)
{
  quat.normalise();

        O3Bone->setManuallyControlled(true);
        O3Bone->setOrientation(quat);
        O3Bone->setInitialState();
        O3Bone->setManuallyControlled(false);
}

void SBone::AddOrientation(Ogre::Quaternion quat)
{
  quat.normalise();

  if (quat != Ogre::Quaternion::ZERO)
  {
          Ogre::Quaternion oldQuat = GetOrientation();
          Ogre::Quaternion resultQuat = oldQuat * quat;

          SetOrientation(resultQuat);
  }
}

void SBone::ResetToInitialOrientation()
{
        O3Bone->setManuallyControlled(true);
        O3Bone->resetOrientation();
        O3Bone->setInitialState();
        O3Bone->setManuallyControlled(false);
}

void SBone::SetPosition(Ogre::Vector3 pos)
{
        O3Bone->setManuallyControlled(true);
        O3Bone->setPosition(pos);
        O3Bone->setInitialState();
        O3Bone->setManuallyControlled(false);
}

void SBone::Translate(Ogre::Vector3 d, SNode::NodeTransformSpace relativeTo)
{
        O3Bone->setManuallyControlled(true);
        O3Bone->translate(d, static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
        O3Bone->setInitialState();
        O3Bone->setManuallyControlled(false);
}

void SBone::SetScale(Ogre::Vector3 scale)
{
        O3Bone->setManuallyControlled(true);
        O3Bone->setScale(scale);
        O3Bone->setInitialState();
        O3Bone->setManuallyControlled(false);
}

Ogre::Vector3 SBone::GetPosition()
{
  return O3Bone->getPosition();
}

Ogre::Quaternion SBone::GetOrientation()
{
  return O3Bone->getOrientation();
}

Ogre::Vector3 SBone::GetScale()
{
  return O3Bone->getScale();
}

Ogre::Vector3 SBone::GetInitialPosition()
{
  return O3Bone->getInitialPosition();
}

Ogre::Quaternion SBone::GetInitialOrientation()
{
  return O3Bone->getInitialOrientation();
}

Ogre::Vector3 SBone::GetInitialScale()
{
  return O3Bone->getInitialScale();
}

//VERIFIED OK
Ogre::Vector3 SBone::GetGlobalPosition()
{
  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()
{
  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()
{
  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(Ogre::Vector3 pos)
{
  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(FLT_MIN,FLT_MIN, FLT_MIN);
  
  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);
}

void SBone::SetGlobalOrientation(Ogre::Quaternion quat)
{
  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);
}

void SBone::SetGlobalScale(Ogre::Vector3 scale)
{
  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);
}

Ogre::Matrix4 SBone::GetTransformationMatrix()
{
  return O3Bone->_getFullTransform();
}

void SBone::Pitch(float radianAngle, SNode::NodeTransformSpace relativeTo)
{
  O3Bone->setManuallyControlled(true);
  O3Bone->pitch(Ogre::Radian(radianAngle), static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
        O3Bone->setInitialState();
        O3Bone->setManuallyControlled(false);
}

void SBone::Yaw(float radianAngle, SNode::NodeTransformSpace relativeTo)
{
  O3Bone->setManuallyControlled(true);
  O3Bone->yaw(Ogre::Radian(radianAngle), static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
        O3Bone->setInitialState();
        O3Bone->setManuallyControlled(false);
}

void SBone::Roll(float radianAngle, SNode::NodeTransformSpace relativeTo)
{
  O3Bone->setManuallyControlled(true);
  O3Bone->roll(Ogre::Radian(radianAngle), static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
        O3Bone->setInitialState();
        O3Bone->setManuallyControlled(false);
}

int SBone::GetNumChildren()
{
  return O3Bone->numChildren();
}

void SBone::StoreInitialPRS()
{
  O3Bone->setManuallyControlled(true);
  O3Bone->setInitialState();
  O3Bone->setManuallyControlled(false);
}

void SBone::ResetToInitialPRS()
{
  O3Bone->setManuallyControlled(true);
  O3Bone->resetToInitialState();
        O3Bone->setManuallyControlled(false);
}

unsigned short SBone::GetIndex()
{
  return boneIndex;
}

void SBone::AttachToBone(SNode* newChild)
{
  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)
{
  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);
    }
        }
}

Ogre::Quaternion SBone::ConvertWorldToLocalOrientation(Ogre::Quaternion quat)
{ 
  return O3Bone->convertWorldToLocalOrientation(quat);
}

void SBone::SetInheritOrientation(bool state)
{ 
  O3Bone->setInheritOrientation(state);
}

bool SBone::GetInheritOrientation()
{ 
  return O3Bone->getInheritOrientation();
}

void SBone::ResetOrientation()
{
  O3Bone->resetOrientation();
}

}

---