《OGRE 3D 渲染引擎原理与架构》14.3 RTSS 与场景集成

RTSS 与场景集成的关键在 scheme:Material::getBestTechnique 按活动 scheme 取技术,缺失时回落默认 scheme;createShaderBasedTechnique 为目标 scheme 生成可编程技术并登记映射,同 dstScheme 冲突拒绝。源码在 OgreMain/src/OgreMaterial.cpp 与 Components/RTShaderSystem/src/OgreShaderGenerator.cpp。lab 复现 scheme 选择、回落与技术替换。

14.3 RTSS 与场景集成

14.1 与 14.2 讲了 RTSS 生成着色器的组织方式。这一节回答「生成出来的技术怎么被场景用上」:答案全在一个词——scheme(方案)。材质可以有多个 Technique,每个挂一个 scheme 名;渲染时相机/视口决定活动 scheme,材质按它挑技术。RTSS 做的就是往材质里塞一个 scheme 为 RTSS 的可编程技术。

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

本卷 2.2 节讲视口时提过 scheme 切换(不同质量档);卷二材质一章讲 Technique 与 LOD。这一节把两者接到 RTSS:scheme 既是 RTSS 的「生成目标」,又是运行时材质选技术的键。Material::getBestTechnique 是这套机制的消费点。

getBestTechnique:按 scheme 选技术

场景对象提交给渲染队列时,材质管理器用当前活动 scheme 为每个 LOD 挑一个技术:

// OgreMain/src/OgreMaterial.cpp:Material::getBestTechnique(v14.6.3 源码摘录,已删减)
    Technique* Material::getBestTechnique(unsigned short lodIndex, const Renderable* rend)
    {
        if (mSupportedTechniques.empty())
        {
            return NULL;
        }
        else
        {
            Technique* ret = 0;
            MaterialManager& matMgr = MaterialManager::getSingleton();
            // get scheme
            auto si = mBestTechniquesBySchemeList.find(matMgr._getActiveSchemeIndex());
            // scheme not found?
            if (si == mBestTechniquesBySchemeList.end())
            {
                // listener specified alternative technique available?
                ret = matMgr._arbitrateMissingTechniqueForActiveScheme(this, lodIndex, rend);
                if (ret)
                    return ret;

                OgreAssert(!mBestTechniquesBySchemeList.empty(), "handleSchemeNotFound() must not remove techniques");
                // Nope, use default
                // get the first item, will be 0 (the default) if default
                // scheme techniques exist, otherwise the earliest defined
                si = mBestTechniquesBySchemeList.begin();
            }

            // get LOD
            auto li = si->second.find(lodIndex);
            // LOD not found? 
            if (li == si->second.end())
            {
                // Use the next LOD level up
                for (auto rli = si->second.rbegin(); rli != si->second.rend(); ++rli)
                {
                    if (rli->second->getLodIndex() < lodIndex)
                    {
                        ret = rli->second;
                        break;
                    }

                }
                if (!ret)
                {
                    // shouldn't ever hit this really, unless user defines no LOD 0
                    // pick the first LOD we have (must be at least one to have a scheme entry)
                    ret = si->second.begin()->second;
                }

            }
            else
            {
                // LOD found
                ret = li->second;
            }

            return ret;

        }
    }

两条回退规则:

  • scheme 缺失:活动 scheme 在材质里找不到对应技术时,先问 _arbitrateMissingTechniqueForActiveScheme(监听器可提供替代),仍无则回落默认 scheme(mBestTechniquesBySchemeList 第一项,通常就是 Default)。
  • LOD 缺失:当前 LOD 找不到,取下一级更低的 LOD;都没有则取该 scheme 下第一个技术。

所以 RTSS 生成的 RTSS scheme 技术参与选技术的方式很自然:活动 scheme 是 RTSS 时被命中,是 Default 时材质照旧用固定管线技术。

createShaderBasedTechnique:登记替换条目

RTSS 把「源技术 → 目标 scheme」登记为 SGTechnique 条目。冲突规则在这里执行:

// Components/RTShaderSystem/src/OgreShaderGenerator.cpp:ShaderGenerator::createShaderBasedTechnique(v14.6.3 源码摘录,已删减)
    // Check if technique already created.
    if (itMatEntry != mMaterialEntriesMap.end())
    {
        const SGTechniqueList& techniqueEntires = itMatEntry->second->getTechniqueList();
        for (auto* t : techniqueEntires)
        {
            // Case the requested mapping already exists.
            if (t->getSourceTechnique()->getSchemeName() == srcTechnique->getSchemeName() && t->getDestinationTechniqueSchemeName() == dstTechniqueSchemeName)
                return true;
            // Case a shader based technique with the same scheme name already defined based
            // on different source technique.
            // This state might lead to conflicts during shader generation - we prevent it by returning false here.
            else if (t->getDestinationTechniqueSchemeName() == dstTechniqueSchemeName)
                return false;
        }
    }

    // Create shader based technique from the given source technique.
    SGMaterial* matEntry = NULL;

    if (itMatEntry == mMaterialEntriesMap.end())
    {
        matEntry = OGRE_NEW SGMaterial(materialName, trueGroupName);
        mMaterialEntriesMap.emplace(MatGroupPair(materialName, trueGroupName), matEntry);
    }
    else
    {
        matEntry = itMatEntry->second;
    }

    // Create the new technique entry.
    SGTechnique* techEntry =
        OGRE_NEW SGTechnique(matEntry, srcTechnique, dstTechniqueSchemeName, overProgrammable);

    // Add to material entry map.
    matEntry->getTechniqueList().push_back(techEntry);

    // Add to all technique map.
    mTechniqueEntriesMap[techEntry] = techEntry;

    // Add to scheme.
    SGScheme* schemeEntry = createOrRetrieveScheme(dstTechniqueSchemeName).first;
    schemeEntry->addTechniqueEntry(techEntry);

    return true;
}

要点:

  • 幂等:同一 (源 scheme, 目标 scheme) 组合已登记 → 返回 true 不重复创建。
  • 冲突拒绝:目标 scheme 已被映射到不同源技术 → 返回 false。同一次生成的多个材质若撞了 scheme,后到的生成会失败,避免生成期歧义。
  • 新条目挂进 mMaterialEntriesMap(材质维度)与 scheme 表(SGScheme::addTechniqueEntry),供 hasShaderBasedTechnique 查询与运行时遍历。

运行时的集成回路

完整回路是这样转的:

  1. 应用把活动 scheme 设为 RTSS(MaterialManager::setActiveScheme,通常在视图初始化时做一次)。
  2. 场景对象入队时,Material::getBestTechnique 用活动 scheme 命中 RTSS 生成的技术。
  3. 该技术由 RTSS 的 TargetRenderState 展开:把 14.2 收集的子状态按执行顺序变成 GPU 程序,updateGpuProgramsParams 在每对象渲染前绑定参数。
  4. 不需要 RTSS 的对象(HUD 材质、粒子)用默认 scheme,依旧走固定管线——两种 scheme 共存于一个场景。

这条回路让「既有 FFP 材质自动获得着色器版本」对场景代码完全透明:场景只管提交对象,scheme 切换在视图层完成。

材质 scheme 与 RTSS 路径

flowchart TD
  A["视口请求材质 scheme"] --> B{"找到可用 Technique?"}
  B -->|"是"| C["应用已选 Technique"]
  B -->|"缺失"| D["材质监听器尝试 RTSS"]
  D --> E["构建 RenderState 与 SubRenderState"]
  E --> F["生成程序并绑定参数"]
  F --> G["登记生成的 Technique"]
  G --> C

材质修改后的 RTSS 失效

请求缺失 scheme 时可以由监听器接入 ShaderGenerator 生成方案。生成过程组合 SubRenderState 并建立着色器程序。直接改源 Pass 后,要按 RTSS 的接口使生成结果失效,才能触发更新。

记录已有 Technique 命中、首次生成和修改后失效这三个时点。程序源码、编译结果和实际 draw 是不同验证层。 RTSS 手册

生成方案中的状态与程序

flowchart LR
  V["Viewport 请求 scheme"] --> M["MaterialManager 方案选择"]
  M -->|"缺失方案"| S["ShaderGenerator"]
  P["源 Technique 与 Pass"] --> S
  S --> R["RenderState"]
  F["SubRenderStateFactory"] --> U["按阶段组织 SubRenderState"]
  U --> R
  R --> W["程序生成与参数绑定"]
  W --> D["目标 Technique 和 Pass"]
  D -.->|"成为方案候选"| M
  P -.->|"直接修改后触发失效"| S

源码定位

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

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

下面用纯 C++ 复现 scheme 选择与技术替换:getBestTechnique 的 scheme 命中与默认回落、RTSS 生成可编程技术并登记映射、同 dstScheme 冲突拒绝、无 FFP 源技术时生成失败。它与 src/14-3-rtss-integration.cpp 逐字节一致:

// file: src/14-3-rtss-integration.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/14-3-rtss-integration.cpp -o bin/14-3-rtss-integration && ./bin/14-3-rtss-integration
//
// 复现 RTSS 与场景集成的材质 scheme 选择与技术替换(对应
// OgreMain/src/OgreMaterial.cpp 296-355 的 Material::getBestTechnique 与
// Components/RTShaderSystem/src/OgreShaderGenerator.cpp 688-815):
//   Material 的 supported techniques 按 scheme + LOD 分桶;
//   getBestTechnique:按活动 scheme 取技术,缺省回落默认 scheme;
//   RTSS 为材质登记 srcScheme -> dstScheme 技术替换条目;
//   活动 scheme 切到 RTSS 后取回的是生成的技术。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <map>
#include <string>
#include <vector>

namespace ogre_repro {

// 对应 Technique(OgreTechnique.h):scheme + LOD + 是否 FFP。
class Technique {
 public:
  Technique(const std::string& schemeName, uint16_t lodIndex)
      : mSchemeName(schemeName), mLodIndex(lodIndex) {}
  const std::string& getSchemeName() const { return mSchemeName; }
  uint16_t getLodIndex() const { return mLodIndex; }
  bool isProgrammable() const { return mProgrammable; }
  void setProgrammable(bool p) { mProgrammable = p; }
  std::string name;

 private:
  std::string mSchemeName;
  uint16_t mLodIndex;
  bool mProgrammable = false;
};

// 对应 Material::getBestTechnique(OgreMaterial.cpp 296-355)的简化形式。
class Material {
 public:
  explicit Material(const std::string& name) : mName(name) {}

  void addTechnique(Technique* t) {
    mSupportedTechniques.push_back(t);
    mBestByScheme[t->getSchemeName()].emplace(t->getLodIndex(), t);
  }

  Technique* getBestTechnique(const std::string& activeScheme, uint16_t lodIndex) {
    if (mSupportedTechniques.empty()) return nullptr;
    auto si = mBestByScheme.find(activeScheme);
    if (si == mBestByScheme.end()) {
      // 活动 scheme 不存在:回落默认 scheme("Default")
      si = mBestByScheme.find("Default");
      if (si == mBestByScheme.end()) return nullptr;
    }
    auto li = si->second.find(lodIndex);
    if (li != si->second.end()) return li->second;
    // LOD 缺失:取最高一级(简化:取第一个)
    return si->second.begin()->second;
  }

  const std::string& getName() const { return mName; }
  const std::vector<Technique*>& getSupportedTechniques() const { return mSupportedTechniques; }

 private:
  std::string mName;
  std::vector<Technique*> mSupportedTechniques;
  std::map<std::string, std::map<uint16_t, Technique*>> mBestByScheme;
};

// 对应 RTSS 的 SGTechnique 替换条目。
struct TechniqueEntry {
  std::string srcScheme;
  std::string dstScheme;
};

// 对应 ShaderGenerator 的材质映射表:登记/查询 RTSS 技术替换。
class RTSS {
 public:
  // 对应 createShaderBasedTechnique:把 dstScheme 技术加入材质 supported 列表。
  bool createShaderBasedTechnique(Material& mat, const std::string& srcScheme,
                                  const std::string& dstScheme) {
    // 检查同 dstScheme 冲突
    auto& entries = mMaterialEntries[mat.getName()];
    for (const auto& e : entries) {
      if (e.dstScheme == dstScheme) return false;
    }
    // 找到源技术:含非可编程(FFP)pass 的、scheme 匹配的技术
    Technique* srcTech = nullptr;
    for (auto* t : mat.getSupportedTechniques()) {
      if (t->getSchemeName() == srcScheme && !t->isProgrammable()) {
        srcTech = t;
        break;
      }
    }
    if (!srcTech) return false;

    // 生成目标技术并加入材质
    Technique* dstTech = new Technique(dstScheme, srcTech->getLodIndex());
    dstTech->setProgrammable(true);
    dstTech->name = mat.getName() + "/" + dstScheme;
    mat.addTechnique(dstTech);
    entries.push_back(TechniqueEntry{srcScheme, dstScheme});
    return true;
  }

  bool hasShaderBasedTechnique(const std::string& materialName, const std::string& srcScheme,
                               const std::string& dstScheme) const {
    auto it = mMaterialEntries.find(materialName);
    if (it == mMaterialEntries.end()) return false;
    for (const auto& e : it->second) {
      if (e.srcScheme == srcScheme && e.dstScheme == dstScheme) return true;
    }
    return false;
  }

  std::map<std::string, std::vector<TechniqueEntry>> mMaterialEntries;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 默认 scheme 技术
  Material mat("stone");
  Technique* defaultTech = new Technique("Default", 0);
  defaultTech->setProgrammable(false);
  defaultTech->name = "stone/default";
  mat.addTechnique(defaultTech);

  // 活动 scheme 为 Default:取默认技术
  CHECK(mat.getBestTechnique("Default", 0) == defaultTech);
  CHECK(mat.getBestTechnique("Default", 0)->name == "stone/default");

  // RTSS 生成着色器技术,scheme = "RTSS"
  RTSS rt;
  CHECK(rt.createShaderBasedTechnique(mat, "Default", "RTSS"));
  CHECK(rt.hasShaderBasedTechnique("stone", "Default", "RTSS"));
  Technique* rtssTech = mat.getBestTechnique("RTSS", 0);
  CHECK(rtssTech != nullptr);
  CHECK(rtssTech != defaultTech);
  CHECK(rtssTech->getSchemeName() == "RTSS");
  CHECK(rtssTech->isProgrammable());
  CHECK(rtssTech->name == "stone/RTSS");

  // 活动 scheme 未知时回落默认 scheme
  CHECK(mat.getBestTechnique("NoSuchScheme", 0) == defaultTech);

  // 同一 dst scheme 已被占用:再次生成被拒绝
  CHECK(!rt.createShaderBasedTechnique(mat, "Default", "RTSS"));

  // 无 FFP 源技术的材质:生成失败
  Material mat2("mat2");
  Technique* prog = new Technique("Default", 0);
  prog->setProgrammable(true);
  mat2.addTechnique(prog);
  CHECK(!rt.createShaderBasedTechnique(mat2, "Default", "RTSS"));
  CHECK(!rt.hasShaderBasedTechnique("mat2", "Default", "RTSS"));

  delete defaultTech;
  delete rtssTech;
  delete prog;

  return lab::report("14-3 RTSS 与场景集成");
}

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

小结

  • 材质按 (scheme, LOD) 分桶存技术,getBestTechnique 用活动 scheme 取技术。
  • scheme 缺失回落默认 scheme;LOD 缺失取下一级更低 LOD。
  • createShaderBasedTechnique 把源技术登记为 SGTechnique 条目:同映射幂等,同目标 scheme 不同源冲突拒绝。
  • RTSS 生成的技术挂到目标 scheme,活动 scheme 切换后 getBestTechnique 自然命中。
  • 回路对场景透明:视图层切 scheme,对象层无感。

阅读导航:上一节:14.2 子渲染状态 · 下一节:15.1 场景装配 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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