ALSkeleton.cpp

Go to the documentation of this file.

#include "SO3SceneLoader/ALSkeleton.h"
#include "SO3SceneLoader/ALKeyFrame.h"
 
#include <exception>
#include <stack>
 
namespace SO3
{
  aiNode* ALSkeleton::findMeshNode(aiNode* node, const aiMesh* mesh)
  {
    if (node == nullptr)
      return nullptr;
 
    for (unsigned int i = 0; i < node->mNumMeshes; ++i)
    {
      const aiMesh* nodeMesh = mScene->getAiScene()->mMeshes[node->mMeshes[i]];
      if (nodeMesh == mesh)
        return node;
    }
 
    for (unsigned int i = 0; i < node->mNumChildren; ++i)
    {
      aiNode* child = findMeshNode(node->mChildren[i], mesh);
      if (child != nullptr)
        return child;
    }
 
    return nullptr;
  }
 
  aiMatrix4x4 ALSkeleton::getNodeLocalTransformWithBindPose(aiNode* node)
  {
    // Get the bone associated with this node, if any
    const aiBone* bone = nullptr;
    const aiScene* scene = mScene->getAiScene();
 
    aiMatrix4x4 meshInverseTrans = aiMatrix4x4().Inverse();
 
    for (unsigned int i = 0; i < scene->mNumMeshes; ++i)
    {
      const aiMesh* mesh = scene->mMeshes[i];
      for (unsigned int j = 0; j < mesh->mNumBones; ++j)
      {
        const aiBone* b = mesh->mBones[j];
        if (strcmp(b->mName.C_Str(), node->mName.C_Str()) == 0)
        {
          aiNode* meshNode = findMeshNode(scene->mRootNode, mesh);
          if (meshNode != nullptr)
            meshInverseTrans = mScene->getFullTransform(meshNode).Inverse();
          bone = b;
          break;
        }
      }
      if (bone) break;
    }
 
    if (!bone)
    {
      // If the node has no associated bone, return its transformation matrix
      return mScene->getFullTransform(node);
    }
 
    // Compute the transformation matrix from bone space to mesh space
    aiMatrix4x4 boneToMesh = meshInverseTrans * mScene->getFullTransform(node) * bone->mOffsetMatrix;
 
    return boneToMesh * meshInverseTrans.Inverse();
  }
 
  aiMatrix4x4 ALSkeleton::getLocalUniformMatrix(int bid)
  {
    aiNode* node = mBones[bid].mNode;
    aiBone* bone = mBones[bid].mBone;
 
    aiNode* parent = (node->mParent && mScene->isBone(node->mParent)) ? node->mParent : mNode;
 
    aiMatrix4x4 bonemat = mScene->getFullTransform(node);
 
    if (parent == mScene->getAiScene()->mRootNode)
      return bonemat;
 
    aiMatrix4x4 parmat = mScene->getFullTransform(parent);
 
    //then return relative matrix in coordinate space of parent
    return parmat.Inverse() * bonemat;    
 
    /*
    aiMatrix4x4 bonemat = getNodeLocalTransformWithBindPose(node);
    if (parent == mScene->getAiScene()->mRootNode)
      return bonemat;
    
    aiMatrix4x4 parmat = getNodeLocalTransformWithBindPose(parent);
 
    //then return relative matrix in coordinate space of parent
    return parmat.Inverse() * bonemat;
    */
  }
 
  ALSkeleton::ALSkeleton()
  {
    mScene = 0;
    mNode = 0;
  }
 
  ALSkeleton::ALSkeleton(ALScene* alscene, Ogre::SkeletonPtr skeleton, aiNode* attach)
  {
    mScene = alscene;
    mSkeleton = skeleton;
    mNode = attach;
  }
 
  ALSkeleton::~ALSkeleton()
  {
  }
 
  aiNode* ALSkeleton::getRootNode()
  {
    aiNode* newBone = 0;
    aiNode* curBone = mBones[0].mNode;
    while(mScene->isBone(curBone))
    {
      newBone = curBone;
      curBone = curBone->mParent;
    }
 
    return newBone;
  }
  
  aiBone* ALSkeleton::getBoneFromNode(aiNode* node)
  {
    //search the bone in all submeshes
    aiBone* bone = 0;
    for (unsigned int i = 0; i < mNode->mNumMeshes && !bone; ++i)
    {
      aiMesh* mesh = mScene->getAiScene()->mMeshes[mNode->mMeshes[i]];
      for (unsigned int j = 0; j < mesh->mNumBones && !bone; ++j)
      {
        if (mesh->mBones[j]->mName == node->mName)
          bone = mesh->mBones[j];
      }
    }
 
    return bone;
  }
 
  ALBone ALSkeleton::getBoneNodeByName(const std::string name)
  {
    for(unsigned int i = 0; i < mBones.size(); ++i)
    {
      if (std::string(mBones[i].mNode->mName.C_Str()) == name)
      {
        return mBones[i];
      }
    }
 
    return ALBone(0, 0);
  }
 
  int ALSkeleton::getBoneIndexByName(const std::string name)
  {
    for (unsigned int i = 0; i < mBones.size(); ++i)
    {
      if (std::string(mBones[i].mNode->mName.C_Str()) == name)
      {
        return i;
      }
    }
 
    return -1;
  }
 
  void ALSkeleton::addBone(aiNode* node, aiBone* bone, Ogre::SubMesh* submesh)
  {
    std::string name = node->mName.C_Str();
    if(node)
    {
      Ogre::Bone* ogreBone = 0;
      if(mSkeleton->hasBone(name))
      {
        ogreBone = mSkeleton->getBone(name);
      }
      else
      {
        ogreBone = mSkeleton->createBone(name);
        mBones.push_back(ALBone(node, bone));
      }
    }
 
    if (bone)
    {
      int bid = getBoneIndexByName(name);
      if (bid >= 0)
        mBones[bid].mBone = bone;
 
      //can fail with bad characters in names
      if(mSkeleton->hasBone(name))
      {
        Ogre::Bone* ogreBone = mSkeleton->getBone(name);
 
        for(unsigned int n=0; n<bone->mNumWeights; ++n)
        {
          Ogre::VertexBoneAssignment vba;
          aiVertexWeight aiWeight = bone->mWeights[n];
 
          vba.boneIndex = ogreBone->getHandle();
          vba.vertexIndex = aiWeight.mVertexId;
          vba.weight = aiWeight.mWeight;
          submesh->addBoneAssignment(vba);
        }
      }
    }
  }
 
  void ALSkeleton::makeHierarchy(aiMatrix4x4 meshInverseTrans)
  {
    for(unsigned int n=0; n<mBones.size(); ++n)
    {
      aiNode* node = mBones[n].mNode;
      aiBone* bone = mBones[n].mBone;
      std::string boneName = node->mName.C_Str();
 
      // set bone matrix
      Ogre::Bone* ogreBone = 0;
      if (mSkeleton->hasBone(boneName))
        ogreBone = mSkeleton->getBone(boneName);
 
      if (ogreBone)
      {
        //todo getLocalUniformMatrix and apply bindoffset of bone and parent bone 
        aiMatrix4x4 bindTrans(getLocalUniformMatrix(n));
        //if (bone != NULL)
        //{
        //  aiMatrix4x4 localbone = bone->mOffsetMatrix;
        //  bindTrans = localbone;
        //}
 
        mBones[n].mBindMatrix = bindTrans;
 
        //set bind pos
        aiVector3D scale;
        aiVector3D pos;
        aiQuaternion rotation;
        
        bindTrans.Decompose(scale, rotation, pos);
        Ogre::Bone* ogreBone = mSkeleton->getBone(boneName);
        ogreBone->setPosition(pos.x, pos.y, pos.z);
        ogreBone->setScale(scale.x, scale.y, scale.z);
        ogreBone->setOrientation(rotation.w, rotation.x, rotation.y, rotation.z);
        ogreBone->setBindingPose();
        ogreBone->setInitialState();
 
        //mBones[n].mBindMatrix.Inverse();
 
        for(unsigned int i=0; i<node->mNumChildren; ++i)
        {
          aiNode* child = node->mChildren[i];
          std::string childName = child->mName.C_Str();
          if(mScene->isBone(child))
          {
            if(mSkeleton->hasBone(childName))
            {
              try
              {
                ogreBone->addChild(mSkeleton->getBone(childName));
              }
              catch (Ogre::Exception &)
              {
                // Child already present for redundant bones.
                // Ignore.
              }
            }
          }
        }
      }
    }
    //force skeleton update
    mSkeleton->getRootBones();
  }
 
  std::vector<aiAnimation*> ALSkeleton::findConcernedAnimation()
  {
    aiAnimation** allAnims = mScene->getAiScene()->mAnimations;
    std::vector<aiAnimation*> concernedAnims;
    
    for(unsigned int n=0; n<mScene->getAiScene()->mNumAnimations; ++n)
    {
      aiNodeAnim** allNodeAnims = allAnims[n]->mChannels;
      for(unsigned int i=0; i<allAnims[n]->mNumChannels; ++i)
      {
        // only one needed
        if (getBoneNodeByName(allNodeAnims[i]->mNodeName.C_Str()).mNode)
        {
          concernedAnims.push_back(allAnims[n]);
          break;
        }
      }
    }
 
    return concernedAnims;
  }
 
  template<typename T> T ALSkeleton::getBiggerValue(T* data, unsigned int size)
  {
    T res = data[0];
    for(unsigned int n=1; n<size; ++n)
    {
      if(data[n]>res)
        res = data[n];
    }
    return res;
  }
 
  void ALSkeleton::processAnimation()
  {
    std::vector<aiAnimation*> anims = findConcernedAnimation();
    for(unsigned int n=0; n<anims.size(); ++n)
    {
      generateAnimation(anims[n]);
    }
  }
 
  void ALSkeleton::generateAnimation(aiAnimation* anim)
  {
    std::string animName(anim->mName.C_Str());
    animName = ALStringCleaner::cleanString(animName);
 
    Ogre::Animation* ogreAnim = mSkeleton->createAnimation(animName, static_cast<float>(anim->mDuration/anim->mTicksPerSecond));
    ogreAnim->setLength((float)(anim->mDuration/anim->mTicksPerSecond));
 
    aiMatrix4x4 meshTrans = mScene->getFullTransform(mNode);
    aiMatrix4x4 meshInverseTrans = meshTrans;
    meshInverseTrans.Inverse();
 
    aiNodeAnim** boneAnim = anim->mChannels;
    for(unsigned int i=0; i<anim->mNumChannels; ++i)
    {
      if(mSkeleton->hasBone(boneAnim[i]->mNodeName.C_Str()))
      {
        ALBone bone = getBoneNodeByName(boneAnim[i]->mNodeName.C_Str());
        aiNode* currentBone = bone.mNode;
        Ogre::Bone* ogbone = mSkeleton->getBone(boneAnim[i]->mNodeName.C_Str());
 
        aiVectorKey* posKey = boneAnim[i]->mPositionKeys;
        aiQuatKey* rotKey = boneAnim[i]->mRotationKeys;
        aiVectorKey* scaleKey = boneAnim[i]->mScalingKeys;
        unsigned int nbKey[3] = {boneAnim[i]->mNumPositionKeys, boneAnim[i]->mNumRotationKeys, boneAnim[i]->mNumScalingKeys};
        unsigned int keySize = getBiggerValue(nbKey, 3);
 
        std::set<float> times;
        for(unsigned int n=0; n<keySize; ++n)
        {
          if(boneAnim[i]->mNumPositionKeys > n)
          {
            times.insert(static_cast<float>(posKey[n].mTime));
          }
 
          if(boneAnim[i]->mNumScalingKeys > n)
          {
            times.insert(static_cast<float>(scaleKey[n].mTime));
          }
 
          if(boneAnim[i]->mNumRotationKeys > n)
          {
            times.insert(static_cast<float>(rotKey[n].mTime));
          }
        }
 
        std::vector<ALKeyFrame> keyframes;
        for(std::set<float>::iterator it=times.begin(); it!=times.end(); ++it)
        {
          ALKeyFrame key(*it);
 
          for(unsigned int n=0; n<keySize; ++n)
          {
            if(boneAnim[i]->mNumPositionKeys > n)
            {
              if(posKey[n].mTime == *it)
              {
                key.setPosition(posKey[n]);
              }
            }
 
            if(boneAnim[i]->mNumScalingKeys > n)
            {
              if(scaleKey[n].mTime == *it)
              {
                key.setScale(scaleKey[n]);
              }
            }
 
            if(boneAnim[i]->mNumRotationKeys > n)
            {
              if(rotKey[n].mTime == *it)
              {
                key.setRotation(rotKey[n]);
              }
            }
          }
 
          keyframes.push_back(key);
        }
 
        Ogre::NodeAnimationTrack* nAnimTrk = ogreAnim->createNodeTrack(ogbone->getHandle(), ogbone);
        for(unsigned int n=0; n<keyframes.size(); ++n)
        {
          if (currentBone != 0)
          {
            keyframes[n].createInterpolation(keyframes, currentBone);
 
            aiVector3D kpos = keyframes[n].getPosition().mValue;
            aiQuaternion krotation = keyframes[n].getRotation().mValue;
            aiVector3D kscale = keyframes[n].getScale().mValue;
 
            aiVector3D bpos;
            aiQuaternion brotation;
            aiVector3D bscale;
 
            aiMatrix4x4 boneMat(kscale, krotation, kpos);
 
            bone.mBindMatrix.Decompose(bscale, brotation, bpos);
            if (currentBone->mParent && !mScene->isBone(currentBone->mParent)) // root bone
            {
              boneMat = mScene->getFullTransform(currentBone->mParent) * boneMat;
              boneMat = meshInverseTrans * boneMat;
              boneMat.Decompose(kscale, krotation, kpos);
            }
            
            kpos -= bpos;
            krotation = aiQuaternion(brotation.GetMatrix().Inverse() * krotation.GetMatrix());
            Ogre::TransformKeyFrame* key = nAnimTrk->createNodeKeyFrame((float)(keyframes[n].getTime() / anim->mTicksPerSecond));
            key->setTranslate(Ogre::Vector3(kpos.x, kpos.y, kpos.z));
            key->setRotation(Ogre::Quaternion(krotation.w, krotation.x, krotation.y, krotation.z));
            key->setScale(Ogre::Vector3(kscale.x, kscale.y, kscale.z));
          }
        }
      }
    }
 
    mSkeleton->optimiseAllAnimations();
  }
}