《OGRE 3D 渲染引擎原理与架构》9.1 骨骼与骨节点

骨骼动画的数据根基是 Skeleton 与 Bone:Skeleton 是 Resource 与 AnimationContainer,按 handle 索引存骨;Bone 是关节层级里的一个节点,通过 createChild 挂成树,世界变换沿父链累乘。lab 复现骨树构建、根骨识别与世界位置累加。

9.1 骨骼与骨节点

要让角色走路、挥手、转身,最省内存的做法是只动一小撮「骨头」,让成千上万的网格顶点跟着骨头走——这就是骨骼动画。OGRE 里它的两大支柱是 Skeleton(骨骼,一个网格绑定的全部骨头集合)与 Bone(骨节点,关节层级中的一环)。这一节先把这两者的类关系、存储结构与「世界变换沿骨树累乘」的机制讲透,为 9.2 的动画轨迹和 9.3 的动画状态铺路。

本章与站内既有内容的分工

helio 四卷从零实现的引擎里有节点树但没有骨骼蒙皮;cg 三卷讲的是顶点变形与插值的图形学原理。这里解析真实 OGRE 的 Skeleton/Bone:它们不是动画本身,而是被动画驱动的数据容器与节点层级。真正让骨头动起来的 Animation/AnimationTrack 在 9.2,控制播放的 AnimationState 在 9.3。读者若在 ogre-core 卷看过 Node 的派生体系,会对 Bone : public Node 感到眼熟。

Skeleton:骨骼的资源容器

Skeleton 同时继承 Resource 与 AnimationContainer——前者让它像材质、网格一样由资源系统管理(.skeleton 文件按需加载);后者让它能持有并管理一组 Animation(9.2)。类声明很短:

// OgreMain/include/OgreSkeleton.h:Skeleton 类(v14.6.3 源码摘录,已删减)
    class _OgreExport Skeleton : public Resource, public AnimationContainer
    {

骨头的存储很直白:一个 BoneList(本质是 std::vector<Bone*>),下标就是 handle。OGRE 要求骨骼 handle 从 0 开始连续编号,这样编译期就能把骨变换压成一个索引矩阵数组:

// OgreMain/include/OgreSkeleton.h:Skeleton::getBone(v14.6.3 源码摘录,已删减)
        Bone* getBone(unsigned short handle) const
        {
            assert(handle < mBoneList.size() && "Index out of bounds");
            return mBoneList[handle];
        }

注意这是 O(1) 下标访问而非名字查找;文档里也明确建议性能敏感代码只用 handle。创建骨的方法 createBone 会自动从 0 起分配顺序 handle,也允许显式指定 handle 或名字。

私有成员里那个被 9.3 复用的存储就一行:

// OgreMain/include/OgreSkeleton.h:Skeleton 私有成员(v14.6.3 源码摘录,已删减)
        /// Storage of bones, indexed by bone handle
        BoneList mBoneList;
方法语义
createBone()新建无父骨并自动分配顺序 handle
getNumBones()返回 mBoneList.size(),即骨头总数
getBones()返回整个 BoneList 引用
getBone(handle)按 handle O(1) 取骨

Bone:关节层级里的节点

单根骨头只是一根"棍",动起来靠的是层级——骨盆带动脊柱、脊柱带动头。所以 Bone 直接继承 Node,天生就有父节点、子节点、局部/世界变换这套体系:

// OgreMain/include/OgreBone.h:Bone 类(v14.6.3 源码摘录,已删减)
    class _OgreExport Bone : public Node
    {

建骨的方式有两种:先在 Skeleton 上建根骨,再用根骨的 createChild 往下挂。createChild 接受一个相对父骨的局部平移与旋转:

// OgreMain/include/OgreBone.h:Bone::createChild(v14.6.3 源码摘录,已删减)
        Bone* createChild(unsigned short handle, 
            const Vector3& translate = Vector3::ZERO, const Quaternion& rotate = Quaternion::IDENTITY);

        /** Gets the numeric handle for this bone (unique within the skeleton). */
        unsigned short getHandle(void) const { return mHandle; }

Bone 隐藏了 Node::createChild 的无参重载(using Node::createChild; 放在 private 区),强制走带 handle 的版本,保证每个子骨在骨架里 handle 唯一。

根骨与骨树遍历

根骨的定义是「没有父骨的骨」。OGRE 允许多个根骨(getRootBones 返回一个列表),但手动建骨架时通常只有一个根,其余骨全部经 createChild 派生:

// OgreMain/include/OgreSkeleton.h:Skeleton::getRootBones(v14.6.3 源码摘录,已删减)
        const BoneList& getRootBones() const;

根骨是懒推导的:第一次查询时从骨列表第一个骨出发沿父链上溯到顶,缓存进 mRootBones。世界变换沿骨树由父向子累乘——每个骨的世界位置 = 父骨世界位置 + 自身局部平移(旋转再引入四元数,但平移路径这个加法本质不变)。lab 里把这条链复现为 getWorldPosition() 递归。

源码定位

上游引用固定到 OGRE v14.6.3 源码 。

可运行产物:C++ 最小验证

下面用纯 C++ 复现 Skeleton/Bone 的骨树层级、根骨识别与世界位置累加。它与 src/09-1-skeleton-bone.cpp 逐字节一致:

// file: src/09-1-skeleton-bone.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/09-1-skeleton-bone.cpp -o bin/09-1-skeleton-bone && ./bin/09-1-skeleton-bone
//
// 复现 Skeleton/Bone 的骨骼层级(对应 OgreSkeleton.h 82/158/177/183/188、OgreBone.h 51/76/80):
//   Skeleton 按 handle 索引存储 mBoneList,getRootBones 返回无父骨;
//   Bone 继承 Node,createChild 建立父/子层级;
//   世界变换沿骨树由父向子累乘(局部平移累加)。
// 独立最小验证,非 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 operator+(const Vec3& a, const Vec3& b) { return Vec3(a.x + b.x, a.y + b.y, a.z + b.z); }

// 对应 OgreBone.h 51:Bone 是关节层级里的一个节点
class Bone {
 public:
  Bone(uint16_t handle, Bone* parent) : mHandle(handle), mParent(parent) {}
  // 对应 OgreBone.h 76:createChild 创建子骨并挂到父骨
  Bone* createChild(uint16_t handle, const Vec3& translate) {
    Bone* child = new Bone(handle, this);
    child->mTranslate = translate;
    mChildren.push_back(child);
    return child;
  }
  // 对应 OgreBone.h 80:getHandle
  uint16_t getHandle() const { return mHandle; }
  const std::vector<Bone*>& getChildren() const { return mChildren; }
  bool hasChildren() const { return !mChildren.empty(); }
  void setTranslate(const Vec3& t) { mTranslate = t; }
  const Vec3& getTranslate() const { return mTranslate; }
  Bone* getParent() const { return mParent; }

  // 沿父链累乘:子骨世界位置 = 父骨世界位置 + 自身局部平移
  Vec3 getWorldPosition() const {
    if (!mParent) return mTranslate;
    return mParent->getWorldPosition() + mTranslate;
  }

 private:
  uint16_t mHandle;
  Bone* mParent;
  Vec3 mTranslate;
  std::vector<Bone*> mChildren;
};

// 对应 OgreSkeleton.h 82:Skeleton 是骨的集合
class Skeleton {
 public:
  // 对应 OgreSkeleton.h 113:createBone,按 handle 编索引
  Bone* createBone(uint16_t handle) {
    if (mBoneList.size() <= handle) mBoneList.resize(handle + 1, nullptr);
    mBoneList[handle] = new Bone(handle, nullptr);
    return mBoneList[handle];
  }
  // 对应 OgreSkeleton.h 158:getNumBones
  unsigned short getNumBones() const { return static_cast<unsigned short>(mBoneList.size()); }
  // 对应 OgreSkeleton.h 183:getBones
  const std::vector<Bone*>& getBones() const { return mBoneList; }
  // 对应 OgreSkeleton.h 188:getBone
  Bone* getBone(unsigned short handle) const { return mBoneList.at(handle); }
  // 对应 OgreSkeleton.h 177:getRootBones,无父骨即根骨
  std::vector<Bone*> getRootBones() const {
    std::vector<Bone*> roots;
    for (Bone* b : mBoneList)
      if (b && !b->getParent()) roots.push_back(b);
    return roots;
  }

 private:
  // 对应 OgreSkeleton.h 443:mBoneList 按 handle 索引
  std::vector<Bone*> mBoneList;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // createBone 后按 handle 可查到骨
  Skeleton skel;
  Bone* root = skel.createBone(0);
  CHECK_EQ(skel.getNumBones(), 1);
  CHECK_EQ(skel.getBone(0), root);

  // Bone::createChild:child 相对 parent 的局部平移
  Bone* hip = root->createChild(1, Vec3(0.f, 1.f, 0.f));
  Bone* hand = hip->createChild(2, Vec3(1.f, 0.f, 0.f));
  CHECK_EQ(hip->getHandle(), 1);
  CHECK_EQ(hand->getHandle(), 2);
  CHECK(root->hasChildren());
  CHECK_EQ(root->getChildren().size(), 1u);

  // 沿树累乘:root(0,0,0) → hip(0,1,0) → hand(1,1,0)
  CHECK_EQ(root->getWorldPosition().x, 0.f);
  CHECK_EQ(hip->getWorldPosition().y, 1.f);
  CHECK_EQ(hand->getWorldPosition().x, 1.f);
  CHECK_EQ(hand->getWorldPosition().y, 1.f);
  CHECK_EQ(hand->getWorldPosition().z, 0.f);

  // getRootBones:只有无父骨
  auto roots = skel.getRootBones();
  CHECK_EQ(roots.size(), 1u);
  CHECK_EQ(roots[0], root);

  // 移动父骨会带动子骨:把 hip 局部平移改为向上 2 单位,hand 世界 y 变 2
  hip->setTranslate(Vec3(0.f, 2.f, 0.f));
  CHECK_EQ(hand->getWorldPosition().y, 2.f);

  // 多根骨也支持(骨架可有多个 root)
  Bone* root2 = skel.createBone(3);
  auto roots2 = skel.getRootBones();
  CHECK_EQ(roots2.size(), 2u);
  CHECK_EQ(roots2[1], root2);

  return lab::report("09-1 骨骼与骨节点");
}

本机实测(Apple clang 16,clang++ -std=c++20 -Wall):编译通过(零警告),断言 16/16 通过。

小结

  • Skeleton 是 Resource 与 AnimationContainer,从 .skeleton 文件按需加载,是动画的容器与骨的仓库。
  • 骨按 handle 存在 mBoneList 里,handle 从 0 连续编号,getBone 是 O(1) 下标访问。
  • Bone : public Node,用 createChild(handle, translate, rotate) 挂成关节树。
  • 根骨是「无父骨」,可多根;getRootBones 懒推导并缓存。
  • 世界变换沿骨树由父向子累乘,父骨一移动,整条子链跟着动。

阅读导航:上一节:8.3 地形分页 · 下一节:9.2 动画与轨迹 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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