《OGRE 3D 渲染引擎原理与架构》12.3 渲染循环中的事件时序

renderOneFrame 是渲染循环的核心:_fireFrameStarted → _updateAllRenderTargets → _fireFrameEnded,任一环节返回 false 即退出。FrameEvent 的 timeSinceLastFrame 由调用方传入,timeSinceLastEvent 在每次派发前用计时器重算。lab 用 C++ 复现一帧的事件序列与提前退出。

12.3 渲染循环中的事件时序

12.1/12.2 讲了监听器的接口与注册;这一节把三件事串起来——renderOneFrame 到底按什么顺序派发哪些事件。

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

12.2 讲派发机制本身;这里讲一帧的完整时序:哪个事件在前、哪个在后,以及每个事件怎么填 FrameEvent。

renderOneFrame:三段式

Root::renderOneFrame 的核心是三段调用:

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

        if (!_updateAllRenderTargets())
            return false;

        return _fireFrameEnded();
    }

顺序:

  1. _fireFrameStarted()——帧开始事件,先于任何渲染目标更新;
  2. _updateAllRenderTargets()——更新所有渲染目标(真正提交渲染命令);
  3. _fireFrameEnded()——帧结束事件。

三段任一段返回 false 都中断整帧。

带时间的重载:FrameEvent 怎么填

另一个 renderOneFrame(Real timeSinceLastFrame) 重载显式填事件时间:

// OgreMain/src/OgreRoot.cpp:Root::renderOneFrame(Real)(v14.6.3 源码摘录,已删减)
    bool Root::renderOneFrame(Real timeSinceLastFrame)
    {
        FrameEvent evt;
        evt.timeSinceLastFrame = timeSinceLastFrame;

        unsigned long now = mTimer->getMilliseconds();
        evt.timeSinceLastEvent = calculateEventTime(now, FETT_ANY);

        if(!_fireFrameStarted(evt))
            return false;

        if (!_updateAllRenderTargets(evt))
            return false;

        now = mTimer->getMilliseconds();
        evt.timeSinceLastEvent = calculateEventTime(now, FETT_ANY);

        return _fireFrameEnded(evt);
    }

两个时间字段的填充方式不同:

  • timeSinceLastFrame:由调用方传入——通常是外层循环量好的一帧时长;
  • timeSinceLastEvent:每次派发前用 mTimer 现场量——calculateEventTime(now, FETT_ANY) 按「距上个事件」的时间窗口计算。

注意 frameStarted 和 frameEnded 之间重新量了一次 timeSinceLastEvent——帧开始时的值和帧结束时的值不同,分别代表「帧开始前隔了多久」和「帧结束后隔了多久」。

主循环:while 包 renderOneFrame

Root::startRendering 用 while(!mQueuedEnd) 包住 renderOneFrame:

// OgreMain/src/OgreRoot.cpp:Root::startRendering(v14.6.3 源码摘录,已删减)
        mQueuedEnd = false;

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

在拥有渲染循环的线程调用 queueEndRendering() 可以请求退出。跨线程应通过同步的消息队列投递,mQueuedEnd 是普通 bool;而任一帧事件返回 false 也会 break——这就是 12.1/12.2 里 false 中止语义的最终落点。

一帧的事件顺序

startRendering
 └─ while(!mQueuedEnd)
     └─ renderOneFrame()
         ├─ _fireFrameStarted()          → 监听器.frameStarted
         ├─ _updateAllRenderTargets()    → 提交渲染命令到所有渲染目标
         ├─ _fireFrameRenderingQueued()  → 监听器.frameRenderingQueued(缓冲交换前)
         └─ _fireFrameEnded()            → 监听器.frameEnded

任一环节 false → break。这就是 OGRE 渲染循环对外暴露的全部钩子。

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

源码定位

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

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

下面复现一帧的事件序列与提前退出。它与 src/12-3-render-one-frame.cpp 逐字节一致:

// file: src/12-3-render-one-frame.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/12-3-render-one-frame.cpp -o bin/12-3-render-one-frame && ./bin/12-3-render-one-frame
//
// 复现 Root::renderOneFrame 的帧时序:
//   _fireFrameStarted → 更新所有渲染目标 → _fireFrameEnded
//   (对应 OgreRoot.cpp renderOneFrame);
//   FrameEvent 的 timeSinceLastFrame 由调用方传入,timeSinceLastEvent 在派发前重算;
//   主循环 while(!mQueuedEnd) renderOneFrame(),任一回调 false 即退出。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <string>
#include <vector>

namespace ogre_repro {

struct FrameEvent {
  float timeSinceLastEvent = 0;
  float timeSinceLastFrame = 0;
};

// 记录事件序列并捕获帧事件时间
struct FrameListener {
  virtual ~FrameListener() {}
  virtual bool frameStarted(const FrameEvent& evt) {
    lastTimeSinceLastEvent = evt.timeSinceLastEvent;
    lastTimeSinceLastFrame = evt.timeSinceLastFrame;
    log += "S";
    return true;
  }
  virtual bool frameRenderingQueued(const FrameEvent&) { log += "R"; return true; }
  virtual bool frameEnded(const FrameEvent&) { log += "E"; return true; }
  std::string log;
  float lastTimeSinceLastEvent = -1;
  float lastTimeSinceLastFrame = -1;
};

// 对应 Root 的最小渲染循环
class Root {
 public:
  // 对应 _updateAllRenderTargets
  bool updateAllRenderTargets() {
    targetsUpdated += 1;
    return true;
  }
  // 对应 calculateEventTime(简化:当前帧时钟 - 上次时间戳)
  float calculateEventTime(float now) { return now - lastStamp; }
  // 模拟帧计时:每帧推进 16.7ms
  float timerMs() {
    timer += 16.7f;
    return timer;
  }

  // 对应 renderOneFrame(Real timeSinceLastFrame)
  bool renderOneFrame(float timeSinceLastFrame) {
    FrameEvent evt;
    evt.timeSinceLastFrame = timeSinceLastFrame;

    float now = timerMs();
    evt.timeSinceLastEvent = calculateEventTime(now);

    for (auto* l : listeners)
      if (!l->frameStarted(evt)) return false;

    if (!updateAllRenderTargets()) return false;

    // 命令已提交、缓冲交换前:frameRenderingQueued
    bool continueFrame = true;
    for (auto* l : listeners) {
      if (!l->frameRenderingQueued(evt)) {
        continueFrame = false;
        break;
      }
    }
    ++swaps;
    if (!continueFrame) return false;

    now = timerMs();
    evt.timeSinceLastEvent = calculateEventTime(now);
    lastStamp = now;

    for (auto* l : listeners) {
      if (!l->frameEnded(evt)) {
        continueFrame = false;
        break;
      }
    }
    ++mainThreadPumps;
    return continueFrame;
  }

  int swaps = 0;
  int mainThreadPumps = 0;

  // 对应主循环 while(!mQueuedEnd) renderOneFrame()
  void startRendering(int frames) {
    for (int i = 0; i < frames; ++i)
      if (!renderOneFrame(0.016f)) break;
  }

  std::vector<FrameListener*> listeners;
  int targetsUpdated = 0;
  float timer = 0;
  float lastStamp = 0;
};

// 在第 N 帧返回 false 的监听器(模拟中止渲染循环)
class QuitAfterListener : public FrameListener {
 public:
  QuitAfterListener(int framesToRun) : mFramesToRun(framesToRun) {}
  bool frameStarted(const FrameEvent& evt) override {
    FrameListener::frameStarted(evt);
    if (++mFrameCount >= mFramesToRun) return false;
    return true;
  }
  int mFramesToRun;
  int mFrameCount = 0;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  FrameListener a;
  Root root;
  root.listeners.push_back(&a);

  // 渲染 3 帧:每帧 S(ta rt) → R(enderingQueued) → E(nd)
  root.startRendering(3);
  CHECK(a.log == "SRESRESRE");
  CHECK(root.targetsUpdated == 3);
  // 帧事件捕获:timeSinceLastFrame 由调用方传入
  CHECK(a.lastTimeSinceLastFrame == 0.016f);
  // timeSinceLastEvent 由计算得出(非零)
  CHECK(a.lastTimeSinceLastEvent > 0.0f);

  // 退出监听器:第 2 帧 frameStarted 返回 false → 循环提前结束
  QuitAfterListener quit(2);
  Root root2;
  root2.listeners.push_back(&quit);
  root2.startRendering(5);
  CHECK(quit.log == "SRES");        // 第 1 帧完整 SRE,第 2 帧 S 后返回 false 中止
  CHECK(quit.mFrameCount == 2);     // frameStarted 被调用两次
  CHECK(root2.targetsUpdated == 1); // 只有第 1 帧更新了渲染目标

  return lab::report("12-3 事件与监听:渲染循环中的事件时序");
}

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

小结

  • renderOneFrame 三段式:_fireFrameStarted → _updateAllRenderTargets → _fireFrameEnded。
  • timeSinceLastFrame 由调用方传入;timeSinceLastEvent 用计时器在派发前现场重算。
  • 主循环 while(!mQueuedEnd) renderOneFrame(),任一环节 false 即 break。
  • 完整序列:frameStarted → 渲染目标更新 → frameRenderingQueued(缓冲交换前)→ frameEnded。

阅读导航:上一节:12.2 注册与派发顺序 · 下一节:13.1 内存分配器 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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