《OGRE 3D 渲染引擎原理与架构》9.2 动画与轨迹

动画数据以 Animation → AnimationTrack → KeyFrame 三级结构存放:Animation 是长度加一组轨迹,轨迹按 handle 索引一串按时间排序的关键帧,TransformKeyFrame 记录平移/缩放/旋转。lab 复现 getKeyFramesAtTime 返回前后两帧与插值参数 t,并按 t 线性合成。

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 个关键帧,中间的运动全靠插值补出来。

源码定位

上游引用固定到 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 动画状态机 。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图