《OGRE 3D 渲染引擎原理与架构》14.1 RTSS 概览

RTSS(实时着色器系统)从既有固定管线材质自动生成着色器:ShaderGenerator 单例登记子渲染状态工厂(addSubRenderStateFactory),并把源 technique scheme 映射到目标 scheme(createShaderBasedTechnique / hasShaderBasedTechnique)。源码在 Components/RTShaderSystem/ 的 OgreShaderGenerator.h/.cpp。lab 复现工厂注册与 scheme 映射。

14.1 RTSS 概览

固定管线(FFP)材质描述「用什么状态渲染」,但现代后端要求着色器。RTSS(Real-Time Shader System,实时着色器系统)的职责就是:从既有固定管线材质自动生成对应的着色器技术。它不要求用户改写材质脚本——应用把活动 scheme 切到 RTSS 生成的 scheme,RTSS 就为每个 FFP pass 产出等价的 GPU program。

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

卷二 3.x 讲 GPU 程序的加载与参数绑定;本卷 7.3 讲地形的 TerrainMaterialGenerator(另一种材质生成器)。RTSS 是通用版:任何 FFP 材质都能生成。它不推着色器语言语法,只讲「生成管线」的组织——工厂、渲染状态、scheme 切换。本节先看总入口 ShaderGenerator。

ShaderGenerator:RTSS 的总入口

ShaderGenerator 是 RTSS 的单例主接口:

// Components/RTShaderSystem/include/OgreShaderGenerator.h:ShaderGenerator(v14.6.3 源码摘录,已删减)
/** Shader generator system main interface. This singleton based class
enables automatic generation of shader code based on existing material techniques.
*/
class _OgreRTSSExport ShaderGenerator : public Singleton<ShaderGenerator>, public RTShaderSystemAlloc
{
// Interface.
public:

    /** 
    Initialize the Shader Generator System.
    Return true upon success.
    */
    static bool initialize();

    /** 
    Destroy the Shader Generator instance.
    */
    static void destroy();

它同时继承 Singleton 与 RenderObjectListener/SceneManager 监听——前者保证全局唯一入口,后者让它在渲染单个对象前更新 GPU 参数。RTSS 还维护了 mMaterialEntriesMap(材质 → SGTechnique 条目)、mSubRenderStateFactories(类型 → 工厂)与 mSchemes(目标 scheme → 技术列表)。

子渲染状态工厂:着色器功能的插件点

RTSS 把「一段着色器功能」建模成 SubRenderState(子渲染状态),例如 FFP 光照、纹理、雾。子状态通过工厂注册进 ShaderGenerator:

// Components/RTShaderSystem/src/OgreShaderGenerator.cpp:ShaderGenerator::addSubRenderStateFactory(v14.6.3 源码摘录,已删减)
void ShaderGenerator::addSubRenderStateFactory(SubRenderStateFactory* factory)
{
    OGRE_LOCK_AUTO_MUTEX;

    SubRenderStateFactoryIterator itFind = mSubRenderStateFactories.find(factory->getType());

    if (itFind != mSubRenderStateFactories.end())
    {
        OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM,
            "A factory of type '" + factory->getType() + "' already exists.",
            "ShaderGenerator::addSubRenderStateFactory");
    }

    mSubRenderStateFactories[factory->getType()] = factory;
}

mSubRenderStateFactories 是 type -> factory 的 map,类型名唯一。getNumSubRenderStateFactories 返回注册数量;createSubRenderState(type) 找到工厂后 createInstance() 生成子状态实例,找不到则抛「类型不存在」异常。14.2 会看到这些子状态如何按执行顺序拼成一段着色器。

createShaderBasedTechnique:从源技术生成目标技术

RTSS 的核心动作是「生成」。createShaderBasedTechnique 接收源材质的 scheme(通常是 Default)与目标 scheme(如 RTSS),先从 mat.getSupportedTechniques() 里找到含固定管线 pass 的源技术:

// Components/RTShaderSystem/src/OgreShaderGenerator.cpp:createShaderBasedTechnique / findSourceTechnique(v14.6.3 源码摘录,已删减)
static bool hasFixedFunctionPass(Technique* tech)
{
    for (const auto& p : tech->getPasses())
    {
        if (!p->isProgrammable())
        {
            return true;
        }
    }
    return false;
}

static Technique* findSourceTechnique(const Material& mat, const String& srcTechniqueSchemeName, bool overProgrammable)
{
    // Find the source technique
    for (auto *t : mat.getSupportedTechniques())
    {
        if (t->getSchemeName() == srcTechniqueSchemeName && (hasFixedFunctionPass(t) || overProgrammable))
        {
            return t;
        }
    }

    return NULL;
}
//-----------------------------------------------------------------------------
bool ShaderGenerator::createShaderBasedTechnique(const Material& srcMat,
                                                 const String& srcTechniqueSchemeName,
                                                 const String& dstTechniqueSchemeName,
                                                 bool overProgrammable)
{
    // No technique created -> check if one can be created from the given source technique scheme.
    Technique* srcTechnique = findSourceTechnique(srcMat, srcTechniqueSchemeName, overProgrammable);

    // No appropriate source technique found.
    if (!srcTechnique)
    {
        return false;
    }

    return createShaderBasedTechnique(srcTechnique, dstTechniqueSchemeName, overProgrammable);
}

如果源技术里没有 FFP pass(即所有 pass 都可编程)且未要求 overProgrammable,就返回 false——RTSS 不为已有着色器的材质重复生成。找到源技术后,RTSS 登记一个 SGTechnique 条目(记录源 scheme → 目标 scheme),并把条目挂进目标 scheme 的技术列表。

hasShaderBasedTechnique 反向查询这个映射:

// Components/RTShaderSystem/src/OgreShaderGenerator.cpp:ShaderGenerator::hasShaderBasedTechnique(v14.6.3 源码摘录,已删减)
bool ShaderGenerator::hasShaderBasedTechnique(const String& materialName,
                                                 const String& groupName,
                                                 const String& srcTechniqueSchemeName,
                                                 const String& dstTechniqueSchemeName) const
{
    OGRE_LOCK_AUTO_MUTEX;

    // Make sure material exists;
    if (false == MaterialManager::getSingleton().resourceExists(materialName, groupName))
        return false;

    SGMaterialConstIterator itMatEntry = findMaterialEntryIt(materialName, groupName);

    // Check if technique already created.
    if (itMatEntry != mMaterialEntriesMap.end())
    {
        const SGTechniqueList& techniqueEntires = itMatEntry->second->getTechniqueList();
        for (auto* t : techniqueEntires) {
            // Check requested mapping already exists.
            if (t->getSourceTechnique()->getSchemeName() == srcTechniqueSchemeName && t->getDestinationTechniqueSchemeName() == dstTechniqueSchemeName)
                return true;
        }
    }
    return false;
}

一个材质、一对 (srcScheme, dstScheme) 的映射只能存在一次——重复 createShaderBasedTechnique 会直接返回 true(幂等);但如果同一 dstScheme 已被映射到不同的源技术,第二次生成返回 false(避免 scheme 冲突)。14.3 会看到这套映射表如何被 getBestTechnique 消费。

源码定位

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

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

下面用纯 C++ 复现 RTSS 的工厂注册与 scheme 映射:子渲染状态工厂注册表、按类型创建实例、从源 scheme 生成目标 scheme 的登记与查询。它与 src/14-1-rtss-overview.cpp 逐字节一致:

// file: src/14-1-rtss-overview.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/14-1-rtss-overview.cpp -o bin/14-1-rtss-overview && ./bin/14-1-rtss-overview
//
// 复现 RTSS ShaderGenerator 的子渲染状态工厂注册与着色器技术生成(对应
// Components/RTShaderSystem/include/OgreShaderGenerator.h 62-327 与
// Components/RTShaderSystem/src/OgreShaderGenerator.cpp 388-469、688-815):
//   addSubRenderStateFactory:按类型登记工厂,重名拒绝;
//   getNumSubRenderStateFactories / getSubRenderStateFactory:按序/按名取回;
//   createSubRenderState:经工厂 createInstance;
//   createShaderBasedTechnique:从源 technique scheme 找含 FFP pass 的
//   source technique,登记 srcScheme -> dstScheme 的映射;
//   hasShaderBasedTechnique:查询映射是否存在。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

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

namespace ogre_repro {

// 对应 OgreShaderSubRenderState.h 87:子渲染状态的极简形式。
class SubRenderState {
 public:
  explicit SubRenderState(const std::string& type) : mType(type) {}
  const std::string& getType() const { return mType; }
  virtual ~SubRenderState() {}

 protected:
  std::string mType;
};

// 对应 OgreShaderSubRenderState.h 中的工厂接口。
class SubRenderStateFactory {
 public:
  virtual ~SubRenderStateFactory() {}
  virtual const std::string& getType() const = 0;
  virtual SubRenderState* createInstance() = 0;
};

class FFPColourFactory : public SubRenderStateFactory {
 public:
  const std::string& getType() const override { return msType; }
  SubRenderState* createInstance() override { return new SubRenderState(msType); }
  static std::string msType;
};
std::string FFPColourFactory::msType = "FFP_Colour";

class FFPFogFactory : public SubRenderStateFactory {
 public:
  const std::string& getType() const override { return msType; }
  SubRenderState* createInstance() override { return new SubRenderState(msType); }
  static std::string msType;
};
std::string FFPFogFactory::msType = "FFP_Fog";

// 对应 ShaderGenerator(OgreShaderGenerator.h 62)。
class ShaderGenerator {
 public:
  using FactoryMap = std::map<std::string, SubRenderStateFactory*>;

  // 对应 addSubRenderStateFactory(OgreShaderGenerator.cpp 388-402)。
  void addSubRenderStateFactory(SubRenderStateFactory* factory) {
    if (mSubRenderStateFactories.find(factory->getType()) != mSubRenderStateFactories.end())
      throw std::runtime_error("A factory of type '" + factory->getType() + "' already exists.");
    mSubRenderStateFactories[factory->getType()] = factory;
  }

  // 对应 getNumSubRenderStateFactories(405-408)。
  size_t getNumSubRenderStateFactories() const { return mSubRenderStateFactories.size(); }

  // 对应 getSubRenderStateFactory(const String& type)(433-439)。
  SubRenderStateFactory* getSubRenderStateFactory(const std::string& type) {
    auto it = mSubRenderStateFactories.find(type);
    return it == mSubRenderStateFactories.end() ? nullptr : it->second;
  }

  // 对应 createSubRenderState(454-469)。
  SubRenderState* createSubRenderState(const std::string& type) {
    auto it = mSubRenderStateFactories.find(type);
    if (it == mSubRenderStateFactories.end())
      throw std::runtime_error("A factory of type '" + type + "' doesn't exists.");
    return it->second->createInstance();
  }

  // 对应 removeSubRenderStateFactory(442-451)。
  void removeSubRenderStateFactory(SubRenderStateFactory* factory) {
    mSubRenderStateFactories.erase(factory->getType());
  }

  FactoryMap mSubRenderStateFactories;
};

// 对应 Technique:一个 pass 是否 FFP(非可编程)。
class Technique {
 public:
  explicit Technique(const std::string& schemeName) : mSchemeName(schemeName) {}
  void setHasFFPPass(bool b) { mHasFFPPass = b; }
  bool hasFFPPass() const { return mHasFFPPass; }
  const std::string& getSchemeName() const { return mSchemeName; }

 private:
  std::string mSchemeName;
  bool mHasFFPPass = true;
};

// 对应 Material:一组 supported technique。
class Material {
 public:
  explicit Material(const std::string& name) : mName(name) {}
  void addTechnique(Technique* t) { mSupportedTechniques.push_back(t); }
  const std::vector<Technique*>& getSupportedTechniques() const { return mSupportedTechniques; }
  const std::string& getName() const { return mName; }

 private:
  std::string mName;
  std::vector<Technique*> mSupportedTechniques;
};

// 对应 SGTechnique 条目:src scheme -> dst scheme 映射。
struct TechniqueEntry {
  std::string srcScheme;
  std::string dstScheme;
};

// 对应 ShaderGenerator 的材质条目映射表。
class MaterialEntry {
 public:
  std::vector<TechniqueEntry> mTechniqueEntries;
};

// 对应 hasFixedFunctionPass / findSourceTechnique(OgreShaderGenerator.cpp 715-739)。
class SGRuntime {
 public:
  // 对应 createShaderBasedTechnique(const Material&, ...)(741-756):
  // 找含 FFP pass 的 source technique,找不到返回 false。
  bool createShaderBasedTechnique(const Material& mat, const std::string& srcScheme,
                                  const std::string& dstScheme) {
    Technique* srcTech = nullptr;
    for (auto* t : mat.getSupportedTechniques()) {
      if (t->getSchemeName() == srcScheme && t->hasFFPPass()) {
        srcTech = t;
        break;
      }
    }
    if (!srcTech) return false;
    return registerEntry(mat, srcTech->getSchemeName(), dstScheme);
  }

  // 对应 hasShaderBasedTechnique(688-713)。
  bool hasShaderBasedTechnique(const std::string& materialName, const std::string& srcScheme,
                               const std::string& dstScheme) const {
    auto it = mMaterialEntriesMap.find(materialName);
    if (it == mMaterialEntriesMap.end()) return false;
    for (const auto& e : it->second->mTechniqueEntries) {
      if (e.srcScheme == srcScheme && e.dstScheme == dstScheme) return true;
    }
    return false;
  }

  bool registerEntry(const Material& mat, const std::string& srcScheme,
                     const std::string& dstScheme) {
    MaterialEntry* entry = nullptr;
    auto it = mMaterialEntriesMap.find(mat.getName());
    if (it == mMaterialEntriesMap.end()) {
      entry = new MaterialEntry();
      mMaterialEntriesMap[mat.getName()] = entry;
    } else {
      entry = it->second;
      // 同一 dst scheme 已有基于不同 source 的条目:冲突,拒绝。
      for (const auto& e : entry->mTechniqueEntries) {
        if (e.dstScheme == dstScheme) return false;
      }
    }
    entry->mTechniqueEntries.push_back(TechniqueEntry{srcScheme, dstScheme});
    return true;
  }

  std::map<std::string, MaterialEntry*> mMaterialEntriesMap;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  ShaderGenerator sg;

  // 子渲染状态工厂注册表
  FFPColourFactory colourFactory;
  FFPFogFactory fogFactory;
  sg.addSubRenderStateFactory(&colourFactory);
  sg.addSubRenderStateFactory(&fogFactory);
  CHECK_EQ(sg.getNumSubRenderStateFactories(), size_t(2));
  CHECK(sg.getSubRenderStateFactory("FFP_Colour") == &colourFactory);
  CHECK(sg.getSubRenderStateFactory("FFP_Fog") == &fogFactory);
  CHECK(sg.getSubRenderStateFactory("FFP_Lighting") == nullptr);

  // 重复登记被拒绝
  bool dupFactory = false;
  try {
    sg.addSubRenderStateFactory(&colourFactory);
  } catch (const std::runtime_error&) {
    dupFactory = true;
  }
  CHECK(dupFactory);
  CHECK_EQ(sg.getNumSubRenderStateFactories(), size_t(2));

  // createSubRenderState:经工厂创建实例
  SubRenderState* fog = sg.createSubRenderState("FFP_Fog");
  CHECK(fog != nullptr);
  CHECK(fog->getType() == "FFP_Fog");
  bool unknownType = false;
  try {
    sg.createSubRenderState("FFP_Lighting");
  } catch (const std::runtime_error&) {
    unknownType = true;
  }
  CHECK(unknownType);

  // 移除工厂后不可再创建
  sg.removeSubRenderStateFactory(&fogFactory);
  CHECK_EQ(sg.getNumSubRenderStateFactories(), size_t(1));
  CHECK(sg.getSubRenderStateFactory("FFP_Fog") == nullptr);

  // createShaderBasedTechnique:从 Default scheme 生成 RTSS scheme
  Material mat("mat1");
  Technique* src = new Technique("Default");
  src->setHasFFPPass(true);
  mat.addTechnique(src);

  SGRuntime rt;
  CHECK(rt.createShaderBasedTechnique(mat, "Default", "RTSS"));
  CHECK(rt.hasShaderBasedTechnique("mat1", "Default", "RTSS"));
  CHECK(!rt.hasShaderBasedTechnique("mat1", "Default", "RTSS2"));

  // 非 FFP 的 source technique:生成失败
  Material mat2("mat2");
  Technique* src2 = new Technique("Default");
  src2->setHasFFPPass(false);
  mat2.addTechnique(src2);
  CHECK(!rt.createShaderBasedTechnique(mat2, "Default", "RTSS"));

  // 同一 dst scheme 已映射到不同 source:冲突,拒绝
  Material mat3("mat3");
  Technique* src3a = new Technique("Default");
  src3a->setHasFFPPass(true);
  mat3.addTechnique(src3a);
  Technique* src3b = new Technique("Light");
  src3b->setHasFFPPass(true);
  mat3.addTechnique(src3b);
  CHECK(rt.createShaderBasedTechnique(mat3, "Default", "RTSS"));
  CHECK(!rt.createShaderBasedTechnique(mat3, "Light", "RTSS"));

  delete fog;
  delete src;
  delete src2;
  delete src3a;
  delete src3b;
  for (auto& kv : rt.mMaterialEntriesMap) delete kv.second;

  return lab::report("14-1 RTSS 概览");
}

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

小结

  • RTSS 从既有 FFP 材质自动生成着色器技术,不改写材质脚本。
  • ShaderGenerator 是单例总入口,持有子状态工厂表、材质条目表与 scheme 表。
  • addSubRenderStateFactory 按类型注册工厂,重名拒绝;createSubRenderState 经工厂生成实例。
  • createShaderBasedTechnique 从含 FFP pass 的源技术登记 srcScheme → dstScheme 映射,无 FFP pass 则返回 false。
  • hasShaderBasedTechnique 查询映射是否已存在;同一 dstScheme 冲突时拒绝第二次生成。

阅读导航:上一节:13.3 覆盖层渲染 · 下一节:14.2 子渲染状态 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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