AnimationChannel* createAnimationChannel(FbxNode* fbxNode, unsigned int targetAttrib, const vector<float>& keyTimes, const vector<float>& keyValues)
{
AnimationChannel* channel = new AnimationChannel();
channel->setTargetId(fbxNode->GetName());
channel->setKeyTimes(keyTimes);
channel->setKeyValues(keyValues);
channel->setInterpolation(AnimationChannel::LINEAR);
channel->setTargetAttribute(targetAttrib);
return channel;
}
void FBXSceneEncoder::loadAnimationChannels(FbxAnimLayer* animLayer, FbxNode* fbxNode, Animation* animation)
{
const char* name = fbxNode->GetName();
//Node* node = _gamePlayFile.getNode(name);
// Determine which properties are animated on this node
// Find the transform at each key frame
// TODO: Ignore properties that are not animated (scale, rotation, translation)
// This should result in only one animation channel per animated node.
float startTime = FLT_MAX, stopTime = -1.0f, frameRate = -FLT_MAX;
bool tx = false, ty = false, tz = false, rx = false, ry = false, rz = false, sx = false, sy = false, sz = false;
FbxAnimCurve* animCurve = NULL;
animCurve = getCurve(fbxNode->LclTranslation, animLayer, FBXSDK_CURVENODE_COMPONENT_X);
if (animCurve)
{
tx = true;
findMinMaxTime(animCurve, &startTime, &stopTime, &frameRate);
}
animCurve = getCurve(fbxNode->LclTranslation, animLayer, FBXSDK_CURVENODE_COMPONENT_Y);
if (animCurve)
{
ty = true;
findMinMaxTime(animCurve, &startTime, &stopTime, &frameRate);
}
animCurve = getCurve(fbxNode->LclTranslation, animLayer, FBXSDK_CURVENODE_COMPONENT_Z);
if (animCurve)
{
tz = true;
findMinMaxTime(animCurve, &startTime, &stopTime, &frameRate);
}
animCurve = getCurve(fbxNode->LclRotation, animLayer, FBXSDK_CURVENODE_COMPONENT_X);
if (animCurve)
{
rx = true;
findMinMaxTime(animCurve, &startTime, &stopTime, &frameRate);
}
animCurve = getCurve(fbxNode->LclRotation, animLayer, FBXSDK_CURVENODE_COMPONENT_Y);
if (animCurve)
{
ry = true;
findMinMaxTime(animCurve, &startTime, &stopTime, &frameRate);
}
animCurve = getCurve(fbxNode->LclRotation, animLayer, FBXSDK_CURVENODE_COMPONENT_Z);
if (animCurve)
{
rz = true;
findMinMaxTime(animCurve, &startTime, &stopTime, &frameRate);
}
animCurve = getCurve(fbxNode->LclScaling, animLayer, FBXSDK_CURVENODE_COMPONENT_X);
if (animCurve)
{
sx = true;
findMinMaxTime(animCurve, &startTime, &stopTime, &frameRate);
}
animCurve = getCurve(fbxNode->LclScaling, animLayer, FBXSDK_CURVENODE_COMPONENT_Y);
if (animCurve)
{
sy = true;
findMinMaxTime(animCurve, &startTime, &stopTime, &frameRate);
}
animCurve = getCurve(fbxNode->LclScaling, animLayer, FBXSDK_CURVENODE_COMPONENT_Z);
if (animCurve)
{
sz = true;
findMinMaxTime(animCurve, &startTime, &stopTime, &frameRate);
}
if (!(sx || sy || sz || rx || ry || rz || tx || ty || tz))
return; // no animation channels
assert(startTime != FLT_MAX);
assert(stopTime >= 0.0f);
// Determine which animation channels to create
vector<unsigned int> channelAttribs;
if (sx && sy && sz)
{
if (rx || ry || rz)
{
if (tx && ty && tz)
{
channelAttribs.push_back(Transform::ANIMATE_SCALE_ROTATE_TRANSLATE);
}
else
{
channelAttribs.push_back(Transform::ANIMATE_SCALE_ROTATE);
if (tx)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_X);
if (ty)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_Y);
if (tz)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_Z);
}
}
else
{
if (tx && ty && tz)
{
channelAttribs.push_back(Transform::ANIMATE_SCALE_TRANSLATE);
}
else
{
channelAttribs.push_back(Transform::ANIMATE_SCALE);
if (tx)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_X);
if (ty)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_Y);
if (tz)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_Z);
}
}
}
else
{
if (rx || ry || rz)
{
if (tx && ty && tz)
{
channelAttribs.push_back(Transform::ANIMATE_ROTATE_TRANSLATE);
}
else
{
channelAttribs.push_back(Transform::ANIMATE_ROTATE);
if (tx)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_X);
if (ty)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_Y);
if (tz)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_Z);
}
}
else
{
if (tx && ty && tz)
{
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE);
}
else
{
if (tx)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_X);
if (ty)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_Y);
if (tz)
channelAttribs.push_back(Transform::ANIMATE_TRANSLATE_Z);
}
}
if (sx)
channelAttribs.push_back(Transform::ANIMATE_SCALE_X);
if (sy)
channelAttribs.push_back(Transform::ANIMATE_SCALE_Y);
if (sz)
channelAttribs.push_back(Transform::ANIMATE_SCALE_Z);
}
unsigned int channelCount = channelAttribs.size();
assert(channelCount > 0);
// Allocate channel list
const int channelStart = animation->getAnimationChannelCount();
for (unsigned int i = 0; i < channelCount; ++i)
{
AnimationChannel* channel = new AnimationChannel();
channel->setTargetId(name);
channel->setInterpolation(AnimationChannel::LINEAR);
channel->setTargetAttribute(channelAttribs[i]);
animation->add(channel);
}
// Evaulate animation curve in increments of frameRate and populate channel data.
FbxAMatrix fbxMatrix;
Matrix matrix;
double increment = 1000.0 / (double)frameRate;
int frameCount = (int)ceil((double)(stopTime - startTime) / increment) + 1; // +1 because stop time is inclusive
// If the animation for this node only has only 1 key frame and it is equal to the node's transform then ignore it.
// This is a work around for a bug in the Blender FBX exporter.
if (frameCount == 1 && fbxMatrix == fbxNode->EvaluateLocalTransform(0))
{
return;
}
for (int frame = 0; frame < frameCount; ++frame)
{
double time = startTime + (frame * (double)increment);
// Note: We used to clamp time to stop time, but FBX sdk does not always produce
// and accurate stopTime (sometimes it is rounded down for some reason), so I'm
// disabling this clamping for now as it seems more accurate under normal circumstances.
//time = std::min(time, (double)stopTime);
// Evalulate the animation at this time
FbxTime kTime;
kTime.SetMilliSeconds((FbxLongLong)time);
fbxMatrix = fbxNode->EvaluateLocalTransform(kTime);
copyMatrix(fbxMatrix, matrix);
// Decompose the evalulated transformation matrix into separate
// scale, rotation and translation.
Vector3 scale;
Quaternion rotation;
Vector3 translation;
matrix.decompose(&scale, &rotation, &translation);
rotation.normalize();
// Append keyframe data to all channels
for (unsigned int i = channelStart, channelEnd = channelStart + channelCount; i < channelEnd; ++i)
{
appendKeyFrame(fbxNode, animation->getAnimationChannel(i), (float)time, scale, rotation, translation);
}
}
if (_groupAnimation != animation)
{
_gamePlayFile.addAnimation(animation);
}
}