14.1 渲染目标管理
一帧不只是画一个窗口:影子贴图、反射、后处理往往先画到纹理,主窗口最后合成。这些目标有依赖关系——主窗口要用影子贴图,所以 RTT 必须先更新。OGRE 用 RenderTargetPriorityMap(按优先级排序的多重表)保证更新顺序,再由 Root::_updateAllRenderTargets 把「全部目标重画 + 统一换缓冲」串成一帧。这一节看这两层调度。
本章与站内既有内容的分工
1.3 讲过渲染目标的双表登记,这一节接上「按优先级表怎么被消费」;卷一 ogre-core 的 Root::renderOneFrame 只留入口,这里展开 _updateAllRenderTargets 内部的更新顺序与 swap 拆分。cg 三卷不涉及目标调度,此节是纯引擎资源管理。
按优先级更新:RenderSystem 侧
真正迭代 mPrioritisedRenderTargets 的是 RenderSystem::_updateAllRenderTargets。std::multimap 按键升序,键就是优先级,所以更新天然按优先级从小到大:
// OgreMain/src/OgreRenderSystem.cpp:RenderSystem::_updateAllRenderTargets(v14.6.3 源码摘录,已删减)
void RenderSystem::_updateAllRenderTargets(bool swapBuffers)
{
// Update all in order of priority
// This ensures render-to-texture targets get updated before render windows
for (auto& rt : mPrioritisedRenderTargets)
{
if (rt.second->isActive() && rt.second->isAutoUpdated())
rt.second->update(swapBuffers);
}
}
//-----------------------------------------------------------------------
void RenderSystem::_swapAllRenderTargetBuffers()
{
OgreProfile("_swapAllRenderTargetBuffers");
// Update all in order of priority
// This ensures render-to-texture targets get updated before render windows
for (auto& rt : mPrioritisedRenderTargets)
{
if (rt.second->isActive() && rt.second->isAutoUpdated())
rt.second->swapBuffers();
}
}
两个过滤条件缺一不可:
| 条件 | 含义 |
|---|---|
isActive() | 目标已被激活(窗口显示中 / RTT 在管线上) |
isAutoUpdated() | 目标参与自动帧循环,而非手动 update() |
swapBuffers 参数控制这次调用是否顺带换缓冲。把「重画」与「换缓冲」拆成两个入口,正是为了让 Root 能把所有目标的重画做完后再统一 swap——见下节。
Root 的一帧入口:先画再换
Root::_updateAllRenderTargets 是 renderOneFrame 的核心,它先调 mActiveRenderer->_updateAllRenderTargets(false)(只画不换),中间给应用 frameRenderingQueued 事件的机会,最后统一换缓冲:
// OgreMain/src/OgreRoot.cpp:Root::_updateAllRenderTargets(v14.6.3 源码摘录,已删减)
bool Root::_updateAllRenderTargets(void)
{
// update all targets but don't swap buffers
mActiveRenderer->_updateAllRenderTargets(false);
// give client app opportunity to use queued GPU time
bool ret = _fireFrameRenderingQueued();
// block for final swap
mActiveRenderer->_swapAllRenderTargetBuffers();
// This belongs here, as all render targets must be updated before events are
// triggered, otherwise targets could be mismatched. This could produce artifacts,
// for instance, with shadows.
for (const auto& m : getSceneManagers())
m.second->_handleLodEvents();
return ret;
}
注释点明了「事件必须等所有目标更新完」的原因:影子贴图若还在旧帧,主窗口用它会画面错位。_handleLodEvents 也在全部更新后统一处理 LOD 事件。帧与帧之间的时间统计由 clearEventTimes 复位——它清空 mEventTimes[FETT_*] 全部槽位,让下一帧的 timeSinceLastEvent 从零重新累计。
目标自身:update 与 updateImpl
单张目标怎么重画?RenderTarget::update(bool swap) 是个瘦包装:先 updateImpl() 真正渲染(_beginUpdate → _updateAutoUpdatedViewports → _endUpdate),再按需换缓冲:
// OgreMain/src/OgreRenderTarget.cpp:RenderTarget::update/updateImpl(v14.6.3 源码摘录,已删减)
void RenderTarget::updateImpl(void)
{
_beginUpdate();
_updateAutoUpdatedViewports(true);
_endUpdate();
}
//-----------------------------------------------------------------------
void RenderTarget::update(bool swap)
{
GpuEventScope profileScope(mName);
// call implementation
updateImpl();
if (swap)
{
// Swap buffers
swapBuffers();
}
}
_updateAutoUpdatedViewports(true) 逐个渲染自动更新的视口;swap 为 true 才 swapBuffers()。与之配套,RenderSystem::_beginFrame 是帧开始时的哨兵——没有选定视口就直接抛 ERR_INVALID_STATE,防止在非法状态下发起一帧。
Root 帧事件与退出路径
flowchart TD
A["Root::renderOneFrame"] --> B["同步监听器集合并派发 frameStarted"]
B --> C{"started 允许继续?"}
C -->|"false"| Stop["返回 false,调用方决定停止"]
C -->|"true"| D["按优先级更新 active 且 autoUpdated 的目标,暂不 swap"]
D --> E["同步监听器,派发 frameRenderingQueued 并保存结果"]
E --> F["交换符合条件的目标缓冲"]
F --> G["派发场景 LOD 事件"]
G --> H{"queued 允许继续?"}
H -->|"false"| Stop
H -->|"true"| I["同步监听器,派发 frameEnded 并保存结果"]
I --> J["释放临时缓冲,处理主线程任务"]
J --> K{"ended 允许继续?"}
K -->|"false"| Stop
K -->|"true"| L["返回 true"]
帧内有三个不同的完成点
目标调用 update(false) 完成的是本次场景更新和后端调用。Root 在全部符合条件的目标更新后派发 queued,再交换缓冲并派发 LOD。queued 返回 false 时,交换和 LOD 仍发生,ended 阶段会跳过。进入 ended 后,即使监听器返回 false,主线程任务泵仍运行。对读取帧轨迹很重要的一点是,GPU 是否执行完毕还要按具体后端的同步手段来判断。 Root 帧调度
· 主线程任务泵
用一组分层记录来验证。原生探针给三个回调、update 和 swap 记序号。场景样例额外记录入队候选、三角形数和像素。最后用 WorkQueue 的完成通知验证主线程处理点。这三份记录分别回答帧控制、场景绘制和资源提交的问题。单独看到一次 queued 回调,不能据此断定像素来自某个对象。 原生探针与场景样例 。
多目标的一帧从哪个视口开始
目标的优先级决定遍历顺序,视口还各有相机、矩形和开关。一个 Root 级回调围绕的是这次整帧的目标调度。某视口没有绘制时可以先分辨目标被跳过、相机不可用或对象被剔除。
固定两个不同优先级目标,分别改 active 与 autoUpdated,记录 update、queued、swap 和 ended。继续用帧探针核对关闭路径。
源码定位
OgreMain/src/OgreRenderSystem.cpp:_updateAllRenderTargets(257-266)、_swapAllRenderTargetBuffers(268-278)、_beginFrame(501-505)OgreMain/src/OgreRoot.cpp:Root::_updateAllRenderTargets(1121-1137 / 1139-1155)、clearEventTimes(1157-1162)OgreMain/src/OgreRenderTarget.cpp:updateImpl(117-122)、update(446-458)OgreMain/include/OgreRenderSystem.h:_updateAllRenderTargets声明(894)、_swapAllRenderTargetBuffers声明(897)、RenderTargetPriorityMap mPrioritisedRenderTargets(1142)
上游引用固定到 OGRE v14.6.3 源码 。
可运行产物:C++ 最小验证
下面复现优先级顺序、active/autoUpdated 过滤与「先画后换」。它与 src/14-1-render-target-manager.cpp 逐字节一致:
// file: src/14-1-render-target-manager.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/14-1-render-target-manager.cpp -o bin/14-1-render-target-manager && ./bin/14-1-render-target-manager
//
// 复现渲染目标按优先级更新的调度(对应 OgreRenderSystem.cpp 257-278 与 OgreRoot.cpp 1121-1137):
// mPrioritisedRenderTargets 是按优先级排序的多重表;_updateAllRenderTargets 只更新 active 且 autoUpdated 的目标;
// update(swap) = updateImpl + 可选 swapBuffers;Root 先 update(false) 全部目标再统一 _swapAllRenderTargetBuffers。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"
#include <cstdint>
#include <map>
#include <string>
namespace ogre_repro {
int gOrder = 0; // 全局更新序号,验证优先级顺序
class RenderTargetRepro {
public:
RenderTargetRepro(const std::string& name, uint8_t priority)
: mName(name), mPriority(priority) {}
const std::string& getName() const { return mName; }
uint8_t getPriority() const { return mPriority; }
bool isActive() const { return mActive; }
bool isAutoUpdated() const { return mAutoUpdated; }
void setActive(bool a) { mActive = a; }
void setAutoUpdated(bool a) { mAutoUpdated = a; }
int mUpdateCount = 0;
int mSwapCount = 0;
int mLastOrder = 0;
// 对应 RenderTarget::update(bool swap)
void update(bool swap) {
++mUpdateCount;
mLastOrder = ++gOrder;
if (swap) ++mSwapCount;
}
void swapBuffers() { ++mSwapCount; }
private:
std::string mName;
uint8_t mPriority;
bool mActive = true;
bool mAutoUpdated = true;
};
class RenderSystemRepro {
public:
void addRenderTarget(RenderTargetRepro* rt) { mPrioritised.emplace(rt->getPriority(), rt); }
// 对应 RenderSystem::_updateAllRenderTargets:按优先级顺序,过滤 active + autoUpdated
void _updateAllRenderTargets(bool swap) {
for (auto& it : mPrioritised) {
if (it.second->isActive() && it.second->isAutoUpdated())
it.second->update(swap);
}
}
// 对应 RenderSystem::_swapAllRenderTargetBuffers
void _swapAllRenderTargetBuffers() {
for (auto& it : mPrioritised) {
if (it.second->isActive() && it.second->isAutoUpdated())
it.second->swapBuffers();
}
}
private:
std::multimap<uint8_t, RenderTargetRepro*> mPrioritised; // 对应 RenderTargetPriorityMap
};
class RootRepro {
public:
void setActiveRenderer(RenderSystemRepro* rs) { mRs = rs; }
// 对应 Root::_updateAllRenderTargets:先全部 update(false),再统一 swap
void _updateAllRenderTargets() {
mRs->_updateAllRenderTargets(false);
mRs->_swapAllRenderTargetBuffers();
}
private:
RenderSystemRepro* mRs = nullptr;
};
} // namespace ogre_repro
int main() {
using namespace ogre_repro;
// 优先级:RTT(0) < Overlay(1) < MainWindow(2),RTT 先更新
RenderTargetRepro rtt("ShadowRTT", 0);
RenderTargetRepro overlay("Overlay", 1);
RenderTargetRepro mainWin("MainWindow", 2);
RenderSystemRepro rs;
rs.addRenderTarget(&mainWin);
rs.addRenderTarget(&rtt);
rs.addRenderTarget(&overlay);
// 单次 update(true):全部目标 update + swap
rs._updateAllRenderTargets(true);
CHECK_EQ(rtt.mUpdateCount, 1);
CHECK_EQ(overlay.mUpdateCount, 1);
CHECK_EQ(mainWin.mUpdateCount, 1);
CHECK_EQ(rtt.mSwapCount, 1);
CHECK_EQ(mainWin.mSwapCount, 1);
CHECK(rtt.mLastOrder < overlay.mLastOrder);
CHECK(overlay.mLastOrder < mainWin.mLastOrder);
// 不活跃目标被跳过
rtt.setActive(false);
rs._updateAllRenderTargets(true);
CHECK_EQ(rtt.mUpdateCount, 1); // 未再更新
CHECK_EQ(overlay.mUpdateCount, 2);
CHECK_EQ(mainWin.mUpdateCount, 2);
// 非 autoUpdated 目标被跳过
overlay.setAutoUpdated(false);
rs._updateAllRenderTargets(true);
CHECK_EQ(overlay.mUpdateCount, 2); // 未再更新
CHECK_EQ(mainWin.mUpdateCount, 3);
// Root 入口:update(false) 全部目标后统一 swap
rtt.setActive(true);
overlay.setAutoUpdated(true);
RootRepro root;
root.setActiveRenderer(&rs);
root._updateAllRenderTargets();
CHECK_EQ(rtt.mUpdateCount, 2);
CHECK_EQ(overlay.mUpdateCount, 3);
CHECK_EQ(mainWin.mUpdateCount, 4);
CHECK_EQ(rtt.mSwapCount, 2);
CHECK_EQ(overlay.mSwapCount, 3);
CHECK_EQ(mainWin.mSwapCount, 4);
return lab::report("14-1 渲染目标管理");
}
本机实测(Apple clang 16,clang++ -std=c++20):编译通过(-Wall 零警告),断言 18/18 通过。
小结
mPrioritisedRenderTargets是多重表,迭代顺序即优先级升序,RTT 先于窗口更新。_updateAllRenderTargets只更新isActive()且isAutoUpdated()的目标。update(bool swap)=updateImpl()重画 + 可选swapBuffers(),把重画与换缓冲拆开。Root::_updateAllRenderTargets先update(false)全部目标,给应用事件机会,最后统一 swap。clearEventTimes复位帧间隔统计;_beginFrame无活动视口即抛异常。
阅读导航:上一节:13.3 深度缓冲管理 · 下一节:14.2 WorkQueue 与后台加载 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。