4.2 Technique 的 Pass 顺序与哈希
4.1 解剖了单个 Pass 的渲染状态。但一个材质通常不是一次绘制就能完成的:漫反射层画一遍、高光层再画一遍、环境遮蔽再画一遍。OGRE 用 Technique 把多个 Pass 装进一个有序容器,渲染时分别应用每个 Pass 的状态并执行绘制,写入结果按该 Pass 的混合规则与目标内容组合。这一节看三件事:Pass 怎么进容器、索引怎么管理、以及那个 32 位哈希如何把「哪道 Pass + 什么状态」编码进用于排序的哈希。默认哈希偏向减少 GPU 程序切换,不表示完整渲染状态。
本章与站内既有内容的分工
helio 四卷渲染器里多遍绘制靠手动提交多个 RenderCommand;卷一 ogre-core 从资源加载角度提过 Material→Technique→Pass 三层。这里聚焦Pass 的组织结构:std::vector<Pass*> 容器、创建/删除时的索引分配与重排、以及哈希的位布局——这些直接为 4.3 的状态应用和 5.2 的排序提供输入。
有序容器:Passes
Technique 保存 Pass 的容器是朴素的指针数组,索引即顺序:
// OgreMain/include/OgreTechnique.h:Passes 容器(v14.6.3 源码摘录,已删减)
typedef std::vector<Pass*> Passes;
Passes mPasses;
// OgreMain/include/OgreTechnique.h:createPass/getPass/getNumPasses(v14.6.3 源码摘录,已删减)
Pass* createPass(void);
/** Retrieves the Pass with the given index.*/
Pass* getPass(size_t index) const { return mPasses.at(index); }
/** Retrieves the Pass matching name.
Returns 0 if name match is not found.
*/
Pass* getPass(const String& name) const;
/** Retrieves the number of passes. */
size_t getNumPasses(void) const { return mPasses.size(); }
getPass(index) 用 at()(越界抛异常),getPass(name) 遍历匹配名字、找不到返回空指针。创建时索引直接取自容器大小:
// OgreMain/src/OgreTechnique.cpp:createPass(v14.6.3 源码摘录,已删减)
Pass* Technique::createPass(void)
{
Pass* newPass = OGRE_NEW Pass(this, static_cast<unsigned short>(mPasses.size()));
mPasses.push_back(newPass);
return newPass;
}
索引从 0 递增——mPasses.size() 既是容器大小,又是下一个新 Pass 的序号。
删除与索引重排
删掉中间的 Pass 后,剩下的必须重新编号,否则哈希里的索引位就错位了:
// OgreMain/src/OgreTechnique.cpp:removePass(v14.6.3 源码摘录,已删减)
void Technique::removePass(unsigned short index)
{
assert(index < mPasses.size() && "Index out of bounds");
Passes::iterator i = mPasses.begin() + index;
(*i)->queueForDeletion();
i = mPasses.erase(i);
// Adjust passes index
for (; i != mPasses.end(); ++i, ++index)
{
(*i)->_notifyIndex(index);
}
}
_notifyIndex 只在索引真的变化时才触发 hash 重算:
// OgreMain/src/OgrePass.cpp:_notifyIndex(v14.6.3 源码摘录,已删减)
void Pass::_notifyIndex(unsigned short index)
{
if (mIndex != index)
{
mIndex = index;
_dirtyHash();
}
}
默认状态:构造函数
每个新 Pass 生下来就带一套完整默认状态——这决定了「什么也没设置」的 Pass 如何渲染:
// OgreMain/src/OgrePass.cpp:Pass 构造函数(v14.6.3 源码摘录,已删减)
Pass::Pass(Technique* parent, unsigned short index)
: mParent(parent)
, mHash(0)
...
, mDepthCheck(true)
, mDepthWrite(true)
...
, mCullMode(CULL_CLOCKWISE)
...
, mIndex(index)
...
{
// init the hash inline
_recalculateHash();
}
深度检查/写入默认开,剔除默认顺时针,混合默认替换。构造函数末尾立刻 _recalculateHash()——状态未动过的 Pass 也拥有有效哈希。一个 Technique 的多个 Pass 各自持有这些状态;「合并」在数据结构层面就是「按容器顺序保存、按索引顺序消费」,没有任何全局叠加——p0 改深度不影响 p1。
哈希位布局:索引 + 内容
Pass 哈希把「是哪一道 Pass」和「是什么状态」压缩进一个 32 位整数,注释写得很清楚:
// OgreMain/src/OgrePass.cpp:_recalculateHash(v14.6.3 源码摘录,已删减)
void Pass::_recalculateHash(void)
{
/* Hash format is 32-bit, divided as follows (high to low bits)
bits purpose
4 Pass index (i.e. max 16 passes!)
28 Pass contents
*/
mHash = (*msHashFunc)(this);
// overwrite the 4 upper bits with pass index
mHash = (uint32(mIndex) << 28) | (mHash >> 4);
}
- 高 4 位:Pass 索引(
uint32(mIndex) << 28)。同一 Technique 不同 Pass 一看高位就分得开;同索引的 Pass 内容相近时低位也相近。 - 低 28 位:内容摘要(
mHash >> 4),来自msHashFunc——一个可替换的函数对象,默认按 Pass 各状态字段算出分布良好的摘要。
这个布局的妙处在于排序阶段按索引聚类:5.2 会用距离排序,同索引/同内容的 Pass 哈希值相近,排在一起就能减少渲染状态切换。_dirtyHash() 负责把「状态变了」登记进一个待重算集合,等材质编译时统一刷新:
// OgreMain/src/OgrePass.cpp:_dirtyHash(v14.6.3 源码摘录,已删减)
void Pass::_dirtyHash(void)
{
if (mQueuedForDeletion)
return;
Material* mat = mParent->getParent();
if (mat->isLoading() || mat->isLoaded())
{
OGRE_LOCK_MUTEX(msDirtyHashListMutex);
// Mark this hash as for follow up
msDirtyHashList.insert(this);
mHashDirtyQueued = false;
}
else
{
mHashDirtyQueued = true;
}
}
源码定位
OgreMain/include/OgreTechnique.h:Passestypedef 与mPasses(54/66)、createPass/getPass/getNumPasses(182-190)OgreMain/src/OgreTechnique.cpp:createPass(309-314)、removePass(327-338)OgreMain/src/OgrePass.cpp:Pass构造函数默认状态(121-177)、_recalculateHash(858-869)、_dirtyHash(871-888)、_notifyIndex(693-700)
上游引用固定到 OGRE v14.6.3 源码 。
可运行产物:C++ 最小验证
下面复现 Pass 容器、索引重排与 32 位哈希合并。它与 src/04-2-state-merge.cpp 逐字节一致:
// file: src/04-2-state-merge.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/04-2-state-merge.cpp -o bin/04-2-state-merge && ./bin/04-2-state-merge
//
// 复现 Technique 的 Pass 容器与状态合并(对应 OgreTechnique.h 54-190、OgreTechnique.cpp 309-341、OgrePass.cpp 858-888):
// Technique 用 std::vector<Pass*> 保存有序 Pass 列表;createPass 用 mPasses.size() 作为新 Pass 索引;
// Pass 各自携带渲染状态(深度/剔除/混合),Technique 的「合并」就是按索引顺序逐个应用这些状态;
// Pass 哈希是 32 位:高 4 位 Pass 索引 + 低 28 位内容摘要,供排序阶段按状态聚类;
// removePass 删除后重排剩余 Pass 的索引。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"
#include <cstdint>
#include <cstring>
#include <string>
#include <vector>
namespace ogre_repro {
enum CullingMode : uint8_t { CULL_NONE = 1, CULL_CLOCKWISE = 2, CULL_ANTICLOCKWISE = 3 };
enum SceneBlendFactor {
SBF_ONE,
SBF_ZERO,
SBF_DEST_COLOUR,
SBF_SOURCE_COLOUR,
SBF_ONE_MINUS_DEST_COLOUR,
SBF_ONE_MINUS_SOURCE_COLOUR,
SBF_DEST_ALPHA,
SBF_SOURCE_ALPHA,
SBF_ONE_MINUS_DEST_ALPHA,
SBF_ONE_MINUS_SOURCE_ALPHA
};
// 对应 ColourBlendState 的简化混合子集
struct BlendState {
SceneBlendFactor sourceFactor;
SceneBlendFactor destFactor;
BlendState() : sourceFactor(SBF_ONE), destFactor(SBF_ZERO) {}
};
// 对应 Pass:独立渲染状态 + 32 位哈希(高 4 位索引 + 低 28 位内容)
class Pass {
public:
Pass(unsigned short index) : mIndex(index) {
// 构造函数默认状态(对应 OgrePass.cpp 121-176)
mDepthCheck = true;
mDepthWrite = true;
mCullMode = CULL_CLOCKWISE;
mBlend = BlendState();
_recalculateHash();
}
void setDepthCheckEnabled(bool e) {
mDepthCheck = e;
_dirtyHash();
}
bool getDepthCheckEnabled() const { return mDepthCheck; }
void setDepthWriteEnabled(bool e) {
mDepthWrite = e;
_dirtyHash();
}
bool getDepthWriteEnabled() const { return mDepthWrite; }
void setCullingMode(CullingMode m) {
mCullMode = m;
_dirtyHash();
}
CullingMode getCullingMode() const { return mCullMode; }
void setSceneBlending(SceneBlendFactor s, SceneBlendFactor d) {
mBlend.sourceFactor = s;
mBlend.destFactor = d;
_dirtyHash();
}
const BlendState& getBlendState() const { return mBlend; }
void setName(const std::string& n) { mName = n; }
const std::string& getName() const { return mName; }
unsigned short getIndex() const { return mIndex; }
// 对应 _notifyIndex(OgrePass.cpp 693-700):索引变化才重算哈希
void _notifyIndex(unsigned short index) {
if (mIndex != index) {
mIndex = index;
_dirtyHash();
}
}
uint32_t getHash() const { return mHash; }
// 对应 _recalculateHash:内容摘要占低 28 位,索引占高 4 位
// 内容摘要用 FNV 混入各状态字段,产生 28 位可分布值(真实哈希函数在 OgrePass.cpp 858-869)
void _recalculateHash() {
uint32_t contents = 2166136261u; // FNV offset basis
contents = (contents ^ (mDepthCheck ? 1u : 0u)) * 16777619u;
contents = (contents ^ (mDepthWrite ? 1u : 0u)) * 16777619u;
contents = (contents ^ uint32_t(mCullMode)) * 16777619u;
contents = (contents ^ uint32_t(mBlend.sourceFactor)) * 16777619u;
contents = (contents ^ uint32_t(mBlend.destFactor)) * 16777619u;
mHash = (uint32_t(mIndex) << 28) | (contents >> 4);
}
void _dirtyHash() { _recalculateHash(); }
private:
std::string mName;
bool mDepthCheck;
bool mDepthWrite;
CullingMode mCullMode;
BlendState mBlend;
unsigned short mIndex;
uint32_t mHash;
};
// 对应 Technique:Pass 有序容器(OgreTechnique.h 54-190)
class Technique {
public:
~Technique() { clear(); }
Pass* createPass() {
Pass* p = new Pass(static_cast<unsigned short>(mPasses.size()));
mPasses.push_back(p);
return p;
}
Pass* getPass(size_t index) const { return mPasses.at(index); }
Pass* getPass(const std::string& name) const {
for (Pass* p : mPasses) {
if (p->getName() == name) return p;
}
return nullptr;
}
size_t getNumPasses() const { return mPasses.size(); }
void removePass(size_t index) {
auto it = mPasses.begin() + index;
delete *it;
it = mPasses.erase(it);
// 重排剩余 Pass 索引(对应 OgreTechnique.cpp 327-341)
for (; it != mPasses.end(); ++it) {
unsigned short i = static_cast<unsigned short>(it - mPasses.begin());
(*it)->_notifyIndex(i);
}
}
void clear() {
for (Pass* p : mPasses) delete p;
mPasses.clear();
}
private:
std::vector<Pass*> mPasses;
};
} // namespace ogre_repro
int main() {
using namespace ogre_repro;
// createPass 分配索引 = mPasses.size(),0 起始
Technique tech;
Pass* p0 = tech.createPass();
Pass* p1 = tech.createPass();
Pass* p2 = tech.createPass();
CHECK(tech.getNumPasses() == 3);
CHECK(p0->getIndex() == 0);
CHECK(p1->getIndex() == 1);
CHECK(p2->getIndex() == 2);
// getPass(index) 与 getPass(name)
p1->setName("lighting");
CHECK(tech.getPass(1) == p1);
CHECK(tech.getPass("lighting") == p1);
CHECK(tech.getPass("nonexistent") == nullptr); // 未匹配返回空
// 每个 Pass 自带默认状态(深度开、剔除顺时针、替换混合)
CHECK(p0->getDepthCheckEnabled() == true);
CHECK(p0->getCullingMode() == CULL_CLOCKWISE);
CHECK(p0->getBlendState().sourceFactor == SBF_ONE);
CHECK(p0->getBlendState().destFactor == SBF_ZERO);
// 状态合并 = 各自修改互不影响
p0->setDepthCheckEnabled(false);
p0->setCullingMode(CULL_ANTICLOCKWISE);
p1->setSceneBlending(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA);
CHECK(p0->getDepthCheckEnabled() == false);
CHECK(p0->getCullingMode() == CULL_ANTICLOCKWISE);
CHECK(p1->getDepthCheckEnabled() == true); // p1 不受 p0 影响
CHECK(p1->getBlendState().sourceFactor == SBF_SOURCE_ALPHA);
CHECK(p1->getBlendState().destFactor == SBF_ONE_MINUS_SOURCE_ALPHA);
CHECK(p2->getCullingMode() == CULL_CLOCKWISE); // p2 保持默认
// 哈希:高 4 位是索引,改状态只动低 28 位
uint32_t h0 = p0->getHash();
uint32_t h1 = p1->getHash();
CHECK((h0 >> 28) == 0);
CHECK((h1 >> 28) == 1); // 索引位不同
p0->setDepthWriteEnabled(false);
uint32_t h0b = p0->getHash();
CHECK((h0b >> 28) == 0); // 高 4 位仍是索引 0
CHECK((h0b & 0x0FFFFFFFu) != (h0 & 0x0FFFFFFFu)); // 低 28 位内容变化
// 改回状态后哈希回到相同值(内容摘要稳定)
p0->setDepthWriteEnabled(true);
uint32_t h0c = p0->getHash();
CHECK(h0c == h0);
// removePass 后重排索引:删第 1 个,原 p1 变为索引 0,原 p2 变为索引 1
tech.removePass(0);
CHECK(tech.getNumPasses() == 2);
Pass* np0 = tech.getPass(0);
Pass* np1 = tech.getPass(1);
CHECK(np0 == p1);
CHECK(np1 == p2);
CHECK(np0->getIndex() == 0);
CHECK(np1->getIndex() == 1);
// 重排后哈希索引位跟随新索引
CHECK((np0->getHash() >> 28) == 0);
CHECK((np1->getHash() >> 28) == 1);
return lab::report("04-2 Technique 的 Pass 顺序与哈希");
}
本机实测(Apple clang 16,clang++ -std=c++20):编译通过(-Wall 零警告),断言 29/29 通过。
小结
Technique用std::vector<Pass*>保存有序 Pass;createPass以容器大小作新索引。- 每个 Pass 持有独立默认状态,Technique 的「合并」是顺序消费而非全局叠加。
removePass后通过_notifyIndex重排剩余 Pass 索引,只在索引变化时重算哈希。- 32 位 Pass 哈希 = 高 4 位索引 + 低 28 位内容摘要,为排序按状态聚类打基础。
_dirtyHash在材质已加载时登记待重算集合,未加载时仅置位等待。
阅读导航:上一节:4.1 Pass 的渲染状态 · 下一节:4.3 状态应用到 RenderSystem 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。