《OGRE 3D 渲染引擎原理与架构》15.3 一帧渲染循环

最小 OGRE 程序的主循环由 Root::startRendering 驱动:先 OgreAssert(mActiveRenderer),再 while(!mQueuedEnd) 反复调 renderOneFrame。renderOneFrame 是 frameStarted → 更新所有渲染目标 → frameEnded 三步;listener 返回 false 或 queueEndRendering 都会让循环退出。lab 用 C++ 复现主循环与三种退出路径。

15.3 一帧渲染循环

15.1 启动了引擎,15.2 建好了场景。最后一环:把它转起来。Root::startRendering 是整个引擎的心脏——一个 while 循环反复渲染每一帧,直到有人喊停。这一节看这个循环怎么写、怎么停。

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

12.3 拆过单帧的三个事件(started/rendering/ended);这里看装配层的循环——startRendering 如何把单帧串成无限循环,以及三种退出路径。

startRendering:while(!mQueuedEnd)

Root::startRendering 很短,但它是引擎的「总开关」:

// OgreMain/src/OgreRoot.cpp:Root::startRendering(v14.6.3 源码摘录,已删减)
    void Root::startRendering(void)
    {
        OgreAssert(mActiveRenderer, "no RenderSystem");

        mActiveRenderer->_initRenderTargets();

        // Clear event times
        clearEventTimes();

        // Infinite loop, until broken out of by frame listeners
        // or break out by calling queueEndRendering()
        mQueuedEnd = false;

        while( !mQueuedEnd )
        {
            if (!renderOneFrame())
                break;
        }
    }

拆开看:

  1. OgreAssert(mActiveRenderer, "no RenderSystem")——与 15.1 的 initialise 同一套前置断言:没有渲染系统,谈什么渲染。
  2. _initRenderTargets()——让渲染系统先备好渲染目标。
  3. mQueuedEnd = false——清掉遗留的退出标记,保证 startRendering 可以「重启」。
  4. while(!mQueuedEnd)——核心循环。每次迭代调 renderOneFrame(),返回 false 就 break。

注释说清了两条退出路径:frame listener 让它停(renderOneFrame 返回 false)或 调用 queueEndRendering()(置 mQueuedEnd = true)。窗口关闭这类外部事件,通常由 listener 检测后转为 queueEndRendering 请求。

renderOneFrame:三件套

renderOneFrame 是无参版的单帧装配——就是 12.3 讲过的三步:

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

        if (!_updateAllRenderTargets())
            return false;

        return _fireFrameEnded();
    }

任一环节返回 false 立即整帧中断并返回 false,上层循环据此退出。有参版 renderOneFrame(Real timeSinceLastFrame) 则用传入的帧时间填充 FrameEvent,适合自己管理时钟的应用(编辑器、工具这类低刷新率场景)。

queueEndRendering:优雅停机

queueEndRendering 只是翻一个布尔量:

// OgreMain/src/OgreRoot.cpp:Root::queueEndRendering(v14.6.3 源码摘录,已删减)
    void Root::queueEndRendering(bool state /* = true */)
    {
        mQueuedEnd = state;
    }
    bool Root::endRenderingQueued(void)
    {
        return mQueuedEnd;
    }

注释点明:startRendering 不会立即返回,它是「阻塞式」的——queueEndRendering 只是设个标记,循环在下一帧开始前看到它才退出。所以回调里调用它是安全的:不会在渲染中途打断当前帧。

三种退出路径总结

路径机制触发方式
listener 返回 falserenderOneFrame 短路frameStarted 里返回 false
显式停机mQueuedEnd 置位queueEndRendering()
单帧失败renderOneFrame 返回 false内部任一环节失败

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

最小程序的三个观测面

启动看后端和首窗是否真正可用,资源看材质解析与网格加载,帧循环看入队、实际三角形统计和读回。窗口初始化成功只说明启动链已到首窗。

依次运行 帧探针与场景样例 ,用相同构建结果观察首帧、退出分支、卸载和资源重载。

源码定位

  • OgreMain/src/OgreRoot.cpp :Root::startRendering(OgreAssert + _initRenderTargets + while(!mQueuedEnd))、Root::renderOneFrame(三步三件套)、Root::queueEndRendering/endRenderingQueued(mQueuedEnd 读写)

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

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

下面复现主循环与三种退出路径。它与 src/15-3-main-loop.cpp 逐字节一致:

// file: src/15-3-main-loop.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/15-3-main-loop.cpp -o bin/15-3-main-loop && ./bin/15-3-main-loop
//
// 复现最小 OGRE 程序的主循环:
//   Root::startRendering 用 while(!mQueuedEnd) 驱动(对应 OgreRoot.cpp 734-752);
//   每帧 renderOneFrame = frameStarted → 更新目标 → frameEnded(对应 754-763);
//   queueEndRendering 设 mQueuedEnd 让循环退出;listener 返回 false 也退出(短路);
//   窗口关闭(hasClosed)作为独立退出信号汇入 mQueuedEnd。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <string>
#include <vector>

namespace ogre_repro {

// FrameListener:返回 false 中止整帧(对应 _fireFrameStarted 短路)
class FrameListener {
 public:
  virtual bool frameStarted(float t) { return true; }
  virtual bool frameEnded(float t) { return true; }
};

// 渲染目标:窗口可被关闭
class RenderTarget {
 public:
  bool mHasClosed = false;
  bool hasClosed() const { return mHasClosed; }
  int mTargetUpdates = 0;
};

class Root {
 public:
  // 对应 startRendering:while(!mQueuedEnd) 主循环
  int startRendering() {
    mQueuedEnd = false;
    int frames = 0;
    while (!mQueuedEnd) {
      if (!renderOneFrame()) break;
      ++frames;
      if (mWindow && mWindow->hasClosed()) mQueuedEnd = true;
    }
    return frames;
  }
  // 对应 renderOneFrame:事件 + 更新目标
  bool renderOneFrame() {
    if (!_fireFrameStarted()) return false;
    if (mWindow) mWindow->mTargetUpdates++;
    return _fireFrameEnded();
  }
  // 对应 queueEndRendering
  void queueEndRendering() { mQueuedEnd = true; }
  bool endRenderingQueued() const { return mQueuedEnd; }

  bool _fireFrameStarted() {
    for (auto* l : mListeners)
      if (!l->frameStarted(mTime)) return false;
    return true;
  }
  bool _fireFrameEnded() {
    for (auto* l : mListeners)
      if (!l->frameEnded(mTime)) return false;
    return true;
  }

  void addFrameListener(FrameListener* l) { mListeners.push_back(l); }

  RenderTarget* mWindow = nullptr;
  std::vector<FrameListener*> mListeners;
  float mTime = 0.016f;
  bool mQueuedEnd = false;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 场景一:3 帧后 listener 请求退出
  Root root;
  RenderTarget window;
  root.mWindow = &window;
  struct QuitAfter : public FrameListener {
    Root* root;
    int n = 0;
    bool frameStarted(float) override {
      if (++n == 3) root->queueEndRendering();
      return true;
    }
  } quitter;
  quitter.root = &root;
  root.addFrameListener(&quitter);

  int frames = root.startRendering();
  CHECK(frames == 3);
  CHECK(window.mTargetUpdates == 3);

  // 场景二:窗口关闭也退出,无需 queueEndRendering
  Root root2;
  RenderTarget window2;
  root2.mWindow = &window2;
  struct CloseAfter : public FrameListener {
    RenderTarget* window;
    int n = 0;
    bool frameStarted(float) override {
      if (++n == 2) window->mHasClosed = true;
      return true;
    }
  } closer;
  closer.window = &window2;
  root2.addFrameListener(&closer);

  frames = root2.startRendering();
  CHECK(frames == 2);

  // 场景三:listener 返回 false → 短路立即退出
  Root root3;
  RenderTarget window3;
  root3.mWindow = &window3;
  struct Abort : public FrameListener {
    bool frameStarted(float) override { return false; }
  } aborting;
  root3.addFrameListener(&aborting);

  frames = root3.startRendering();
  CHECK(frames == 0);

  return lab::report("15-3 装配:最小的 OGRE 程序(主循环)");
}

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

小结

  • startRendering:OgreAssert(mActiveRenderer) → _initRenderTargets() → mQueuedEnd=false → while(!mQueuedEnd) { renderOneFrame() }。
  • renderOneFrame = _fireFrameStarted → _updateAllRenderTargets → _fireFrameEnded,任一环节 false 即整帧中断。
  • queueEndRendering 只翻 mQueuedEnd 布尔,循环在下一帧开始前退出——回调内调用安全。
  • 三种退出路径:listener 返回 false、显式 queueEndRendering、单帧内部失败。

阅读导航:上一节:15.2 建场景 · 下一节:本卷目录 。

继续阅读 下一卷目录 。

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

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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