《OGRE 3D 渲染引擎原理与架构》5.1 渲染队列 RenderQueue

RenderQueue 是场景提交与后端绘制之间的缓冲:RenderQueueGroupID 把绘制分成 0-100 的组,RenderQueue 用 unique_ptr 数组按需懒创建组,addRenderable 把默认组的透明物体重定向到 RENDER_QUEUE_TRANSPARENTS。lab 复现组号、懒创建、重定向与 clear 的帧间复用。

5.1 渲染队列 RenderQueue

4.3 讲了 Pass 状态如何落到 RenderSystem。但一帧里有成百上千个物体,谁先画谁后画?直接遍历场景图逐个提交会产生大量状态切换。OGRE 在中间插一层 RenderQueue:SceneManager 每帧先把所有可见物体按组塞进队列,渲染时才按组、按排序策略逐个取出来画。这一节看队列的骨架:组号、组的懒创建、以及透明物体的自动重定向。

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

helio 四卷渲染器用「渲染图 + 提交命令」管理绘制顺序;卷一 ogre-core 没展开提交细节。这里看 OGRE 的分层提交:SceneManager 收集 → RenderQueue 按 RenderQueueGroupID 分桶 → 渲染时按组消费。5.2 的排序和 5.3 的 QueuedRenderable 都在这个容器之上工作。

组号:RenderQueueGroupID

先把「背景、主场景、透明、叠加层」画在哪道顺序编成一组常量。枚举注释说明它其实可以是任意 uint8:

// OgreMain/include/OgreRenderQueue.h:RenderQueueGroupID(v14.6.3 源码摘录,已删减)
    enum RenderQueueGroupID
    {
        /// Use this queue for objects which must be rendered first e.g. backgrounds
        RENDER_QUEUE_BACKGROUND = 0,
        /// First queue (after backgrounds), used for skyboxes if rendered first
        RENDER_QUEUE_SKIES_EARLY = 5,
        ...
        /// The default render queue
        RENDER_QUEUE_MAIN = 50,
        ...
        /// Penultimate queue(before overlays)
        RENDER_QUEUE_TRANSPARENTS = 95,
        /// Use this queue for objects which must be rendered last e.g. overlays
        RENDER_QUEUE_OVERLAY = 100, 
        /// Final possible render queue, don't exceed this
        RENDER_QUEUE_MAX = 105,
        RENDER_QUEUE_COUNT
    };

关键值:背景 0、默认主场景 50、透明 95、叠加 100、上限 105。RENDER_QUEUE_COUNT 紧跟在 MAX 之后,正好等于数组长度。枚举只是约定——方法参数是 uint8,允许你插进任意中间值。

组容器:unique_ptr 数组

RenderQueue 内部用固定大小的 unique_ptr 数组装组,长度是 RENDER_QUEUE_COUNT:

// OgreMain/include/OgreRenderQueue.h:RenderQueueGroupMap(v14.6.3 源码摘录,已删减)
        typedef std::unique_ptr<RenderQueueGroup> RenderQueueGroupMap[RENDER_QUEUE_COUNT];
        ...
        RenderQueueGroupMap mGroups;
// OgreMain/src/OgreRenderQueue.cpp:getQueueGroup(v14.6.3 源码摘录,已删减)
    RenderQueueGroup* RenderQueue::getQueueGroup(uint8 groupID)
    {
        if (!mGroups[groupID])
        {
            // Insert new
            mGroups[groupID] = std::make_unique<RenderQueueGroup>(mSplitPassesByLightingType, mSplitNoShadowPasses,
                                                        mShadowCastersCannotBeReceivers);
        }

        return mGroups[groupID].get();

    }

懒创建:数组初始全空,第一次访问某组号时才 make_unique 造出来。所以一帧里没用到 RENDER_QUEUE_OVERLAY,数组里那个槽就是空指针。组对象还接收三个阴影/光照分裂开关(mSplitPassesByLightingType 等),决定组内是否按光照类型拆开。

入队:addRenderable

入队是核心入口,三个重载逐级补默认值。最完整的版本做三件事:解析/兜底材质、允许监听器改写或拒绝、透明重定向:

// OgreMain/src/OgreRenderQueue.cpp:addRenderable(v14.6.3 源码摘录,已删减)
    void RenderQueue::addRenderable(Renderable* pRend, uint8 groupID, ushort priority)
    {
        Technique* pTech;

        // make sure supported techniques are populated
        if (auto mat = pRend->getMaterial())
            mat->prepare();

        // Check material & technique supplied (the former since the default implementation
        // of getTechnique is based on it for backwards compatibility
        if(!pRend->getMaterial() || !pRend->getTechnique())
        {
            // Use default base white, with lighting only if vertices has normals
            RenderOperation op;
            pRend->getRenderOperation(op);
            bool useLighting = (NULL != op.vertexData->vertexDeclaration->findElementBySemantic(VES_NORMAL));
            MaterialPtr defaultMat = MaterialManager::getSingleton().getDefaultMaterial(useLighting);
            defaultMat->prepare();
            pTech = defaultMat->getBestTechnique();
        }
        else
            pTech = pRend->getTechnique();

        if (mRenderableListener)
        {
            // Allow listener to override technique and to abort
            if (!mRenderableListener->renderableQueued(pRend, groupID, priority, &pTech, this))
                return; // rejected
        }

        // tell material it's been used
        pTech->getParent()->touch();

        if(groupID == mDefaultQueueGroup && onTransparentQueue(pTech))
            groupID = RENDER_QUEUE_TRANSPARENTS;

        // Find group
        RenderQueueGroup* pGroup = getQueueGroup(groupID);
        pGroup->addRenderable(pRend, pTech, priority);

    }

几个关键点:

  • 材质兜底:没有材质/Technique 的物体用「默认材质」——有法线就开光照,没有就关。
  • 监听器钩子:renderableQueued 可以替换 Technique 甚至拒绝入队(返回 false),是低层材质覆盖的入口。
  • 透明重定向:groupID == mDefaultQueueGroup && onTransparentQueue(pTech) 时改入 RENDER_QUEUE_TRANSPARENTS。注意只在「默认组」触发——你显式指定组 100 的透明物体不会被乱改。

另外两个重载只是补默认值:

// OgreMain/src/OgreRenderQueue.cpp:addRenderable 重载(v14.6.3 源码摘录,已删减)
    void RenderQueue::addRenderable(Renderable* pRend, uint8 groupID)
    {
        addRenderable(pRend, groupID, mDefaultRenderablePriority);
    }
    void RenderQueue::addRenderable(Renderable* pRend)
    {
        addRenderable(pRend, mDefaultQueueGroup, mDefaultRenderablePriority);
    }

清空:clear 的帧间复用

每帧结束要清空,但 OGRE 故意不销毁组结构——帧间同一批组大概率还会再用:

// OgreMain/src/OgreRenderQueue.cpp:clear(v14.6.3 源码摘录,已删减)
    void RenderQueue::clear(bool destroyPassMaps)
    {
        // Note: We clear dirty passes from all RenderQueues in all 
        // SceneManagers, because the following recalculation of pass hashes
        // also considers all RenderQueues and could become inconsistent, otherwise.
        for (auto p : SceneManagerEnumerator::getSingleton().getSceneManagers())
        {
            RenderQueue* queue = p.second->getRenderQueue();

            for (auto & g : queue->mGroups)
            {
                if(g)
                    g->clear(destroyPassMaps);
            }
        }

        // Now trigger the pending pass updates
        Pass::processPendingPassUpdates();

        // NB this leaves the items present (but empty)
        // We're assuming that frame-by-frame, the same groups are likely to 
        //  be used, so no point destroying the vectors and incurring the overhead
        //  that would cause, let them be destroyed in the destructor.
    }

clear 遍历所有 SceneManager 的队列清空(因为 Pass hash 重算可能涉及所有队列),然后触发 processPendingPassUpdates 处理 4.2 的脏 hash。注释点明设计意图:组对象留着,下一帧直接复用,避免反复分配销毁的开销。

从可见对象到绘制队列

flowchart TD
  A["场景管理器发现可见 MovableObject"] --> B["对象提交 Renderable"]
  B --> C["选择材质 Technique"]
  C --> D["按 queue group 和 priority 分桶"]
  D --> E{"透明性与排序配置"}
  E -->|"不透明路径"| F["按 Pass 分组"]
  E -->|"距离排序路径"| G["按相机距离排序"]
  F --> H["应用 Pass,提交 RenderOperation"]
  G --> H

源码定位

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

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

下面复现组号、懒创建、透明重定向与 clear 的帧间复用。它与 src/05-1-render-queue.cpp 逐字节一致:

// file: src/05-1-render-queue.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/05-1-render-queue.cpp -o bin/05-1-render-queue && ./bin/05-1-render-queue
//
// 复现 RenderQueue 与队列组(对应 OgreRenderQueue.h 52-78/98/134、OgreRenderQueue.cpp 79-189):
//   RenderQueueGroupID 定义 0-100 的组号;RenderQueue 用 unique_ptr<RenderQueueGroup>[RENDER_QUEUE_COUNT] 数组保存组;
//   getQueueGroup 按需懒创建;addRenderable 把默认组的透明物体重定向到 RENDER_QUEUE_TRANSPARENTS;
//   clear 清空组内物品但保留组结构(帧间复用)。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <memory>
#include <vector>

namespace ogre_repro {

enum RenderQueueGroupID {
  RENDER_QUEUE_BACKGROUND = 0,
  RENDER_QUEUE_SKIES_EARLY = 5,
  RENDER_QUEUE_1 = 10,
  RENDER_QUEUE_2 = 20,
  RENDER_QUEUE_WORLD_GEOMETRY_1 = 25,
  RENDER_QUEUE_3 = 30,
  RENDER_QUEUE_4 = 40,
  RENDER_QUEUE_MAIN = 50,
  RENDER_QUEUE_6 = 60,
  RENDER_QUEUE_7 = 70,
  RENDER_QUEUE_WORLD_GEOMETRY_2 = 75,
  RENDER_QUEUE_8 = 80,
  RENDER_QUEUE_SKIES_LATE = 90,
  RENDER_QUEUE_TRANSPARENTS = 95,
  RENDER_QUEUE_OVERLAY = 100,
  RENDER_QUEUE_MAX = 105,
  RENDER_QUEUE_COUNT
};

// 最小 Renderable:只携带是否透明(用于默认组重定向)
struct Renderable {
  int id;
  bool transparent;
};

// 对应 RenderQueueGroup:本 lab 只统计组内物品数量
class RenderQueueGroup {
 public:
  void addRenderable(Renderable* r, bool transparent) {
    mItems.push_back(r);
    if (transparent) mTransparentCount++;
  }
  size_t getNumRenderables() const { return mItems.size(); }
  size_t getNumTransparent() const { return mTransparentCount; }
  void clear() {
    mItems.clear();
    mTransparentCount = 0;
  }

 private:
  std::vector<Renderable*> mItems;
  size_t mTransparentCount = 0;
};

// 对应 RenderQueue:组数组 + 默认组 + 默认优先级(OgreRenderQueue.h 134-138)
class RenderQueue {
 public:
  using RenderQueueGroupMap = std::unique_ptr<RenderQueueGroup>[RENDER_QUEUE_COUNT];

  RenderQueue() : mDefaultQueueGroup(RENDER_QUEUE_MAIN), mDefaultRenderablePriority(0) {
    for (auto& g : mGroups) g.reset();
  }

  // 对应 getQueueGroup:懒创建
  RenderQueueGroup* getQueueGroup(uint8_t groupID) {
    if (!mGroups[groupID]) {
      mGroups[groupID] = std::make_unique<RenderQueueGroup>();
    }
    return mGroups[groupID].get();
  }

  // 对应 addRenderable(Renderable*, uint8, ushort):默认组透明物体重定向
  void addRenderable(Renderable* pRend, uint8_t groupID, uint16_t priority) {
    bool transparent = pRend->transparent;
    if (groupID == mDefaultQueueGroup && transparent) {
      groupID = RENDER_QUEUE_TRANSPARENTS;  // 透明物体上透明队列
    }
    RenderQueueGroup* pGroup = getQueueGroup(groupID);
    pGroup->addRenderable(pRend, transparent);
  }

  // 对应 addRenderable(Renderable*, uint8):用默认优先级
  void addRenderable(Renderable* pRend, uint8_t groupID) {
    addRenderable(pRend, groupID, mDefaultRenderablePriority);
  }

  // 对应 addRenderable(Renderable*):默认组 + 默认优先级
  void addRenderable(Renderable* pRend) {
    addRenderable(pRend, mDefaultQueueGroup, mDefaultRenderablePriority);
  }

  // 对应 clear:清空组内物品但保留组结构
  void clear() {
    for (auto& g : mGroups) {
      if (g) g->clear();
    }
  }

  uint8_t getDefaultQueueGroup() const { return mDefaultQueueGroup; }
  RenderQueueGroup* getGroup(uint8_t id) { return mGroups[id].get(); }
  bool hasGroup(uint8_t id) const { return mGroups[id] != nullptr; }

 private:
  RenderQueueGroupMap mGroups;
  uint8_t mDefaultQueueGroup;
  uint16_t mDefaultRenderablePriority;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // RenderQueueGroupID 关键组号
  CHECK(RENDER_QUEUE_BACKGROUND == 0);
  CHECK(RENDER_QUEUE_MAIN == 50);
  CHECK(RENDER_QUEUE_TRANSPARENTS == 95);
  CHECK(RENDER_QUEUE_OVERLAY == 100);
  CHECK(RENDER_QUEUE_MAX == 105);

  RenderQueue queue;
  CHECK(queue.hasGroup(RENDER_QUEUE_MAIN) == false);  // 初始化时无任何组

  // getQueueGroup 懒创建
  RenderQueueGroup* g50 = queue.getQueueGroup(RENDER_QUEUE_MAIN);
  CHECK(g50 != nullptr);
  CHECK(queue.hasGroup(RENDER_QUEUE_MAIN) == true);
  CHECK(queue.getQueueGroup(RENDER_QUEUE_MAIN) == g50);  // 同一实例

  // 不透明物体进默认组 50
  Renderable opaque = {1, false};
  queue.addRenderable(&opaque);
  CHECK(queue.getGroup(RENDER_QUEUE_MAIN)->getNumRenderables() == 1);
  CHECK(queue.getGroup(RENDER_QUEUE_MAIN)->getNumTransparent() == 0);

  // 透明物体在默认组被重定向到 95
  Renderable glass = {2, true};
  queue.addRenderable(&glass);
  CHECK(queue.getGroup(RENDER_QUEUE_MAIN)->getNumRenderables() == 1);   // 没进 50
  CHECK(queue.getGroup(RENDER_QUEUE_TRANSPARENTS)->getNumRenderables() == 1);  // 进了 95
  CHECK(queue.getGroup(RENDER_QUEUE_TRANSPARENTS)->getNumTransparent() == 1);

  // 显式指定组 100 的透明物体不被重定向(groupID != 默认组)
  Renderable ui = {3, true};
  queue.addRenderable(&ui, RENDER_QUEUE_OVERLAY, 10);
  CHECK(queue.getGroup(RENDER_QUEUE_OVERLAY)->getNumRenderables() == 1);
  CHECK(queue.getGroup(RENDER_QUEUE_OVERLAY)->getNumTransparent() == 1);

  // 带组 ID 的 2 参 addRenderable 也走默认优先级
  Renderable decal = {4, false};
  queue.addRenderable(&decal, RENDER_QUEUE_MAIN);
  CHECK(queue.getGroup(RENDER_QUEUE_MAIN)->getNumRenderables() == 2);

  // clear 清空内容但保留组
  queue.clear();
  CHECK(queue.getGroup(RENDER_QUEUE_MAIN)->getNumRenderables() == 0);
  CHECK(queue.getGroup(RENDER_QUEUE_TRANSPARENTS)->getNumRenderables() == 0);
  CHECK(queue.hasGroup(RENDER_QUEUE_MAIN) == true);   // 组结构还在
  CHECK(queue.hasGroup(RENDER_QUEUE_TRANSPARENTS) == true);

  // clear 后可继续使用同一组
  Renderable again = {5, false};
  queue.addRenderable(&again);
  CHECK(queue.getGroup(RENDER_QUEUE_MAIN)->getNumRenderables() == 1);

  // 默认组未访问过的组保持不存在
  CHECK(queue.hasGroup(RENDER_QUEUE_OVERLAY) == true);   // 之前创建过
  CHECK(queue.hasGroup(RENDER_QUEUE_BACKGROUND) == false);  // 从未创建

  return lab::report("05-1 渲染队列 RenderQueue");
}

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

小结

  • RenderQueueGroupID 定义 0-105 的组号,RENDER_QUEUE_COUNT 紧跟 MAX 作为数组长度。
  • RenderQueue 用 unique_ptr<RenderQueueGroup>[RENDER_QUEUE_COUNT] 数组装组,getQueueGroup 懒创建。
  • addRenderable 解析/兜底材质、允许监听器改写或拒绝、把默认组的透明物体重定向到 95。
  • 显式指定非默认组的透明物体不被重定向。
  • clear 清空组内物品但保留组结构,帧间复用避免反复分配。

阅读导航:上一节:4.3 状态应用到 RenderSystem · 下一节:5.2 排序策略 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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