ALKeyFrame.cpp

Go to the documentation of this file.

#include "SO3SceneLoader/ALKeyFrame.h"
 
namespace SO3
{
 
ALKeyFrame::ALKeyFrame(double time)
{
  mTime = time;
  mHasPos = false;
  mHasRot = false;
  mHasScl = false;
}
 
ALKeyFrame::~ALKeyFrame()
{
}
 
bool ALKeyFrame::hasPosition()
{
  return mHasPos;
}
 
bool ALKeyFrame::hasScale()
{
  return mHasScl;
}
 
bool ALKeyFrame::hasRotation()
{
  return mHasRot;
}
 
double ALKeyFrame::getTime()
{
  return mTime;
}
 
void ALKeyFrame::setPosition(aiVectorKey positionkey)
{
  mPosition = positionkey;
  mHasPos = true;
}
 
void ALKeyFrame::setScale(aiVectorKey scaleKey)
{
  mScale = scaleKey;
  mHasScl = true;
}
 
void ALKeyFrame::setRotation(aiQuatKey rotationKey)
{
  mRotation = rotationKey;
  mHasRot = true;
}
 
aiVectorKey ALKeyFrame::getPosition()
{
  return mPosition;
}
 
aiVectorKey ALKeyFrame::getScale()
{
  return mScale;
}
 
aiQuatKey ALKeyFrame::getRotation()
{
  return mRotation;
}
 
template<typename T> T ALKeyFrame::linearInterpolate(T tm, T ta, T va, T tb, T vb)
{
  T a = (va-vb)/(ta-tb);
  T b = vb-a*tb;
  return a*tm+b;
}
 
void ALKeyFrame::createInterpolation(std::vector<ALKeyFrame> keyframes, aiNode* initNode)
{
  aiVector3D ipos;
  aiQuaternion irotation;
  aiVector3D iscale;
  initNode->mTransformation.Decompose(iscale, irotation, ipos);
 
  if(!mHasPos)
  {
    ALKeyFrame prevKey(0);
    bool pfound = false;
    for (unsigned int i = 0; i < keyframes.size(); ++i)
    {
      ALKeyFrame tkey = keyframes[i];
      if ((tkey.getTime() <= mTime) && tkey.hasPosition())
      {
        prevKey = tkey;
        pfound = true;
      }
      else if (tkey.getTime() > mTime)
        break;
    }
 
    ALKeyFrame nextKey(0);
    bool nfound = false;
    for (unsigned int i = (keyframes.size() - 1); i >= 0; --i)
    {
      ALKeyFrame tkey = keyframes[i];
      if ((tkey.getTime() > mTime) && tkey.hasPosition())
      {
        nextKey = tkey;
        nfound = true;
      }
      else if (tkey.getTime() <= mTime)
        break;
    }
 
    if (!pfound)
    {
      prevKey.setPosition(aiVectorKey(0, ipos));
 
      pfound = true;
    }
 
    if (pfound && !nfound)
    {
      mPosition = prevKey.getPosition();
    }
    else if (pfound && nfound)
    {
      mPosition.mValue.x = static_cast<float>(linearInterpolate<double>(mTime, prevKey.getTime(), prevKey.getPosition().mValue.x, 
                                                            nextKey.getTime(), nextKey.getPosition().mValue.x));
 
      mPosition.mValue.y = static_cast<float>(linearInterpolate<double>(mTime, prevKey.getTime(), prevKey.getPosition().mValue.y, 
                                                            nextKey.getTime(), nextKey.getPosition().mValue.y));
 
      mPosition.mValue.z = static_cast<float>(linearInterpolate<double>(mTime, prevKey.getTime(), prevKey.getPosition().mValue.z, 
                                                            nextKey.getTime(), nextKey.getPosition().mValue.z));
    }
  }
   
 
  if(!mHasScl)
  {
    ALKeyFrame prevKey(0);
    bool pfound = false;
    for (unsigned int i = 0; i < keyframes.size(); ++i)
    {
      ALKeyFrame tkey = keyframes[i];
      if ((tkey.getTime() <= mTime) && tkey.hasScale())
      {
        prevKey = tkey;
        pfound = true;
      }
      else if (tkey.getTime() > mTime)
        break;
    }
 
    ALKeyFrame nextKey(0);
    bool nfound = false;
    for (unsigned int i = (keyframes.size() - 1); i >= 0; --i)
    {
      ALKeyFrame tkey = keyframes[i];
      if ((tkey.getTime() > mTime) && tkey.hasScale())
      {
        nextKey = tkey;
        nfound = true;
      }
      else if (tkey.getTime() <= mTime)
        break;
    }
 
    if (!pfound)
    {
      prevKey.setScale(aiVectorKey(0, iscale));
 
      pfound = true;
    }
 
    if (pfound && !nfound)
    {
      mScale = prevKey.getScale();
    }
    else if (pfound && nfound)
    {
      mScale.mValue.x = static_cast<float>(linearInterpolate<double>(mTime, prevKey.getTime(), prevKey.getScale().mValue.x, 
                                                            nextKey.getTime(), nextKey.getScale().mValue.x));
 
      mScale.mValue.y = static_cast<float>(linearInterpolate<double>(mTime, prevKey.getTime(), prevKey.getScale().mValue.y, 
                                                            nextKey.getTime(), nextKey.getScale().mValue.y));
 
      mScale.mValue.z = static_cast<float>(linearInterpolate<double>(mTime, prevKey.getTime(), prevKey.getScale().mValue.z, 
                                                            nextKey.getTime(), nextKey.getScale().mValue.z));
    }
  }
 
  if(!mHasRot)
  {
    ALKeyFrame prevKey(0);
    bool pfound = false;
    for (unsigned int i = 0; i < keyframes.size(); ++i)
    {
      ALKeyFrame tkey = keyframes[i];
      if ((tkey.getTime() <= mTime) && tkey.hasRotation())
      {
        prevKey = tkey;
        pfound = true;
      }
      else if (tkey.getTime() > mTime)
        break;
    }
 
    ALKeyFrame nextKey(0);
    bool nfound = false;
    for (unsigned int i = (keyframes.size() - 1); i >= 0; --i)
    {
      ALKeyFrame tkey = keyframes[i];
      if ((tkey.getTime() > mTime) && tkey.hasRotation())
      {
        nextKey = tkey;
        nfound = true;
      }
      else if (tkey.getTime() <= mTime)
        break;
    }
 
    if (!pfound)
    {
      prevKey.setRotation(aiQuatKey(0, irotation));
 
      pfound = true;
    }
 
    if (pfound && !nfound)
    {
      mRotation = prevKey.getRotation();
    }
    else if (pfound && nfound)
    {
      mRotation.mValue.Interpolate(mRotation.mValue, prevKey.getRotation().mValue, nextKey.getRotation().mValue, static_cast<float>(fabs((prevKey.getTime() - nextKey.getTime()) / mTime)));
    }
  }
}
 
}