15.3 完整一帧渲染
15.1 与 15.2 把场景、相机、视口都装配好了。最后一节把这些捏成一帧:Root::renderOneFrame 的帧循环状态机、FrameListener 的三个回调点、以及注册/移除的延迟同步。这是卷三收尾——从对象进入场景到缓冲翻转的完整路径。
本章与站内既有内容的分工
本卷前面各章是「场景里有什么」;这一节是「一帧怎么转」。它与卷二第 5 章的渲染队列、3.x 的 GPU 程序共同构成渲染主循环:场景内容经剔除、排序、提交渲染命令,帧事件在命令提交前后插入用户逻辑。
FrameEvent 与 FrameListener:帧回调的契约
帧事件携带两个时间量:timeSinceLastEvent(距上次任意帧事件)与 timeSinceLastFrame(距上次同类型事件,即完整一帧):
// OgreMain/include/OgreFrameListener.h:FrameEvent(v14.6.3 源码摘录,已删减)
struct FrameEvent
{
/** Elapsed time in seconds since the last event.
This gives you time between frame start & frame end,
and between frame end and next frame start.
@note This may not be the elapsed time but the average
elapsed time between recently fired events.
*/
Real timeSinceLastEvent;
/** Elapsed time in seconds since the last event of the same type,
i.e. time for a complete frame.
@note This may not be the elapsed time but the average
elapsed time between recently fired events of the same type.
*/
Real timeSinceLastFrame;
};
FrameListener 是「适配器」式的接口(不是纯抽象类)——三个回调默认都返回 true,使用者只覆写关心的:
// OgreMain/include/OgreFrameListener.h:FrameListener(v14.6.3 源码摘录,已删减)
class _OgreExport FrameListener
{
public:
/** Called when a frame is about to begin rendering.
This event happens before any render targets have begun updating.
@return
True to go ahead, false to abort rendering and drop
out of the rendering loop.
*/
virtual bool frameStarted(const FrameEvent& evt)
{ (void)evt; return true; }
/** Called after all render targets have had their rendering commands
issued, but before render windows have been asked to flip their
buffers over.
The usefulness of this event comes from the fact that rendering
commands are queued for the GPU to process. These can take a little
while to finish, and so while that is happening the CPU can be doing
useful things. Once the request to 'flip buffers' happens, the thread
requesting it will block until the GPU is ready, which can waste CPU
cycles. Therefore, it is often a good idea to use this callback to
perform per-frame processing. Of course because the frame's rendering
commands have already been issued, any changes you make will only
take effect from the next frame, but in most cases that's not noticeable.
@return
True to continue rendering, false to drop out of the rendering loop.
*/
virtual bool frameRenderingQueued(const FrameEvent& evt)
{ (void)evt; return true; }
/** Called just after a frame has been rendered.
This event happens after all render targets have been fully updated
and the buffers switched.
@return
True to continue with the next frame, false to drop
out of the rendering loop.
*/
virtual bool frameEnded(const FrameEvent& evt)
{ (void)evt; return true; }
virtual ~FrameListener() {}
};
三个回调点的语义差异:
frameStarted:任何渲染目标更新之前。frameRenderingQueued:所有目标的渲染命令已提交、缓冲尚未翻转——GPU 还在处理上一条命令时 CPU 干别的活。frameEnded:缓冲已翻转,本帧真正结束。
注意帧事件是每帧一次、对所有渲染目标一次(不是每目标一次)。
注册/移除的延迟同步
addFrameListener 与 removeFrameListener 不直接改活动集合 mFrameListeners,而是写入挂起集合 mAddedFrameListeners/mRemovedFrameListeners:
// OgreMain/src/OgreRoot.cpp:Root::addFrameListener / removeFrameListener / _syncAddedRemovedFrameListeners(v14.6.3 源码摘录,已删减)
void Root::addFrameListener(FrameListener* newListener)
{
mRemovedFrameListeners.erase(newListener);
mAddedFrameListeners.insert(newListener);
}
//-----------------------------------------------------------------------
void Root::removeFrameListener(FrameListener* oldListener)
{
mAddedFrameListeners.erase(oldListener);
mRemovedFrameListeners.insert(oldListener);
}
//-----------------------------------------------------------------------
void Root::_syncAddedRemovedFrameListeners()
{
for (auto& l : mRemovedFrameListeners)
mFrameListeners.erase(l);
mRemovedFrameListeners.clear();
for (auto& l : mAddedFrameListeners)
mFrameListeners.insert(l);
mAddedFrameListeners.clear();
}
为什么延迟?帧回调期间遍历 mFrameListeners,若监听器在回调里直接增删,迭代器就失效。所以变更先入挂起集合,在每次 _fireFrameStarted/_fireFrameRenderingQueued/_fireFrameEnded 开头统一 _syncAddedRemovedFrameListeners() 生效。这也意味着:一个监听器若在 frameStarted 里 removeFrameListener 自己,当前回调执行完后,本帧后续的 queued 和 ended 就会跳过该监听器。
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();
}
各阶段返回 false 时,已执行的工作仍然有效。
_fireFrameStarted:同步监听器 → 逐个调用frameStarted,任一返回 false 则整帧放弃。_updateAllRenderTargets:遍历所有渲染目标(如窗口和渲染纹理),每个目标执行各自的更新(场景剔除、队列排序、命令提交)。_fireFrameEnded:同步监听器 → 逐个调用frameEnded,任一返回 false 则返回 false(但本帧已渲染完)。
_fireFrameEnded 在返回前还会释放本帧临时缓冲拷贝、处理主线程队列任务——这些是帧尾收尾工作:
// OgreMain/src/OgreRoot.cpp:Root::_fireFrameEnded(v14.6.3 源码摘录,已删减)
bool Root::_fireFrameEnded(FrameEvent& evt)
{
_syncAddedRemovedFrameListeners();
// Tell all listeners
bool ret = true;
for (auto *l : mFrameListeners)
{
if(mRemovedFrameListeners.find(l) != mRemovedFrameListeners.end())
continue;
if (!l->frameEnded(evt))
{
ret = false;
break;
}
}
// Tell buffer manager to free temp buffers used this frame
if (HardwareBufferManager::getSingletonPtr())
HardwareBufferManager::getSingleton()._releaseBufferCopies();
// Tell the queue to process responses
mWorkQueue->processMainThreadTasks();
return ret;
}
注意循环里有个额外的 mRemovedFrameListeners.find(l) 保护:同一帧内某监听器在 frameStarted 里移除另一个监听器,后者本帧就不该再被回调。
应用层的主循环通常长这样:
while (root.renderOneFrame()) { /* 用户每帧逻辑可挂在 FrameListener 里 */ }
一旦某回调返回 false(例如收到退出信号),循环退出。
帧中段先更新启用自动更新的活动目标,再派发 frameRenderingQueued,随后交换缓冲并处理 LOD 事件。queued 返回 false 时依然执行交换和 LOD,随后跳过 frameEnded。如果 frameEnded 自身返回 false,Root 仍会释放临时缓冲并处理主线程任务。完整调用顺序见卷二 14.1
。
对每个自动更新的视口,RenderTarget::update 经过 Viewport::update 调用 Camera::_renderScene。相机把视口交给 SceneManager::_renderScene,场景管理器收集可见对象、填充并消费 RenderQueue,应用各 Pass 的状态后调用后端绘制。RTSS 参与材质方案和程序生成,后处理目标的组织见卷二第 6 章
。
场景与渲染对象的所有权和数据流
flowchart TB
Root["Root"]
Root -->|"管理枚举器"| Enum["SceneManagerEnumerator"]
Enum -->|"创建并登记"| Scene["SceneManager"]
Root -.->|"选定 active 后端"| RS["RenderSystem 插件"]
Root -->|"持有资源系统管理器"| Managers["资源管理器"]
Managers -->|"管理资源"| Mesh["Mesh 与 SubMesh"]
Managers -->|"管理资源"| Mat["Material → Technique → Pass"]
Scene -->|"管理场景树"| Node["SceneNode"]
Scene -->|"登记场景对象"| Entity["Entity 与 SubEntity"]
Scene -->|"创建相机"| Camera["Camera"]
Node -.->|"附着指针"| Entity
Node -.->|"附着指针"| Camera
Entity -.->|"引用资源"| Mesh
Entity -.->|"材质选择"| Mat
RS -->|"登记渲染目标"| Target["RenderTarget"]
Target -->|"拥有视口"| VP["Viewport"]
VP -.->|"引用并驱动"| Camera
Camera -.->|"驱动可见性与渲染"| Scene
Scene -->|"组织本帧队列"| Queue["RenderQueue"]
Entity -.->|"提交可见 Renderable"| Queue
Queue -.->|"SceneManager 应用 Pass 并发起绘制"| RS
两个实体怎样变成一帧像素
原生样例把同一 Mesh 交给两个 Entity,各自挂到不同 SceneNode。资源中保留的几何、索引和材质可以共享,节点位置和每个实体的场景状态独立。由相机和视口确定本次可见范围后,SceneManager 遍历候选,逐步进入队列与后端。下图把候选收集和入队分开。节点级过滤会提前剪掉部分候选。已进入 processVisibleObject 的对象,还要经过阴影过滤、相机通知与对象可见性检查。 场景渲染入口
· 候选处理
flowchart TD
A["Viewport 和 Camera 启动场景渲染"] --> B["SceneManager 更新场景并遍历节点"]
B --> C{"节点通过当前遍历的可见性检查?"}
C -->|"否"| X["跳过该节点分支"]
C -->|"是"| D["RenderQueue 处理候选 MovableObject"]
D --> E{"阴影条件与对象可见性允许?"}
E -->|"否"| Y["不提交绘制项,按条件合并接收范围"]
E -->|"是"| F["Entity 选取当前子实体和 LOD"]
F --> G["SubEntity 入队,关联 Technique 和 Pass"]
G --> H["SceneManager 消费队列,后端绘制"]
H --> I["视口统计和目标像素可观察"]
保持材质、资源和目标不变,仅把相机平移到两个实体的视锥外。可见帧有两个队列候选、四个三角形和非背景像素。移出后这三项都为零。该对照排除了通过隐藏对象或销毁资源得到同一画面变化的歧义。队列消费的调用顺序见卷二 5.3 。 原生场景样例 。
从对象身份复原一帧
将 Entity 名称、节点位置、SubEntity、材质方案、组和索引范围串到同一份帧记录。之后由目标像素证实绘制。多视口案例要把相机与视口也纳入记录,不能把一次入队当成全局状态。
主链以原生场景为基准,通用时序引用卷二 14.1,Pass 与后端提交细节引用卷二 5.3。阴影、后处理和覆盖层作为后续分支接入同一观察方法。
源码定位
OgreMain/include/OgreFrameListener.h:FrameEvent(44-61)、FrameListener(79-132)OgreMain/src/OgreRoot.cpp:addFrameListener(572-576)、removeFrameListener(578-582)、_syncAddedRemovedFrameListeners(584-593)、_fireFrameStarted(595-611)、_fireFrameRenderingQueued(613-630)、_fireFrameEnded(632-660)、renderOneFrame(754-763)
上游引用固定到 OGRE v14.6.3 源码 。
可运行产物:C++ 最小验证
下面用纯 C++ 验证三个回调点、交换缓冲、帧尾清理和监听器延迟同步。它与 src/15-3-full-frame-render.cpp 逐字节一致:
// file: src/15-3-full-frame-render.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/15-3-full-frame-render.cpp -o bin/15-3-full-frame-render && ./bin/15-3-full-frame-render
//
// 复现完整一帧渲染的帧循环状态机(对应 OgreMain/src/OgreRoot.cpp 754-763 的
// Root::renderOneFrame、572-593 的 addFrameListener / removeFrameListener /
// _syncAddedRemovedFrameListeners、595-660 的 _fireFrameStarted/_fireFrameEnded,
// 以及 OgreMain/include/OgreFrameListener.h 44-61、79-132 的 FrameEvent / FrameListener):
// 帧循环:_fireFrameStarted -> _updateAllRenderTargets -> _fireFrameEnded,
// 任一步返回 false 即中止;
// FrameListener 的注册/移除经 mAdded / mRemoved 集合延迟同步;
// frameStarted / frameRenderingQueued / frameEnded 任一返回 false 中止渲染;
// FrameEvent 携带 timeSinceLastFrame / timeSinceLastEvent。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"
#include <cstdint>
#include <set>
#include <string>
#include <vector>
namespace ogre_repro {
using Real = float;
// 对应 OgreFrameListener.h 44-61:FrameEvent。
struct FrameEvent {
Real timeSinceLastEvent = 0;
Real timeSinceLastFrame = 0;
};
// 对应 OgreFrameListener.h 79-132:帧监听器。
class FrameListener {
public:
virtual ~FrameListener() {}
virtual bool frameStarted(const FrameEvent& evt) { (void)evt; return true; }
virtual bool frameRenderingQueued(const FrameEvent& evt) { (void)evt; return true; }
virtual bool frameEnded(const FrameEvent& evt) { (void)evt; return true; }
};
// 记录回调顺序与次数的监听器。
class RecordingListener : public FrameListener {
public:
bool frameStarted(const FrameEvent& evt) override {
mStartCount++;
mOrder.push_back("started");
return mAbortStart ? false : true;
}
bool frameRenderingQueued(const FrameEvent& evt) override {
mQueuedCount++;
mOrder.push_back("queued");
return !mAbortQueued;
}
bool frameEnded(const FrameEvent& evt) override {
mEndCount++;
mOrder.push_back("ended");
return mAbortEnd ? false : true;
}
bool mAbortStart = false;
bool mAbortEnd = false;
bool mAbortQueued = false;
int mStartCount = 0;
int mQueuedCount = 0;
int mEndCount = 0;
std::vector<std::string> mOrder;
};
// 对应 Root 的帧循环(OgreRoot.cpp 754-763)。
class Renderer {
public:
// 对应 Root::addFrameListener(572-576)。
void addFrameListener(FrameListener* l) {
mRemovedFrameListeners.erase(l);
mAddedFrameListeners.insert(l);
}
// 对应 Root::removeFrameListener(578-582)。
void removeFrameListener(FrameListener* l) {
mAddedFrameListeners.erase(l);
mRemovedFrameListeners.insert(l);
}
// 对应 Root::_syncAddedRemovedFrameListeners(584-593)。
void sync() {
for (auto* l : mRemovedFrameListeners) mFrameListeners.erase(l);
mRemovedFrameListeners.clear();
for (auto* l : mAddedFrameListeners) mFrameListeners.insert(l);
mAddedFrameListeners.clear();
}
// 对应 Root::_fireFrameStarted(595-611)。
bool fireFrameStarted(FrameEvent& evt) {
sync();
for (auto* l : mFrameListeners) {
if (mRemovedFrameListeners.count(l)) continue;
if (!l->frameStarted(evt)) return false;
}
return true;
}
// 对应 Root::_fireFrameRenderingQueued(613-630)。
bool fireFrameRenderingQueued(FrameEvent& evt) {
++mNextFrame;
sync();
for (auto* l : mFrameListeners) {
if (mRemovedFrameListeners.count(l)) continue;
if (!l->frameRenderingQueued(evt)) return false;
}
return true;
}
// 对应 Root::_fireFrameEnded(632-660)。
bool fireFrameEnded(FrameEvent& evt) {
sync();
bool result = true;
for (auto* l : mFrameListeners) {
if (mRemovedFrameListeners.count(l)) continue;
if (!l->frameEnded(evt)) {
result = false;
break;
}
}
++mMainThreadPumps;
return result;
}
bool updateAllRenderTargets(FrameEvent& evt) {
++mUpdates;
const bool result = fireFrameRenderingQueued(evt);
++mSwaps;
++mLodDispatches;
return result;
}
// 对应 Root::renderOneFrame(754-763)。
bool renderOneFrame(Real timeSinceLastFrame) {
FrameEvent evt;
evt.timeSinceLastFrame = timeSinceLastFrame;
evt.timeSinceLastEvent = timeSinceLastFrame;
if (!fireFrameStarted(evt)) return false;
if (!updateAllRenderTargets(evt)) return false;
return fireFrameEnded(evt);
}
int mUpdates = 0;
int mSwaps = 0;
int mLodDispatches = 0;
int mMainThreadPumps = 0;
unsigned long mNextFrame = 0;
std::set<FrameListener*> mFrameListeners;
std::set<FrameListener*> mAddedFrameListeners;
std::set<FrameListener*> mRemovedFrameListeners;
};
} // namespace ogre_repro
int main() {
using namespace ogre_repro;
Renderer root;
RecordingListener l1;
RecordingListener l2;
// 注册:同步前不在活动集合,同步后生效
root.addFrameListener(&l1);
root.addFrameListener(&l2);
CHECK_EQ(root.mFrameListeners.size(), size_t(0));
root.sync();
CHECK_EQ(root.mFrameListeners.size(), size_t(2));
CHECK(root.renderOneFrame(0.016f));
CHECK_EQ(l1.mStartCount, 1);
CHECK_EQ(l1.mQueuedCount, 1);
CHECK_EQ(l1.mEndCount, 1);
CHECK((l1.mOrder == std::vector<std::string>{"started", "queued", "ended"}));
CHECK_EQ(root.mNextFrame, 1ul);
// 移除:延迟到下一次同步生效
root.removeFrameListener(&l1);
CHECK_EQ(root.mFrameListeners.size(), size_t(2)); // 尚未同步
root.renderOneFrame(0.016f);
CHECK_EQ(l1.mStartCount, 1); // 已不再被回调
CHECK_EQ(l2.mStartCount, 2);
CHECK_EQ(root.mFrameListeners.size(), size_t(1));
// frameStarted 返回 false:一帧中止,不再更新目标与 ended
RecordingListener abortStart;
root.addFrameListener(&abortStart);
abortStart.mAbortStart = true;
root.sync();
CHECK(!root.renderOneFrame(0.016f));
CHECK_EQ(abortStart.mStartCount, 1);
CHECK_EQ(abortStart.mEndCount, 0);
abortStart.mAbortStart = false;
// frameEnded 返回 false:一帧中止
RecordingListener abortEnd;
root.addFrameListener(&abortEnd);
abortEnd.mAbortEnd = true;
root.sync();
CHECK(!root.renderOneFrame(0.016f));
CHECK_EQ(abortEnd.mEndCount, 1);
CHECK(abortEnd.mOrder.back() == "ended");
CHECK_EQ(root.mMainThreadPumps, 3);
root.removeFrameListener(&abortEnd);
RecordingListener abortQueued;
abortQueued.mAbortQueued = true;
root.addFrameListener(&abortQueued);
CHECK(!root.renderOneFrame(0.016f));
CHECK_EQ(abortQueued.mQueuedCount, 1);
CHECK_EQ(abortQueued.mEndCount, 0);
CHECK_EQ(root.mUpdates, 4);
CHECK_EQ(root.mSwaps, 4);
CHECK_EQ(root.mLodDispatches, 4);
CHECK_EQ(root.mMainThreadPumps, 3);
// FrameEvent 携带时间:帧循环透传 timeSinceLastFrame
CHECK(root.mFrameListeners.find(&l2) != root.mFrameListeners.end());
return lab::report("15-3 完整一帧渲染");
}
本机实测(Apple clang 16,clang++ -std=c++20):编译通过(-Wall 零警告),覆盖三种退出分支,运行命令见示例头部。
小结
renderOneFrame是三步状态机:_fireFrameStarted → _updateAllRenderTargets → _fireFrameEnded,任一步返回 false 中止。FrameListener的三个回调点:帧开始前、命令提交后缓冲翻转前、缓冲翻转后。- 注册/移除进挂起集合,每次
_fire*开头统一同步,避免回调期间改集合导致迭代器失效。 - 任一
frameStarted/frameRenderingQueued/frameEnded返回 false 都让renderOneFrame返回 false。 _fireFrameEnded帧尾还负责释放临时缓冲、处理主线程队列任务。
阅读导航:上一节:15.2 相机视口装配 · 下一节:卷末目录 。
继续阅读 下一卷目录 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。