《OGRE 3D 渲染引擎原理与架构》4.2 Technique 的 Pass 顺序与哈希

一个 Technique 是一组有序 Pass,每个 Pass 携带独立渲染状态;「合并」就是按索引顺序把这些状态逐个应用成一次多次绘制。Pass 的 32 位哈希把索引放高 4 位、内容摘要放低 28 位,供排序按状态聚类。lab 复现容器管理、索引重排与哈希合并。

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;
        }
    }

源码定位

上游引用固定到 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 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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