《OGRE 3D 渲染引擎原理与架构》9.2 渲染状态切换优化

9.2 讲 RenderQueue 的分组与 pass 聚合。addRenderable 按 queue group 粗分、透明 pass 自动提升到 RENDER_QUEUE_TRANSPARENTS;组内 PassGroupLess 按 pass 哈希稳定排序以最小化渲染状态切换。lab 复现透明提升、分组计数与状态切换统计,10 项断言。

9.2 渲染状态切换优化

渲染状态切换(bind shader、改 blend/深度状态、换纹理绑定)是 CPU 侧最贵的操作之一:一次切换动辄几十微秒,一帧几千次切换就能吃满一个核。OGRE 的应对是「先分组、再聚合」:RenderQueue 把物体按 RenderQueueGroupID 粗分,组内再按 priority 细分;真正的杀手锏是 OM_PASS_GROUP 组织模式——用 PassGroupLess 按 pass 哈希把相同 pass 的可渲染对象聚到连续区间,让渲染循环一次切换状态后连续画一整批同状态物体。

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

8.3 的 Metal/D3D11 讲「状态对象」的缓存(mPSOCache/ID3D11*State);本节讲排序阶段如何减少这些状态对象的切换次数。两者互补:排序在 CPU 端尽量聚批,缓存在后端避免重复创建。lab 复现队列分组与 pass 哈希聚合的最小逻辑。

addRenderable:按组入队,透明提升

RenderQueue::addRenderable 拿到 Renderable 后先确保材质/technique 可用,然后询问监听器是否放行。随后是一个关键分支:如果 groupID 恰为默认队列组、且 onTransparentQueue(pTech) 判定材质是透明的,就把组改成 RENDER_QUEUE_TRANSPARENTS——这就是「透明提升」,让透明物体永远排在常规队列之后渲染:

// OgreMain/src/OgreRenderQueue.cpp:RenderQueue::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);

RenderQueueGroupID 把渲染分成背景、世界几何、主队列、透明、覆盖层等档位。主队列 RENDER_QUEUE_MAIN = 50,透明 RENDER_QUEUE_TRANSPARENTS = 95——中间留出的数字空间正是给用户自定义队列插入用的:

// 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,
        RENDER_QUEUE_1 = 10,
        RENDER_QUEUE_2 = 20,
        RENDER_QUEUE_WORLD_GEOMETRY_1 = 25,
        RENDER_QUEUE_3 = 30,
        RENDER_QUEUE_4 = 40,
        /// The default render queue
        RENDER_QUEUE_MAIN = 50,
        RENDER_QUEUE_6 = 60,
        RENDER_QUEUE_7 = 70,
        RENDER_QUEUE_WORLD_GEOMETRY_2 = 75,
        RENDER_QUEUE_8 = 80,
        /// Used for skyboxes if rendered last
        RENDER_QUEUE_SKIES_LATE = 90,
        /// 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
    };

lab 里用 groupSize(RENDER_QUEUE_MAIN)==5 与 groupSize(RENDER_QUEUE_TRANSPARENTS)==1 验证 5 个不透明 + 1 个透明物体被正确分流到两组。

PassGroupLess:按 pass 哈希聚合

组内采用 QueuedRenderableCollection::OM_PASS_GROUP 组织模式时,可渲染对象存放在 std::map<Pass*, RenderableList, PassGroupLess> 中。PassGroupLess 比较两个 Pass 的 getHash()——哈希综合了 pass 参数与纹理单元状态——哈希相同再回退到指针比较以保证严格弱序。哈希相同的 pass 会被 map 归到同一个键,天然形成连续批次:

// OgreMain/include/OgreRenderQueueSortingGrouping.h:PassGroupLess(v14.6.3 源码摘录,已删减)
        /// Comparator to order pass groups
        struct PassGroupLess
        {
            bool operator()(const Pass* a, const Pass* b) const
            {
                // Sort by passHash, which is pass, then texture unit changes
                uint32 hasha = a->getHash();
                uint32 hashb = b->getHash();
                if (hasha == hashb)
                {
                    // Must differentTransparentQueueItemLessiate by pointer in case 2 passes end up with the same hash
                    return a < b;
                }
                else
                {
                    return hasha < hashb;
                }
            }
        };
        /** Vector of RenderablePass objects, this is built on the assumption that
         vectors only ever increase in size, so even if we do clear() the memory stays
         allocated, ie fast */
        typedef std::vector<RenderablePass> RenderablePassList;
        /** Map of pass to renderable lists, this is a grouping by pass. */
        typedef std::map<Pass*, RenderableList, PassGroupLess> PassGroupRenderableMap;

用数值看收益:5 个物体 pass 交错为 1、2、1、2、1,逐个渲染需要 4 次状态切换;按 passHash 排序成 1、1、1、2、2 后只需 1 次切换。lab 里 naiveStateChanges(raw)==4u 与 renderStateChanges()==2u 形成对照——后者因为还跨了 MAIN 与 TRANSPARENTS 两个组,组间切换一次、组内再切换一次,共 2 次。

源码定位

  • OgreMain/src/OgreRenderQueue.cpp:RenderQueue::addRenderable(79-119 行)
  • OgreMain/include/OgreRenderQueue.h:RenderQueueGroupID(52-78 行)
  • OgreMain/include/OgreRenderQueueSortingGrouping.h:PassGroupLess(126-149 行)
  • OgreMain/src/OgreRenderQueueSortingGrouping.cpp:RenderPriorityGroup::addRenderable(144 行起)

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

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

RenderQueueRepro 用一个 std::map<uint8_t, vector<Renderable>> 复现「按组入队 + 透明提升」,渲染时组内按 passHash 稳定排序并统计切换次数;naiveStateChanges 给出不聚合的对照。它与 src/09-2-render-state-optimization.cpp 逐字节一致:

// file: src/09-2-render-state-optimization.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/09-2-render-state-optimization.cpp -o bin/09-2-render-state-optimization && ./bin/09-2-render-state-optimization
//
// 复现渲染队列的分组与 pass 聚合(对应 OgreRenderQueue.cpp 79-119 的
//   RenderQueue::addRenderable、OgreRenderQueue.h 52-78 的 RenderQueueGroupID、
//   OgreRenderQueueSortingGrouping.h 126-142 的 PassGroupLess):渲染队列按
//   queue group 粗分、按 priority 细分;透明 pass 被自动提升到
//   RENDER_QUEUE_TRANSPARENTS;组内按 pass 哈希聚合以最小化渲染状态切换。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <algorithm>
#include <cstdint>
#include <map>
#include <vector>

namespace ogre_repro {

// 对应 OgreRenderQueue.h 52-78 的 RenderQueueGroupID(摘录两个关键档位)
enum RenderQueueGroupID {
    RENDER_QUEUE_MAIN = 50,
    RENDER_QUEUE_TRANSPARENTS = 95,
};

struct Renderable {
    uint32_t passHash;  // Pass::getHash 的近似:pass + 纹理单元状态
    uint8_t groupID;
    uint16_t priority;
    bool transparent;   // onTransparentQueue 的近似
};

class RenderQueueRepro {
public:
    // 对应 RenderQueue::addRenderable:透明提升 + 入组
    void addRenderable(const Renderable& r) {
        uint8_t gid = r.groupID;
        if (r.transparent)
            gid = RENDER_QUEUE_TRANSPARENTS;
        mGroups[gid].push_back(r);
    }

    // 组内按 pass 哈希稳定排序(对应 QueuedRenderableCollection 的 PassGroupLess
    // 按 getHash 排序),渲染时统计 pass 状态切换次数
    uint32_t renderStateChanges() const {
        uint32_t changes = 0;
        uint32_t lastHash = 0;
        bool first = true;
        for (auto& [gid, list] : mGroups) {
            (void)gid;
            std::vector<Renderable> sorted = list;
            std::stable_sort(sorted.begin(), sorted.end(),
                             [](const Renderable& a, const Renderable& b) {
                                 return a.passHash < b.passHash;
                             });
            for (const Renderable& r : sorted) {
                if (first) {
                    lastHash = r.passHash;
                    first = false;
                    continue;
                }
                if (r.passHash != lastHash)
                    ++changes;
                lastHash = r.passHash;
            }
        }
        return changes;
    }

    uint32_t groupCount() const { return static_cast<uint32_t>(mGroups.size()); }
    size_t groupSize(uint8_t gid) const {
        auto it = mGroups.find(gid);
        return it == mGroups.end() ? 0 : it->second.size();
    }

private:
    std::map<uint8_t, std::vector<Renderable>> mGroups;
};

// 不聚合的逐对象渲染:切换次数 = 相邻 passHash 变化数
uint32_t naiveStateChanges(const std::vector<Renderable>& input) {
    uint32_t changes = 0;
    for (size_t i = 1; i < input.size(); ++i)
        if (input[i].passHash != input[i - 1].passHash)
            ++changes;
    return changes;
}

}  // namespace ogre_repro

int main() {
    using namespace ogre_repro;
    RenderQueueRepro q;

    // 5 个不透明物体,pass 交错(1,2,1,2,1);一个透明物体被提升到 95
    q.addRenderable({1, RENDER_QUEUE_MAIN, 10, false});
    q.addRenderable({2, RENDER_QUEUE_MAIN, 10, false});
    q.addRenderable({1, RENDER_QUEUE_MAIN, 10, false});
    q.addRenderable({2, RENDER_QUEUE_MAIN, 10, false});
    q.addRenderable({1, RENDER_QUEUE_MAIN, 10, false});
    q.addRenderable({3, RENDER_QUEUE_MAIN, 10, true});

    CHECK_EQ(q.groupSize(RENDER_QUEUE_MAIN), 5u);
    CHECK_EQ(q.groupSize(RENDER_QUEUE_TRANSPARENTS), 1u);
    CHECK_EQ(q.groupCount(), 2u);

    // 乱序渲染 5 个交错的 pass 需要 4 次切换
    const std::vector<Renderable> raw{{1, 50, 10, false}, {2, 50, 10, false},
                                      {1, 50, 10, false}, {2, 50, 10, false},
                                      {1, 50, 10, false}};
    CHECK_EQ(naiveStateChanges(raw), 4u);
    // 组内聚合后仅 2 次切换
    CHECK_EQ(q.renderStateChanges(), 2u);

    // 跨组连续渲染:MAIN 组(1,2 -> 1 次)+ 切换到 TRANSPARENTS 组(2->3 -> 1 次)
    RenderQueueRepro q2;
    q2.addRenderable({1, RENDER_QUEUE_MAIN, 10, false});
    q2.addRenderable({2, RENDER_QUEUE_MAIN, 10, false});
    q2.addRenderable({3, RENDER_QUEUE_MAIN, 10, true});
    CHECK_EQ(q2.renderStateChanges(), 2u);

    // 同 passHash 的物体聚合后无切换(stable 保持输入顺序)
    RenderQueueRepro q3;
    q3.addRenderable({5, RENDER_QUEUE_MAIN, 20, false});
    q3.addRenderable({5, RENDER_QUEUE_MAIN, 10, false});
    CHECK_EQ(q3.renderStateChanges(), 0u);
    CHECK_EQ(q3.groupSize(RENDER_QUEUE_MAIN), 2u);

    // 空队列无切换
    RenderQueueRepro empty;
    CHECK_EQ(empty.renderStateChanges(), 0u);
    CHECK_EQ(empty.groupCount(), 0u);

    return lab::report("9.2 渲染状态切换优化");
}

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

小结

  • 渲染队列先按 RenderQueueGroupID 粗分,再按 priority 细分;透明 pass 被提升到 RENDER_QUEUE_TRANSPARENTS。
  • OM_PASS_GROUP 用 std::map<Pass*, RenderableList, PassGroupLess> 按 pass 哈希聚合,哈希相同回退指针比较。
  • 状态切换计数里「跨组切换」也要算:MAIN 组尾到 TRANSPARENTS 组首是一次切换。
  • std::stable_sort 保证同哈希物体保持输入顺序,避免破坏不透明物体的先后关系。
  • 空队列与同哈希全聚合场景切换数为 0,对应渲染循环「零状态变化」的批处理理想情形。

阅读导航:上一节:9.1 性能剖析器 · 下一节:9.3 合批与顶点缓存 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析·向量数据库与 AI 检索内核》 · 目录与学习路径(45 篇)
  2. 《大规模分布式计算深入解析》15.3 自研向量引擎:可执行骨架与工程缺口
  3. 《大规模分布式计算深入解析》14.1 Milvus:组件架构、段管理与检索链路