9.2 动画与轨迹
上一节有了骨树,这一节给它填「动作」:一段走路动画就是在时间轴上摆好若干关键姿势,再在它们之间插值。OGRE 用三级结构装这段数据——Animation(一段动画的总长 + 一组轨迹)、AnimationTrack(一根骨头的时间线)、KeyFrame(时间轴上的姿势快照)。这一节把三级结构、关键帧存取与「前后两帧 + 参数 t」的插值接口讲透。
本章与站内既有内容的分工
helio 四卷的动画是逐帧硬切;cg 三卷讲了插值曲线的数学。这里解析真实 OGRE 的 Animation/AnimationTrack/TransformKeyFrame:轨道怎么按 handle 索引、getKeyFramesAtTime 为什么一次给两帧加一个 t、TransformKeyFrame 存哪三个分量。9.3 的 AnimationState 负责「现在播到哪」,而本节只负责「数据怎么组织」。
Animation:一段动画的容器
Animation 的核心数据是「长度 + 三类轨道」。长度决定播放时间轴;轨道按目标类型分 NodeAnimationTrack(动节点/骨头)、VertexAnimationTrack(顶点动画,10 章)、NumericAnimationTrack(数值参数):
// OgreMain/include/OgreAnimation.h:Animation 类(v14.6.3 源码摘录,已删减)
class _OgreExport Animation : public AnimationAlloc
{
构造函数直接给长度,访问器见下:
// OgreMain/include/OgreAnimation.h:Animation::getLength/createNodeTrack(v14.6.3 源码摘录,已删减)
/** Gets the total length of the animation. */
Real getLength(void) const;
/** Creates a NodeAnimationTrack for animating a Node.
@param handle Handle to give the track, used for accessing the track later.
Must be unique within this Animation.
*/
NodeAnimationTrack* createNodeTrack(unsigned short handle);
私有成员把节点轨道按 handle 索引存放:
// OgreMain/include/OgreAnimation.h:Animation 私有成员(v14.6.3 源码摘录,已删减)
/// Node tracks, indexed by handle
NodeTrackList mNodeTrackList;
/// Numeric tracks, indexed by handle
NumericTrackList mNumericTrackList;
/// Vertex tracks, indexed by handle
VertexTrackList mVertexTrackList;
String mName;
Real mLength;
Animation 本身不关心节点是谁——轨道只按 handle 记着「动哪个骨头」。把 handle 换成具体 Node* 的工作由上层(骨架/实体)完成。这为多套骨骼共享同一段动画数据留了空间。
AnimationTrack:一根骨头的时间线
AnimationTrack 是二级结构:一串按时间排序的关键帧 + 一个 handle。三个核心访问器覆盖「查数量 / 按下标取 / 按时间取」:
// OgreMain/include/OgreAnimationTrack.h:AnimationTrack(v14.6.3 源码摘录,已删减)
/** Returns the number of keyframes in this animation. */
size_t getNumKeyFrames(void) const { return mKeyFrames.size(); }
/** Returns the KeyFrame at the specified index. */
KeyFrame* getKeyFrame(size_t index) const { return mKeyFrames.at(index); }
/** Gets the 2 KeyFrame objects which are active at the time given, and the blend value between them.
At any point in time in an animation, there are either 1 or 2 keyframes which are 'active',
1 if the time index is exactly on a keyframe, 2 at all other times i.e. the keyframe before
and the keyframe after.
...
@return Parametric value indicating how far along the gap between the 2 keyframes the timeIndex
value is, e.g. 0.0 for exactly at 1, 0.25 for a quarter etc. By definition the range of this
value is: 0.0 <= returnValue < 1.0 .
*/
float getKeyFramesAtTime(const TimeIndex& timeIndex, KeyFrame** keyFrame1, KeyFrame** keyFrame2,
unsigned short* firstKeyIndex = 0) const;
getKeyFramesAtTime 是插值的数据入口:给定一个时间点,它返回时间点前/后的两帧(落在关键帧上时两帧相同)和一个参数 t,t 表示时间点落在这两帧之间的比例,范围 0.0 <= t < 1.0。lab 复现了这套「二分找帧 + 算 t」的语义。
TransformKeyFrame:姿势快照
关键帧是 KeyFrame 的派生。节点动画用的是 TransformKeyFrame,它存下三个分量:平移、缩放、旋转:
// OgreMain/include/OgreKeyFrame.h:KeyFrame/TransformKeyFrame(v14.6.3 源码摘录,已删减)
class _OgreExport KeyFrame : public AnimationAlloc
{
public:
/** Gets the time of this keyframe in the animation sequence. */
Real getTime(void) const { return mTime; }
protected:
Real mTime;
const AnimationTrack* mParentTrack;
};
/** Specialised KeyFrame which stores a full transform. */
class _OgreExport TransformKeyFrame : public KeyFrame
{
public:
virtual void setTranslate(const Vector3& trans);
virtual void setScale(const Vector3& scale);
virtual void setRotation(const Quaternion& rot);
...
private:
Vector3 mTranslate;
Vector3 mScale;
Quaternion mRotate;
};
TransformKeyFrame 是绝对快照而非增量——它记录该骨头在某个时刻的完整目标姿势。插值就是把相邻两帧的快照按 t 混合:平移/缩放走线性 lerp,旋转走球面插值(OGRE 里由 RotationInterpolationMode 决定,默认最短路径)。一段 1 秒的走路动画可以只有 3-4 个关键帧,中间的运动全靠插值补出来。
源码定位
OgreMain/include/OgreAnimation.h:Animation(98)、getLength(134)、createNodeTrack(146)、getNumNodeTracks(184)、mNodeTrackList(512)、mLength(519)OgreMain/include/OgreAnimationTrack.h:AnimationTrack(123)、getNumKeyFrames(150)、getKeyFrame(153)、getKeyFramesAtTime(176)、createKeyFrame(184)OgreMain/include/OgreKeyFrame.h:KeyFrame(55)、getTime(65)、TransformKeyFrame(102)、mTranslate/mScale/mRotate(141-143)
上游引用固定到 OGRE v14.6.3 源码 。
可运行产物:C++ 最小验证
下面用纯 C++ 复现 Animation/Track/KeyFrame 的三级结构与插值接口。它与 src/09-2-animation-track.cpp 逐字节一致:
// file: src/09-2-animation-track.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/09-2-animation-track.cpp -o bin/09-2-animation-track && ./bin/09-2-animation-track
//
// 复现 Animation/Track/KeyFrame 的时序结构(对应 OgreAnimation.h 98/134/146、OgreAnimationTrack.h 123/150/176/184、OgreKeyFrame.h 55/65/102):
// Animation 是「时间 + 一组轨迹」;createNodeTrack 按 handle 建 NodeAnimationTrack;
// AnimationTrack 持有按时间排序的关键帧,getKeyFramesAtTime 返回前后两帧与参数 t;
// TransformKeyFrame 存 translate/scale/rotate,插值时按 t 线性合成。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"
#include <cstdint>
#include <vector>
namespace ogre_repro {
struct Vec3 {
float x = 0.f;
float y = 0.f;
float z = 0.f;
Vec3() = default;
Vec3(float px, float py, float pz) : x(px), y(py), z(pz) {}
};
Vec3 lerp(const Vec3& a, const Vec3& b, float t) {
return Vec3(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t);
}
// 对应 OgreKeyFrame.h 55:关键帧是时间轴上的离散快照
struct KeyFrame {
float time;
Vec3 translate;
Vec3 scale;
explicit KeyFrame(float t) : time(t), translate(0.f, 0.f, 0.f), scale(1.f, 1.f, 1.f) {}
float getTime() const { return time; } // 对应 OgreKeyFrame.h 65
};
// 对应 OgreAnimationTrack.h 123:一串按时间排序的关键帧
class AnimationTrack {
public:
explicit AnimationTrack(uint16_t handle) : mHandle(handle) {}
uint16_t getHandle() const { return mHandle; }
// 对应 OgreAnimationTrack.h 150:getNumKeyFrames
size_t getNumKeyFrames() const { return mKeyFrames.size(); }
// 对应 OgreAnimationTrack.h 153:getKeyFrame
KeyFrame* getKeyFrame(size_t index) const { return mKeyFrames.at(index); }
// 对应 OgreAnimationTrack.h 184:createKeyFrame
KeyFrame* createKeyFrame(float timePos) {
mKeyFrames.push_back(new KeyFrame(timePos));
return mKeyFrames.back();
}
// 对应 OgreAnimationTrack.h 176:getKeyFramesAtTime,返回参数 t(0.0 <= t < 1.0)
float getKeyFramesAtTime(float timePos, KeyFrame** keyFrame1, KeyFrame** keyFrame2) const {
size_t i = 0;
while (i + 1 < mKeyFrames.size() && mKeyFrames[i + 1]->getTime() <= timePos) ++i;
*keyFrame1 = mKeyFrames[i];
*keyFrame2 = (i + 1 < mKeyFrames.size()) ? mKeyFrames[i + 1] : mKeyFrames[i];
float span = (*keyFrame2)->getTime() - (*keyFrame1)->getTime();
if (span <= 0.f) return 0.f;
return (timePos - (*keyFrame1)->getTime()) / span;
}
private:
uint16_t mHandle;
// 对应 OgreAnimationTrack.h 249:mKeyFrames
std::vector<KeyFrame*> mKeyFrames;
};
// 对应 OgreAnimation.h 98:Animation 是动画序列
class Animation {
public:
Animation(const char* name, float length) : mName(name), mLength(length) {}
const char* getName() const { return mName; }
// 对应 OgreAnimation.h 134:getLength
float getLength() const { return mLength; }
// 对应 OgreAnimation.h 140:setLength
void setLength(float len) { mLength = len; }
// 对应 OgreAnimation.h 146:createNodeTrack
AnimationTrack* createNodeTrack(uint16_t handle) {
mNodeTracks.push_back(new AnimationTrack(handle));
return mNodeTracks.back();
}
// 对应 OgreAnimation.h 184:getNumNodeTracks
unsigned short getNumNodeTracks() const {
return static_cast<unsigned short>(mNodeTracks.size());
}
private:
const char* mName;
float mLength;
// 对应 OgreAnimation.h 512:mNodeTrackList
std::vector<AnimationTrack*> mNodeTracks;
};
// 插值结果:在前后两关键帧之间按 t 线性合成平移与缩放
struct Interpolated {
Vec3 translate;
Vec3 scale;
};
Interpolated interpolateTrack(AnimationTrack* track, float timePos) {
KeyFrame* kf1;
KeyFrame* kf2;
float t = track->getKeyFramesAtTime(timePos, &kf1, &kf2);
Interpolated out;
out.translate = lerp(kf1->translate, kf2->translate, t);
out.scale = lerp(kf1->scale, kf2->scale, t);
return out;
}
} // namespace ogre_repro
int main() {
using namespace ogre_repro;
// Animation:名称 + 长度
Animation anim("walk", 1.0f);
CHECK_EQ(anim.getLength(), 1.0f);
CHECK_EQ(anim.getNumNodeTracks(), 0);
// createNodeTrack 按 handle 索引轨迹
AnimationTrack* track = anim.createNodeTrack(0);
CHECK_EQ(track->getHandle(), 0);
CHECK_EQ(anim.getNumNodeTracks(), 1);
// 关键帧:时间 + 平移 + 缩放
KeyFrame* k0 = track->createKeyFrame(0.0f);
k0->translate = Vec3(0.f, 0.f, 0.f);
KeyFrame* k1 = track->createKeyFrame(1.0f);
k1->translate = Vec3(1.f, 0.f, 0.f);
CHECK_EQ(track->getNumKeyFrames(), 2u);
CHECK_EQ(track->getKeyFrame(0)->getTime(), 0.0f);
CHECK_EQ(track->getKeyFrame(1)->getTime(), 1.0f);
// 正好落在关键帧上:t=0,返回首帧
KeyFrame* a;
KeyFrame* b;
CHECK_EQ(track->getKeyFramesAtTime(0.0f, &a, &b), 0.0f);
CHECK(a == k0);
// 时间中途:t=0.5,平移线性插值 → (0.5, 0, 0)
Interpolated mid = interpolateTrack(track, 0.5f);
CHECK_EQ(mid.translate.x, 0.5f);
CHECK_EQ(mid.translate.y, 0.0f);
// 超出末尾:夹到最后一帧
KeyFrame* c;
KeyFrame* d;
CHECK_EQ(track->getKeyFramesAtTime(2.0f, &c, &d), 0.0f);
CHECK(c == k1);
// 缩放插值:k0 缩放 (1,1,1),k1 缩放 (2,2,2),t=0.5 → (1.5,1.5,1.5)
k1->scale = Vec3(2.f, 2.f, 2.f);
Interpolated scaled = interpolateTrack(track, 0.5f);
CHECK_EQ(scaled.scale.x, 1.5f);
CHECK_EQ(scaled.scale.y, 1.5f);
// 修改长度
anim.setLength(2.0f);
CHECK_EQ(anim.getLength(), 2.0f);
return lab::report("09-2 动画与轨迹");
}
本机实测(Apple clang 16,clang++ -std=c++20 -Wall):编译通过(零警告),断言 16/16 通过。
小结
- 动画数据三级结构:
Animation(长度 + 轨道组)→AnimationTrack(handle + 关键帧串)→KeyFrame(时间 + 快照)。 - 节点轨道按 handle 索引,
Animation不持有节点指针,只记「动哪根骨」。 getKeyFramesAtTime返回前后两帧加参数 t,t 范围0.0 <= t < 1.0,是插值的数据入口。TransformKeyFrame存绝对快照:平移、缩放、旋转,插值按 t 混合。- 落在关键帧上时返回同一帧、t=0;超出末尾时夹到最后一帧。
阅读导航:上一节:9.1 骨骼与骨节点 · 下一节:9.3 动画状态机 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。