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 消费。
源码定位
Components/RTShaderSystem/include/OgreShaderGenerator.h:ShaderGenerator(62-327)、addSubRenderStateFactory(216)、createShaderBasedTechnique(284/287)、hasShaderBasedTechnique(267)Components/RTShaderSystem/src/OgreShaderGenerator.cpp:addSubRenderStateFactory(388-402)、getNumSubRenderStateFactories(405-408)、createSubRenderState(454-469)、hasShaderBasedTechnique(688-713)、findSourceTechnique/createShaderBasedTechnique(715-756)
上游引用固定到 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 子渲染状态 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。