ALConverterNodeAnim.cpp

Go to the documentation of this file.

 
#include <boost/format.hpp>
#include "SO3SceneLoader/ALConverterNodeAnim.h"
#include "SO3SceneLoader/ALStringCleaner.h"
#include "SO3SceneLoader/ALKeyFrame.h"
#include "SO3SceneLoader/ALScene.h"
 
#include "SO3Animation/SO3NodeAnimation.h"
#include "SO3Animation/SO3NodeAnimationTrack.h"
 
#include <set>
#include <numeric>
 
namespace SO3
{
  ALConverterNodeAnim::ALConverterNodeAnim(ALScene* scene, aiAnimation* animation, aiNodeAnim* nodeAnim, aiNode* node, double tickPerSec)
  {
    mAnim = animation;
    mNodeAnim = nodeAnim;
    mNode = node;
    mScene = scene;
    mTickPerSec = tickPerSec;
  }
 
  ALConverterNodeAnim::~ALConverterNodeAnim() 
  {
 
  }
 
  bool ALConverterNodeAnim::isAffected(aiString nodeName)
  {
    return (mNode->mName == nodeName);
  }
 
  double ALConverterNodeAnim::getTime()
  {
    return mAnim->mDuration/mTickPerSec;
  }
 
  unsigned int ALConverterNodeAnim::getBiggest(unsigned int* data, unsigned int size)
  {
    unsigned int res = data[0];
    for(unsigned int n=1; n<size; ++n)
    {
      if(data[n]>res)
        res = data[n];
    }
    return res;
  }
 
  template<typename T> T ALConverterNodeAnim::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 ALConverterNodeAnim::convert(tinyxml2::XMLElement* xmlAnimations, bool first)
  {
    tinyxml2::XMLDocument* doc = xmlAnimations->GetDocument();
    tinyxml2::XMLElement* animations = doc->NewElement("animations");
    tinyxml2::XMLElement* anim = doc->NewElement("animation");
 
    std::string animName(mNodeAnim->mNodeName.C_Str());
    animName += "Anim";
 
    anim->SetAttribute("name", ALStringCleaner::cleanString(animName).c_str());
    anim->SetAttribute("enable", first ? "true" : "false");
    anim->SetAttribute("loop", first ? "true" : "false");
    anim->SetAttribute("interpolationMode", "linear");
    anim->SetAttribute("rotationInterpolationMode", "linear");
    anim->SetAttribute("length", ConversionTools::formatFloatToString(getTime()).c_str());
 
    aiVectorKey* posKey = mNodeAnim->mPositionKeys;
    aiQuatKey* rotKey = mNodeAnim->mRotationKeys;
    aiVectorKey* scaleKey = mNodeAnim->mScalingKeys;
    unsigned int nbKey[3] = {mNodeAnim->mNumPositionKeys, mNodeAnim->mNumRotationKeys, mNodeAnim->mNumScalingKeys};
    unsigned int keySize = getBiggerValue(nbKey, 3);
 
    std::set<float> times;
    for(unsigned int n=0; n<keySize; ++n)
    {
      if(mNodeAnim->mNumPositionKeys > n)
      {
        times.insert(static_cast<float>(posKey[n].mTime));
      }
 
      if(mNodeAnim->mNumScalingKeys > n)
      {
        times.insert(static_cast<float>(scaleKey[n].mTime));
      }
 
      if(mNodeAnim->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(mNodeAnim->mNumPositionKeys > n)
        {
          if(posKey[n].mTime == *it)
          {
            key.setPosition(posKey[n]);
          }
        }
 
        if(mNodeAnim->mNumScalingKeys > n)
        {
          if(scaleKey[n].mTime == *it)
          {
            key.setScale(scaleKey[n]);
          }
        }
 
        if(mNodeAnim->mNumRotationKeys > n)
        {
          if(rotKey[n].mTime == *it)
          {
            key.setRotation(rotKey[n]);
          }
        }
      }
      keyframes.push_back(key);
    }
 
    for(unsigned int n=0; n<keyframes.size(); ++n)
    {
      keyframes[n].createInterpolation(keyframes, mNode);
 
      aiVector3D keypos = keyframes[n].getPosition().mValue;
      aiVector3D keyscale = keyframes[n].getScale().mValue;
      aiQuaternion keyquat = keyframes[n].getRotation().mValue;
 
      tinyxml2::XMLElement* XMLkeyframe = doc->NewElement("keyframe");
      XMLkeyframe->SetAttribute("time", ConversionTools::formatFloatToString(keyframes[n].getTime()/mTickPerSec).c_str());
 
      tinyxml2::XMLElement* translation = doc->NewElement("translation");
      translation->SetAttribute("x", ConversionTools::formatFloatToString(keypos.x).c_str());
      translation->SetAttribute("y", ConversionTools::formatFloatToString(keypos.y).c_str());
      translation->SetAttribute("z", ConversionTools::formatFloatToString(keypos.z).c_str());
      XMLkeyframe->InsertEndChild(translation);
 
      tinyxml2::XMLElement* scaling = doc->NewElement("scale");
      scaling->SetAttribute("x", ConversionTools::formatFloatToString(keyscale.x).c_str());
      scaling->SetAttribute("y", ConversionTools::formatFloatToString(keyscale.y).c_str());
      scaling->SetAttribute("z", ConversionTools::formatFloatToString(keyscale.z).c_str());
      XMLkeyframe->InsertEndChild(scaling);
 
      tinyxml2::XMLElement* rot = doc->NewElement("rotation");
      rot->SetAttribute("qx", ConversionTools::formatFloatToString(keyquat.x).c_str());
      rot->SetAttribute("qy", ConversionTools::formatFloatToString(keyquat.y).c_str());
      rot->SetAttribute("qz", ConversionTools::formatFloatToString(keyquat.z).c_str());
      rot->SetAttribute("qw", ConversionTools::formatFloatToString(keyquat.w).c_str());
      XMLkeyframe->InsertEndChild(rot);
 
      anim->InsertEndChild(XMLkeyframe);
    }
 
    animations->InsertEndChild(anim);
    xmlAnimations->InsertEndChild(animations);
  }
 
  void ALConverterNodeAnim::load(SNode* ogNode)
  {
    std::string animName(mNodeAnim->mNodeName.C_Str());
    animName += "Anim";
    SNodeAnimation* animation = ogNode->CreateNodeAnimation(ALStringCleaner::cleanString(animName), static_cast<float>(ConversionTools::formatFloat(getTime())));
    SAnimTrack* animationTrack = animation->CreateAnimationTrack(boost::str(boost::format("%1%") %animation->GetNumAnimationsTracks()));
 
    aiVectorKey* posKey = mNodeAnim->mPositionKeys;
    aiQuatKey* rotKey = mNodeAnim->mRotationKeys;
    aiVectorKey* scaleKey = mNodeAnim->mScalingKeys;
    unsigned int nbKey[3] = {mNodeAnim->mNumPositionKeys, mNodeAnim->mNumRotationKeys, mNodeAnim->mNumScalingKeys};
    unsigned int keySize = getBiggerValue(nbKey, 3);
 
    std::set<float> times;
    for(unsigned int n=0; n<keySize; ++n)
    {
      if(mNodeAnim->mNumPositionKeys > n)
      {
        times.insert(static_cast<float>(posKey[n].mTime));
      }
 
      if(mNodeAnim->mNumScalingKeys > n)
      {
        times.insert(static_cast<float>(scaleKey[n].mTime));
      }
 
      if(mNodeAnim->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(mNodeAnim->mNumPositionKeys > n)
        {
          if(posKey[n].mTime == *it)
          {
            key.setPosition(posKey[n]);
          }
        }
 
        if(mNodeAnim->mNumScalingKeys > n)
        {
          if(scaleKey[n].mTime == *it)
          {
            key.setScale(scaleKey[n]);
          }
        }
 
        if(mNodeAnim->mNumRotationKeys > n)
        {
          if(rotKey[n].mTime == *it)
          {
            key.setRotation(rotKey[n]);
          }
        }
      }
      keyframes.push_back(key);
    }
 
    for(unsigned int n=0; n<keyframes.size(); ++n)
    {
      keyframes[n].createInterpolation(keyframes, mNode);
 
      aiVector3D keypos = keyframes[n].getPosition().mValue;
      aiVector3D keyscale = keyframes[n].getScale().mValue;
      aiQuaternion keyquat = keyframes[n].getRotation().mValue;
 
      animationTrack->CreateKey(static_cast<float>(ConversionTools::formatFloat(keyframes[n].getTime()/mTickPerSec)), Ogre::Vector3(keypos.x, keypos.y, keypos.z), Ogre::Quaternion(keyquat.w, keyquat.x, keyquat.y, keyquat.z), Ogre::Vector3(keyscale.x, keyscale.y, keyscale.z));
    }
  }
}