《OGRE 3D 渲染引擎原理与架构》14.1 渲染目标管理

一帧里所有渲染目标按优先级调度:RenderSystem::_updateAllRenderTargets 只更新 active 且 autoUpdated 的目标,update(swap) 先重画再按需换缓冲;Root::_updateAllRenderTargets 先全部 update(false) 再统一 swap。lab 复现优先级顺序与过滤。

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。继续用帧探针核对关闭路径。

源码定位

上游引用固定到 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 与后台加载 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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