《OGRE 3D 渲染引擎原理与架构》15.3 最小跨后端渲染器

把卷二收束成一段装配流程:Root::initialise 初始化 active 后端,createRenderWindow 委托 _createRenderWindow 并做一次性后初始化,createSceneManager 把后端交给场景管理器,renderOneFrame 走 frameStarted→更新目标→frameEnded。lab 复现完整装配与一帧循环。

15.3 最小跨后端渲染器

一个能跑起来的 OGRE 程序其实只差四步:挑后端、初始化、开窗口、建场景,然后进帧循环。前三步由 Root 的几个入口完成,最后一步就是 renderOneFrame。这一节把卷二散落的机制(后端候选表、窗口创建、场景管理器、目标更新)收束成一条最小的装配链——这也是跨后端抽象的一次完整演出。

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

15.1/15.2 拆开了候选表与插件链,这一节把它们按启动顺序串起来;与卷一 ogre-core 的「启动流程」呼应:卷一讲 Root 全局结构,这里给出一条代码级的最小启动序列。lab 不实现任何后端,只用抽象接口模拟四个装配步骤。

初始化与创建窗口

装配从 Root::initialise 开始:断言已有 active 后端,调 _initialise(),之后才能开窗口:

// OgreMain/src/OgreRoot.cpp:Root::initialise(v14.6.3 源码摘录,已删减)
    RenderWindow* Root::initialise(bool autoCreateWindow, const String& windowTitle)
    {
        OgreAssert(mActiveRenderer, "Cannot initialise");

        if (!mControllerManager)
            mControllerManager = std::make_unique<ControllerManager>();

        PlatformInformation::log(LogManager::getSingleton().getDefaultLog());
        mActiveRenderer->_initialise();

        // Initialise timer
        mTimer->reset();
        ...
        mIsInitialised = true;
        ...
    }

OgreAssert(mActiveRenderer, ...) 保证没选后端不能初始化。窗口创建同样有两条断言,然后委托给 active 后端的 _createRenderWindow;首窗创建后还要跑一次性后初始化(oneTimePostWindowInit)并把它设为 primary:

// OgreMain/src/OgreRoot.cpp:Root::createRenderWindow(v14.6.3 源码摘录,已删减)
    RenderWindow* Root::createRenderWindow(const String &name, unsigned int width, unsigned int height,
            bool fullScreen, const NameValuePairList *miscParams)
    {
        OgreAssert(mIsInitialised,
                   "Cannot create window! Make sure to call Root::initialise before creating a window");
        OgreAssert(mActiveRenderer, "Cannot create window");

        RenderWindow* ret;
        ret = mActiveRenderer->_createRenderWindow(name, width, height, fullScreen, miscParams);

        // Initialisation for classes dependent on first window created
        if(!mFirstTimePostWindowInit)
        {
            oneTimePostWindowInit();
            ret->_setPrimary();
        }

        return ret;
    }

这里有两个 OGRE 惯例值得记下:基类 _createRenderWindow 默认实现只做重名检查 + 打日志(真正创建在各后端 override,1.3 已看),以及 mFirstTimePostWindowInit 保证「只初始化一次」——多窗口共享同一套依赖初始化。

建场景与进帧循环

createSceneManager 只是把请求转发给场景管理器枚举器;枚举器会为新场景管理器接上当前 active 后端:

// OgreMain/src/OgreRoot.cpp:Root::createSceneManager(v14.6.3 源码摘录,已删减)
    SceneManager* Root::createSceneManager(const String& typeName, const String& instanceName)
    {
        return mSceneManagerEnum->createSceneManager(typeName, instanceName);
    }

帧循环的核心是 renderOneFrame。它把一帧切三段:frameStarted 事件 → _updateAllRenderTargets → frameEnded 事件:

// OgreMain/src/OgreRoot.cpp:Root::renderOneFrame(v14.6.3 源码摘录,已删减)
    bool Root::renderOneFrame(void)
    {
        if(!_fireFrameStarted())
            return false;

        if (!_updateAllRenderTargets())
            return false;

        return _fireFrameEnded();
    }
步骤作用返回 false 时
_fireFrameStarted()广播帧开始,应用可在此取消整帧中断
_updateAllRenderTargets()14.1 看过:先画全部目标再统一 swap中断,不进 frameEnded
_fireFrameEnded()广播帧结束返回 false 表示应用主动终止

_updateAllRenderTargets 内部再走 14.1 的调度,最终落到具体后端的 _render——至此,从 Root::initialise 到屏幕上出现像素的最小链路闭合。

帧中段先更新启用自动更新的活动目标,再派发 frameRenderingQueued,随后交换缓冲并处理 LOD 事件。queued 返回 false 时依然执行交换和 LOD,随后跳过 frameEnded。如果 frameEnded 自身返回 false,Root 仍会释放临时缓冲并处理主线程任务。完整调用顺序见卷二 14.1 。

同一场景上的后端验收

先固定场景、资源组、相机、索引范围和图像读回条件。后端专用的材质和窗口配置要单独记录。在同一套业务输入上追踪所选方案、队列项目和提交结果。

原生样例 已提供 Tiny 的绘制与剔除对照。扩展到硬件后端时增加设备、驱动、支持能力、目标格式和图像基线。

源码定位

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

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

下面复现「初始化 → 建窗口 → 建场景 → 帧循环」的最小装配。它与 src/15-3-minimal-renderer-assembly.cpp 逐字节一致:

// file: src/15-3-minimal-renderer-assembly.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/15-3-minimal-renderer-assembly.cpp -o bin/15-3-minimal-renderer-assembly && ./bin/15-3-minimal-renderer-assembly
//
// 复现最小跨后端渲染器的装配(对应 OgreRoot.cpp 492-520 / 754-763 / 962-981):
//   Root::initialise 初始化 active 后端;createRenderWindow 委托 _createRenderWindow 并做一次性后初始化;
//   createSceneManager 把 active 后端交给场景管理器;renderOneFrame = frameStarted -> 更新全部目标 -> frameEnded。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <stdexcept>
#include <string>

namespace ogre_repro {

class RenderWindow {
 public:
  RenderWindow(const std::string& name, uint32_t w, uint32_t h)
      : mName(name), mWidth(w), mHeight(h) {}
  const std::string& getName() const { return mName; }
  uint32_t getWidth() const { return mWidth; }
  uint32_t getHeight() const { return mHeight; }
  int mFramesDrawn = 0;

 private:
  std::string mName;
  uint32_t mWidth;
  uint32_t mHeight;
};

// 抽象后端:对应 RenderSystem 基类
class RenderSystem {
 public:
  explicit RenderSystem(const std::string& name) : mName(name) {}
  virtual ~RenderSystem() = default;
  const std::string& getName() const { return mName; }
  // 对应各后端的 _createRenderWindow
  virtual RenderWindow* _createRenderWindow(const std::string& name, uint32_t w, uint32_t h) = 0;
  // 对应 RenderSystem::_render
  virtual void _renderScene() = 0;
  void _initialise() { ++mInitCount; }
  int mInitCount = 0;

 private:
  std::string mName;
};

class GLRenderSystem : public RenderSystem {
 public:
  GLRenderSystem() : RenderSystem("OpenGL Rendering Subsystem") {}
  RenderWindow* _createRenderWindow(const std::string& name, uint32_t w, uint32_t h) override {
    return new RenderWindow(name, w, h);
  }
  void _renderScene() override { ++mSceneRenders; }
  int mSceneRenders = 0;
};

// 场景管理器:对应 Root::createSceneManager 产出的对象
class SceneManager {
 public:
  void setRenderSystem(RenderSystem* rs) { mRs = rs; }
  void setWindow(RenderWindow* w) { mWindow = w; }
  RenderWindow* getWindow() const { return mWindow; }
  // 对应一帧的更新:后端画几何 + 窗口计数
  void _renderScene() {
    mRs->_renderScene();
    if (mWindow) mWindow->mFramesDrawn++;
  }

 private:
  RenderSystem* mRs = nullptr;
  RenderWindow* mWindow = nullptr;
};

// 最小 Root:对应 Root 的装配入口
class Root {
 public:
  void setRenderSystem(RenderSystem* system) { mActiveRenderer = system; }
  RenderSystem* getRenderSystem() const { return mActiveRenderer; }

  // 对应 Root::initialise
  void initialise() {
    mActiveRenderer->_initialise();
    mIsInitialised = true;
  }

  // 对应 Root::createRenderWindow:未初始化/无 active 后端即抛
  RenderWindow* createRenderWindow(const std::string& name, uint32_t w, uint32_t h) {
    if (!mIsInitialised || !mActiveRenderer)
      throw std::runtime_error("Cannot create window");
    RenderWindow* ret = mActiveRenderer->_createRenderWindow(name, w, h);
    if (!mFirstTimePostWindowInit) mFirstTimePostWindowInit = true;  // oneTimePostWindowInit 占位
    return ret;
  }

  // 对应 Root::createSceneManager:把 active 后端交给新场景管理器
  SceneManager* createSceneManager() {
    SceneManager* sm = new SceneManager();
    sm->setRenderSystem(mActiveRenderer);
    return sm;
  }

  // 对应 Root::renderOneFrame:frameStarted -> 更新目标 -> frameEnded
  bool renderOneFrame() {
    if (!mActiveRenderer) return false;
    if (mSceneManager) mSceneManager->_renderScene();
    ++mFrames;
    return true;
  }
  void setSceneManager(SceneManager* sm) { mSceneManager = sm; }
  int mFrames = 0;

 private:
  RenderSystem* mActiveRenderer = nullptr;
  SceneManager* mSceneManager = nullptr;
  bool mIsInitialised = false;
  bool mFirstTimePostWindowInit = false;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  Root root;
  GLRenderSystem gl;
  root.setRenderSystem(&gl);

  // 未初始化就建窗口:OgreAssert 语义 -> 抛异常
  bool threw = false;
  try {
    root.createRenderWindow("MainWindow", 1920, 1080);
  } catch (const std::runtime_error&) {
    threw = true;
  }
  CHECK(threw);

  // initialise 初始化 active 后端
  root.initialise();
  CHECK_EQ(gl.mInitCount, 1);

  // createRenderWindow 委托后端创建窗口
  RenderWindow* win = root.createRenderWindow("MainWindow", 1920, 1080);
  CHECK(win != nullptr);
  CHECK(win->getName() == "MainWindow");
  CHECK_EQ(win->getWidth(), 1920u);
  CHECK_EQ(win->getHeight(), 1080u);

  // createSceneManager:绑定 active 后端,窗口后续再挂
  SceneManager* sm = root.createSceneManager();
  root.setSceneManager(sm);
  CHECK(sm->getWindow() == nullptr);
  sm->setWindow(win);

  // renderOneFrame:场景管理器画 + 窗口计数
  CHECK(root.renderOneFrame());
  CHECK_EQ(root.mFrames, 1);
  CHECK_EQ(gl.mSceneRenders, 1);
  CHECK_EQ(win->mFramesDrawn, 1);

  // 第二帧
  root.renderOneFrame();
  CHECK_EQ(root.mFrames, 2);
  CHECK_EQ(gl.mSceneRenders, 2);
  CHECK_EQ(win->mFramesDrawn, 2);

  delete sm;
  delete win;

  return lab::report("15-3 最小跨后端渲染器");
}

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

小结

  • 最小装配四步:setRenderSystem → initialise → createRenderWindow → createSceneManager,然后进 renderOneFrame。
  • initialise/createRenderWindow 都带 OgreAssert 前置校验,窗口创建委托后端 _createRenderWindow。
  • mFirstTimePostWindowInit 保证首窗才做一次性后初始化。
  • renderOneFrame 三阶段:frameStarted → _updateAllRenderTargets → frameEnded,任一 false 即中断。
  • 跨后端渲染器的本质:全程只碰抽象 RenderSystem,换后端不影响装配序列。

阅读导航:上一节:15.2 跨后端抽象 · 下一节:目录与学习路径 。

继续阅读 下一卷目录 。

运行 OGRE 原生探针与本卷实验 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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