private static uint FindPosition(float animationTime, AiNodeAnimationChannel nodeAnim)
{
for (uint i = 0; i < nodeAnim.PositionKeyCount - 1; i++)
{
if (animationTime < (float)nodeAnim.PositionKeys[i + 1].Time)
{
return(i);
}
}
return(0);
}
private static AiNodeAnimationChannel FineNodeAnim(AiAnimation animation, string nodeName)
{
AiNodeAnimationChannel channel = null;
for (int i = 0; i < animation.NodeAnimationChannelCount; i++)
{
var nodeAnim = animation.NodeAnimationChannels[i];
if (nodeAnim.NodeName == nodeName)
{
channel = nodeAnim;
break;
}
}
return(channel);
}
private static uint FindScaling(float animationTime, AiNodeAnimationChannel nodeAnim)
{
//assert(pNodeAnim->mNumScalingKeys > 0);
for (uint i = 0; i < nodeAnim.ScalingKeyCount - 1; i++)
{
if (animationTime < (float)nodeAnim.ScalingKeys[i + 1].Time)
{
return(i);
}
}
//assert(0);
return(0);
}
private static void ReadNodeHeirarchy(float animationTime, AiNode node, AiAnimation animation, mat4 parentTransform, AllBoneInfos allBoneInfos)
{
string nodeName = node.Name;
mat4 nodeTransform = node.Transform.ToMat4();
AiNodeAnimationChannel nodeAnim = FineNodeAnim(animation, nodeName);
if (nodeAnim != null)
{
mat4 mat = mat4.identity();
// Interpolate scaling and generate scaling transformation matrix
vec3 scaling = CalcInterpolatedScaling(animationTime, nodeAnim);
mat4 scalingMat = glm.scale(mat, new vec3(scaling.X, scaling.Y, scaling.Z));
// Interpolate rotation and generate rotation transformation matrix
Quaternion rotation = CalcInterpolatedRotation(animationTime, nodeAnim);
mat4 rotationMat = new AiMatrix4x4(rotation.GetMatrix()).ToMat4();
// Interpolate translation and generate translation transformation matrix
vec3 translation = CalcInterpolatedPosition(animationTime, nodeAnim);
mat4 translationMat = glm.translate(mat4.identity(), new vec3(translation.X, translation.Y, translation.Z));
// Combine the above transformations
nodeTransform = translationMat * rotationMat * scalingMat;
}
mat4 globalTransformation = parentTransform * nodeTransform;
if (allBoneInfos.nameIndexDict.ContainsKey(nodeName))
{
uint BoneIndex = allBoneInfos.nameIndexDict[nodeName];
allBoneInfos.boneInfos[BoneIndex].finalTransformation = globalTransformation * allBoneInfos.boneInfos[BoneIndex].bone.OffsetMatrix.ToMat4();
}
for (int i = 0; i < node.ChildCount; i++)
{
ReadNodeHeirarchy(animationTime, node.Children[i], animation, globalTransformation, allBoneInfos);
}
}
private static vec3 CalcInterpolatedPosition(float animationTime, AiNodeAnimationChannel nodeAnim)
{
vec3 result;
if (nodeAnim.PositionKeyCount == 1)
{
result = nodeAnim.PositionKeys[0].Value;
return(result);
}
uint index = FindPosition(animationTime, nodeAnim);
uint nextIndex = (index + 1);
//assert(NextPositionIndex < nodeAnim->mNumPositionKeys);
float deltaTime = (float)(nodeAnim.PositionKeys[nextIndex].Time - nodeAnim.PositionKeys[index].Time);
float factor = (animationTime - (float)nodeAnim.PositionKeys[index].Time) / deltaTime;
//assert(Factor >= 0.0f && Factor <= 1.0f);
vec3 start = nodeAnim.PositionKeys[index].Value;
vec3 end = nodeAnim.PositionKeys[nextIndex].Value;
vec3 delta = end - start;
result = start + factor * delta;
return(result);
}
private static Quaternion CalcInterpolatedRotation(float animationTime, AiNodeAnimationChannel nodeAnim)
{
Quaternion result;
// we need at least two values to interpolate...
if (nodeAnim.RotationKeyCount == 1)
{
result = nodeAnim.RotationKeys[0].Value;
return(result);
}
uint index = FindRotation(animationTime, nodeAnim);
uint nextIndex = (index + 1);
//assert(NextRotationIndex < nodeAnim.RotationKeyCount);
float deltaTime = (float)(nodeAnim.RotationKeys[nextIndex].Time - nodeAnim.RotationKeys[index].Time);
float factor = (animationTime - (float)nodeAnim.RotationKeys[index].Time) / deltaTime;
//assert(Factor >= 0.0f && Factor <= 1.0f);
Quaternion start = nodeAnim.RotationKeys[index].Value;
Quaternion end = nodeAnim.RotationKeys[nextIndex].Value;
result = Interpolate(start, end, factor);
result.Normalize();
return(result);
}
