《OGRE 3D 渲染引擎原理与架构》1.2 可渲染对象与渲染操作

Renderable 是 OGRE 声明式渲染的最小契约:getMaterial/getRenderOperation/getWorldTransforms 三个纯虚方法决定一个物体怎么被画;RenderOperation 携带绘制类型(点/线/三角列表/条带/扇形)与顶点/索引数据。lab 复现契约实现与操作类型的记录语义。

1.2 可渲染对象与渲染操作

一个物体要能被画出来,得先回答三个问题:用什么材质、画成什么形状、摆在世界的哪里。OGRE 把这三个问题的答案约定成一个纯虚契约 Renderable,任何「可渲染的东西」(网格实体、粒子、布告板、天空盒)都实现它。这一节看契约本身与它携带的数据结构 RenderOperation。

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

卷二 2.x 讲了顶点声明与缓冲;卷一 8.x 讲了材质数据。Renderable 是这两个世界对接的契约:材质从 getMaterial 来,几何从 getRenderOperation 来,放置从 getWorldTransforms 来——后端只认这份契约,不管对象到底是什么。

Renderable:三个纯虚方法

// OgreMain/include/OgreRenderable.h:Renderable(v14.6.3 源码摘录,已删减)
    class _OgreExport Renderable
    {
    public:
        enum
        {
            DEFAULT_PRIORITY = 100
        };

        Renderable()
            : mMaterialLodIndex(0), mPolygonModeOverrideable(true), mUseIdentityProjection(false),
              mUseIdentityView(false)
        {
        }
        /** Virtual destructor needed as class has virtual methods. */
        virtual ~Renderable() {}
        /** Retrieves a weak reference to the material this renderable object uses.
        */
        virtual const MaterialPtr& getMaterial(void) const = 0;
        /** Gets the render operation required to send this object to the frame buffer.
        */
        virtual void getRenderOperation(RenderOperation& op) = 0;
方法契约含义
getMaterial()返回材质引用(后续 getTechnique 默认选最佳 Technique)
getRenderOperation(RenderOperation&)填充「画什么形状、用哪些缓冲」
getWorldTransforms(Matrix4*)填充世界变换矩阵(GPU 蒙皮时是多个矩阵)

注意 getRenderOperation 不是 const——它要往调用方传入的 RenderOperation& 里写数据。构造函数还有一组默认状态:mPolygonModeOverrideable(true)(多边模式可被覆盖)、mUseIdentityProjection/View(false)(默认用真实投影/视图矩阵)。

RenderOperation:一次绘制的声明

getRenderOperation 填的是一个 RenderOperation,它把「画法」完整声明出来:

// OgreMain/include/OgreRenderOperation.h:RenderOperation(v14.6.3 源码摘录,已删减)
    class _OgreExport RenderOperation {
    public:
        /// The rendering operation type to perform
        enum OperationType : uint8 {
            /// A list of points, 1 vertex per point
            OT_POINT_LIST = 1,
            /// A list of lines, 2 vertices per line
            OT_LINE_LIST = 2,
            /// A strip of connected lines, 1 vertex per line plus 1 start vertex
            OT_LINE_STRIP = 3,
            /// A list of triangles, 3 vertices per triangle
            OT_TRIANGLE_LIST = 4,
            /// A strip of triangles, 3 vertices for the first triangle, and 1 per triangle after that
            OT_TRIANGLE_STRIP = 5,
            /// A fan of triangles, 3 vertices for the first triangle, and 1 per triangle after that
            OT_TRIANGLE_FAN = 6,
字段(RenderOperation 成员)含义
operationType图元类型(uint8 枚举:点/线/线带/三角列表/条带/扇形)
vertexData顶点数据(顶点声明 + 缓冲)
indexData/useIndexes索引数据,useIndexes 为真才有效
srcRenderable 等供后端取用来源对象

声明式渲染:发现与绘制分离

OGRE 是队列渲染器。Renderable::getRenderOperation 的文档注释说得直白:真实渲染命令是在对象「被发现可见」之后很久才执行的。发现阶段只把声明填进 RenderQueue,排序与分组后,真正绘制时后端再来消费这份 RenderOperation。这意味着:

  • 场景遍历(发现)不需要知道后端细节;
  • 排序、合批、状态缓存都可以在队列层做;
  • preRender/postRender 钩子让个别对象在绘制点做特殊处理(返回 false 可完全接管自己的绘制)。

源码定位

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

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

下面复现 Renderable 契约与 RenderOperation 声明。它与 src/01-2-renderable-operation.cpp 逐字节一致:

// file: src/01-2-renderable-operation.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/01-2-renderable-operation.cpp -o bin/01-2-renderable-operation && ./bin/01-2-renderable-operation
//
// 复现 Renderable 契约与 RenderOperation(对应 OgreRenderable.h 63-、OgreRenderOperation.h 45-):
//   Renderable 是纯虚契约:getMaterial / getRenderOperation / getWorldTransforms 必须实现;
//   RenderOperation 的 OperationType 枚举(点/线/三角列表/条带/扇形)+ vertexData/indexData;
//   队列渲染是声明式:发现可见时只记录 RenderOperation,真正绘制在稍后执行。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <memory>
#include <string>
#include <vector>

namespace ogre_repro {

// 对应 OperationType(OgreRenderOperation.h 48-,uint8 底层)
enum class OperationType : uint8_t {
  OT_POINT_LIST = 1,
  OT_LINE_LIST = 2,
  OT_LINE_STRIP = 3,
  OT_TRIANGLE_LIST = 4,
  OT_TRIANGLE_STRIP = 5,
  OT_TRIANGLE_FAN = 6,
};

// 极简 VertexData:顶点数 + 每顶点字节数
struct VertexData {
  size_t vertexCount = 0;
  size_t vertexSize = 0;  // 字节
};

// 对应 RenderOperation(OgreRenderOperation.h 45-):一次绘制的全部声明信息
struct RenderOperation {
  OperationType operationType = OperationType::OT_TRIANGLE_LIST;
  std::shared_ptr<VertexData> vertexData;
  bool useIndexes = false;
  size_t indexStart = 0;
  size_t indexCount = 0;
};

// 对应 Renderable(OgreRenderable.h 63-)的极简实现
class Renderable {
 public:
  virtual ~Renderable() = default;
  virtual const std::string& getMaterial() const = 0;         // 对应 getMaterial
  virtual void getRenderOperation(RenderOperation& op) = 0;   // 对应 getRenderOperation
  virtual void getWorldTransforms(float xform[16]) const = 0; // 对应 getWorldTransforms
};

// 一个可渲染的三角形网格
class TriangleMesh final : public Renderable {
 public:
  explicit TriangleMesh(const std::string& mat) : mMaterial(mat) {}

  const std::string& getMaterial() const override { return mMaterial; }
  void getRenderOperation(RenderOperation& op) override {
    op.operationType = OperationType::OT_TRIANGLE_LIST;
    op.vertexData = mVertexData;
    op.useIndexes = false;
    op.indexStart = 0;
    op.indexCount = mVertexData->vertexCount;
  }
  void getWorldTransforms(float xform[16]) const override {
    // 单位变换:对角为 1
    for (int i = 0; i < 16; ++i) xform[i] = 0;
    xform[0] = xform[5] = xform[10] = xform[15] = 1.0f;
  }

  void setVertexData(size_t count, size_t size) {
    mVertexData = std::make_shared<VertexData>();
    mVertexData->vertexCount = count;
    mVertexData->vertexSize = size;
  }

 private:
  std::string mMaterial;
  std::shared_ptr<VertexData> mVertexData;
};

// 声明式渲染队列:记录 RenderOperation,不立即绘制
struct QueuedOp {
  const Renderable* renderable;
  RenderOperation op;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 三角形网格:3 顶点 × 每顶点 32 字节(pos 12 + normal 12 + uv 8)
  TriangleMesh tri("examples/stone");
  tri.setVertexData(3, 32);

  // Renderable 契约:getMaterial + getRenderOperation + getWorldTransforms
  Renderable& r = tri;
  CHECK(r.getMaterial() == "examples/stone");

  RenderOperation op;
  r.getRenderOperation(op);
  CHECK(op.operationType == OperationType::OT_TRIANGLE_LIST);
  CHECK(op.vertexData->vertexCount == 3);
  CHECK(op.vertexData->vertexSize == 32);
  CHECK(!op.useIndexes);
  CHECK(op.indexCount == 3);

  float xf[16];
  r.getWorldTransforms(xf);
  CHECK(xf[0] == 1.0f && xf[5] == 1.0f && xf[10] == 1.0f && xf[15] == 1.0f);

  // 声明式队列:把 Renderable 的记录塞进队列,绘制推迟
  std::vector<QueuedOp> queue;
  QueuedOp q;
  q.renderable = &tri;
  r.getRenderOperation(q.op);
  queue.push_back(q);
  CHECK(queue.size() == 1);
  CHECK(queue[0].op.vertexData->vertexCount == 3);

  return lab::report("01-2 可渲染对象与渲染操作");
}

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

小结

  • Renderable 是声明式渲染的契约:材质、形状、世界变换三个纯虚方法。
  • RenderOperation 把「画法」数据化:OperationType(uint8 枚举)+ vertexData/indexData。
  • OGRE 是队列渲染器:发现与绘制分离,排序合批在队列层做,preRender/postRender 是绘制点钩子。
  • 一切可渲染对象——网格、粒子、布告板、天空盒——都只实现这份契约。

阅读导航:上一节:1.1 实体与子实体 · 下一节:1.3 实体相机关联与 LOD 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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