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 合批与顶点缓存 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。