6.1 高级着色器程序
卷二 3.x 已经见过 GpuProgram——用汇编(ARBVP1、vs_2_0 之类)写死的低层程序,语法码直接对应 API。但这要求每个目标 API 各写一份,很不方便。OGRE 的解法是再包一层:HighLevelGpuProgram,把 GLSL、HLSL、Cg 这类高级语言写成的高层程序统一接进来,运行时编译成当前 API 能吃的低层程序。这一节看这层壳怎么定义、语言怎么标识、管理器怎么按语言把它造出来。
本章与站内既有内容的分工
卷二 3.1《GPU 程序抽象》讲了低层 GpuProgram 与 GpuProgramManager 的工厂结构;这一节的 HighLevelGpuProgram 正是压在那层之上的壳,重点在「语言」这一维:getLanguage()、预处理器定义、入口点、低层委托,以及管理器如何按语言字符串把高级程序分发给对应工厂。卷三 8.x 再往下走是 GLSLang/Vulkan 对 SPIR-V 的编译细节。
GpuProgram 的语言标识:默认 asm
每个 GPU 程序都回答「我是哪种语言」。低层汇编程序没有选择的余地,GpuProgram::getLanguage() 用一个 static 常量固定返回 "asm":
// OgreMain/src/OgreGpuProgram.cpp:GpuProgram::getLanguage(v14.6.3 源码摘录,已删减)
const String& GpuProgram::getLanguage(void) const
{
static const String language = "asm";
return language;
}
注意返回值是 const String&,指向一个函数内 static 对象——语言标签是进程级常量,不存在每实例一份的开销。材料脚本里 language glsl 这种写法,正是在把「语言」这个词喂给 GpuProgramManager 做工厂查表(见后文)。
HighLevelGpuProgram:从高级语言到低层汇编的壳
HighLevelGpuProgram 继承 GpuProgram,在低层程序之上补了高级语言需要的全部状态:是否已加载高层部分、名字到参数的映射是否已建、编译产物(低层汇编程序)放哪、预处理器定义与入口点是什么:
// OgreMain/include/OgreHighLevelGpuProgram.h:HighLevelGpuProgram(v14.6.3 源码摘录,已删减)
class _OgreExport HighLevelGpuProgram : public GpuProgram
{
protected:
/// Whether the high-level program (and it's parameter defs) is loaded
bool mHighLevelLoaded;
/// Have we built the name->index parameter map yet?
bool mConstantDefsBuilt;
/// The underlying assembler program
GpuProgramPtr mAssemblerProgram;
/// Preprocessor options
String mPreprocessorDefines;
/// Entry point for this program
String mEntryPoint;
/// in-situ parsing of defines
static std::vector<std::pair<const char*, const char*>> parseDefines(String& defines);
String appendBuiltinDefines(String defines);
/// Internal load high-level portion if not loaded
virtual void loadHighLevel(void);
/// Internal unload high-level portion if loaded
virtual void unloadHighLevel(void);
/** Internal method for creating an appropriate low-level program from this
high-level program, must be implemented by subclasses. */
virtual void createLowLevelImpl(void) = 0;
/// Internal unload implementation, must be implemented by subclasses
virtual void unloadHighLevelImpl(void) = 0;
/// Populate the passed parameters with name->index map
void populateParameterNames(const GpuProgramParametersSharedPtr& params);
/** Build the constant definition map, must be overridden.
...
virtual void buildConstantDefinitions() = 0;
/** @copydoc Resource::loadImpl */
void loadImpl() override;
/** @copydoc Resource::unloadImpl */
void unloadImpl() override;
void setupBaseParamDictionary() override;
public:
/** Constructor, should be used only by factory classes. */
HighLevelGpuProgram(ResourceManager* creator, const String& name, ResourceHandle handle,
const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
~HighLevelGpuProgram();
/** Creates a new parameters object compatible with this program definition.
...
GpuProgramParametersSharedPtr createParameters(void) override;
/** @copydoc GpuProgram::_getBindingDelegate */
GpuProgram* _getBindingDelegate(void) override { return mAssemblerProgram.get(); }
...
void setPreprocessorDefines(const String& defines) { mPreprocessorDefines = defines; }
/** Gets the preprocessor defines used to compile the program. */
const String& getPreprocessorDefines(void) const { return mPreprocessorDefines; }
/** Sets the entry point for this program i.e, the first method called. */
void setEntryPoint(const String& entryPoint) { mEntryPoint = entryPoint; }
/** Gets the entry point defined for this program. */
const String& getEntryPoint(void) const { return mEntryPoint; }
| 成员 | 含义 |
|---|---|
mHighLevelLoaded | 高层部分(与参数定义)是否已加载 |
mConstantDefsBuilt | 名字到参数索引的映射是否已构建 |
mAssemblerProgram | 编译出的低层汇编程序,_getBindingDelegate 把管线绑定委托给它 |
mPreprocessorDefines | 编译时预处理器选项(MAX_LIGHTS=4 之类) |
mEntryPoint | 入口点,构造默认 "main"(OgreHighLevelGpuProgram.cpp 第 76 行) |
关键在 createLowLevelImpl() 是纯虚、buildConstantDefinitions() 也是纯虚——「高级语言怎么编译成低层程序」「怎么扫出 uniform 列表」都留给语言插件实现(GLSLang 插件的 GLSLangProgram 就负责这两件)。createParameters() 也有讲究:低层程序的参数对象由 GpuProgramManager 统一创建,而高级程序的参数对象「必须从程序本身创建」,因为只有程序自己知道有哪些命名常量——实现里先 safePrepare() 加载源码、再 populateParameterNames(params) 把名字到索引的映射挂上去。
管理器:按语言字符串分发
HighLevelGpuProgramManager.h 只有一行 #include "OgreGpuProgramManager.h"——高层管理器就是低层管理器,共享同一张工厂表。工厂的键是语言名:
// OgreMain/include/OgreGpuProgramManager.h:GpuProgramFactory(v14.6.3 源码摘录,已删减)
class _OgreExport GpuProgramFactory : public FactoryAlloc
{
public:
virtual ~GpuProgramFactory() {}
/// Get the name of the language this factory creates programs for
virtual const String& getLanguage(void) const = 0;
virtual GpuProgram* create(ResourceManager* creator, const String& name, ResourceHandle handle,
const String& group, bool isManual, ManualResourceLoader* loader) = 0;
virtual void destroy(GpuProgram* prog) { delete prog; }
};
create() 先把语言名翻译成工厂指针,再由工厂造对象并补 type/syntaxCode;createProgramFromString() 在 create() 之后把源码字符串写进去:
// OgreMain/src/OgreGpuProgramManager.cpp:GpuProgramManager::create / createProgramFromString(v14.6.3 源码摘录,已删减)
GpuProgramPtr GpuProgramManager::create(const String& name, const String& group, GpuProgramType gptype,
const String& syntaxCode, bool isManual,
ManualResourceLoader* loader)
{
auto prg = getFactory(syntaxCode)->create(this, name, getNextHandle(), group, isManual, loader);
prg->setType(gptype);
prg->setSyntaxCode(syntaxCode);
ResourcePtr ret(prg);
addImpl(ret);
...
}
...
GpuProgramPtr GpuProgramManager::createProgramFromString(const String& name,
const String& groupName, const String& code, GpuProgramType gptype,
const String& syntaxCode)
{
GpuProgramPtr prg = createProgram(name, groupName, syntaxCode, gptype);
prg->setSource(code);
return prg;
}
查表失败时 getFactory 回退到 sNullLang 的「空工厂」,造出永远不会被支持的占位程序而不是崩掉。语言插件在 install() 里 addFactory,同一个插件把 GLSL/HLSL 的工厂注册进同一张表——这就是「高级语言不侵入核心 API」的落点。
源码定位
OgreMain/include/OgreHighLevelGpuProgram.h:HighLevelGpuProgram(64-146)、createParameters(122)、_getBindingDelegate(124)、setPreprocessorDefines/setEntryPoint(135-142)OgreMain/src/OgreHighLevelGpuProgram.cpp:createParameters(115-138)、populateParameterNames(269-275)OgreMain/include/OgreGpuProgram.h:GpuProgram(74-)、getLanguage(318)OgreMain/src/OgreGpuProgram.cpp:getLanguage(422-427)OgreMain/include/OgreGpuProgramManager.h:GpuProgramFactory(48-57)、GpuProgramManager(68-)OgreMain/src/OgreGpuProgramManager.cpp:create(185-199)、createProgramFromString(210-217)、addFactory/getFactory(429-456)OgreMain/include/OgreHighLevelGpuProgramManager.h:仅#include "OgreGpuProgramManager.h"
上游引用固定到 OGRE v14.6.3 源码 。
可运行产物:C++ 最小验证
下面复现高级程序的壳:低层程序语言固定 "asm"、高级程序默认入口点 "main"、createParameters() 从程序本身创建、_getBindingDelegate() 委托到低层汇编程序,以及管理器按语言字符串分发 createProgramFromString。它与 src/ogre-ext-06-1-high-level-gpu-program.cpp 逐字节一致:
// file: src/ogre-ext-06-1-high-level-gpu-program.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/ogre-ext-06-1-high-level-gpu-program.cpp -o bin/ogre-ext-06-1-high-level-gpu-program && ./bin/ogre-ext-06-1-high-level-gpu-program
//
// 复现 HighLevelGpuProgram 抽象与 GpuProgramManager 工厂分发
// (对应 OgreHighLevelGpuProgram.h 64-146、OgreGpuProgram.h 74-371、OgreGpuProgramManager.cpp 185-217):
// GpuProgram 是低层程序,getLanguage() 固定返回 "asm"(OgreGpuProgram.cpp 422-427);
// HighLevelGpuProgram 继承它,持有 mEntryPoint/mPreprocessorDefines/mAssemblerProgram,
// 入口点默认 "main",_getBindingDelegate 委托到低层汇编程序;
// GpuProgramManager 按 language 字符串注册工厂,create/createProgramFromString 走 getFactory 分发。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"
#include <cstdint>
#include <map>
#include <memory>
#include <string>
namespace ogre_repro {
enum GpuProgramType : uint8_t {
GPT_VERTEX_PROGRAM = 0,
GPT_FRAGMENT_PROGRAM,
GPT_GEOMETRY_PROGRAM,
GPT_COMPUTE_PROGRAM,
GPT_COUNT
};
const char* getProgramTypeName(GpuProgramType t) {
switch (t) {
case GPT_VERTEX_PROGRAM:
return "vertex";
case GPT_GEOMETRY_PROGRAM:
return "geometry";
case GPT_FRAGMENT_PROGRAM:
return "fragment";
case GPT_COMPUTE_PROGRAM:
return "compute";
case GPT_COUNT:
return "count";
}
return "unknown";
}
// 对应 GpuProgramParameters 的极简形式(OgreGpuProgramParams.h 467-)
class GpuProgramParameters {
public:
explicit GpuProgramParameters(const std::string& lang) : mLanguage(lang) {}
const std::string& getLanguage() const { return mLanguage; }
private:
std::string mLanguage;
};
// 对应 GpuProgram(OgreGpuProgram.h 74-):低层程序,语言固定 asm
class GpuProgram {
public:
GpuProgram() = default;
virtual ~GpuProgram() = default;
void setSource(const std::string& s) { mSource = s; }
const std::string& getSource() const { return mSource; }
void setSyntaxCode(const std::string& s) { mSyntaxCode = s; }
const std::string& getSyntaxCode() const { return mSyntaxCode; }
void setType(GpuProgramType t) { mType = t; }
GpuProgramType getType() const { return mType; }
virtual const std::string& getLanguage() const {
static const std::string asmLang = "asm"; // OgreGpuProgram.cpp 422-427
return asmLang;
}
virtual std::shared_ptr<GpuProgramParameters> createParameters() {
return std::make_shared<GpuProgramParameters>(getLanguage());
}
protected:
std::string mSource;
std::string mSyntaxCode;
GpuProgramType mType = GPT_VERTEX_PROGRAM;
};
// 对应 HighLevelGpuProgram(OgreHighLevelGpuProgram.h 64-146)
class HighLevelGpuProgram : public GpuProgram {
public:
HighLevelGpuProgram() = default;
void setPreprocessorDefines(const std::string& d) { mPreprocessorDefines = d; }
const std::string& getPreprocessorDefines() const { return mPreprocessorDefines; }
void setEntryPoint(const std::string& e) { mEntryPoint = e; }
const std::string& getEntryPoint() const { return mEntryPoint; }
void setAssemblerProgram(std::shared_ptr<GpuProgram> p) { mAssemblerProgram = p; }
// _getBindingDelegate(OgreHighLevelGpuProgram.h 124-)
GpuProgram* getBindingDelegate() {
return mAssemblerProgram ? mAssemblerProgram.get() : this;
}
// createParameters(OgreHighLevelGpuProgram.cpp 115-138):
// 参数对象从程序本身创建,populateParameterNames 后带上命名常量
std::shared_ptr<GpuProgramParameters> createParameters() override {
auto params = std::make_shared<GpuProgramParameters>(getLanguage());
populateParameterNames();
return params;
}
virtual void buildConstantDefinitions() = 0;
protected:
// populateParameterNames(OgreHighLevelGpuProgram.cpp 269-275)
void populateParameterNames() {
getConstantDefinitions();
}
virtual const std::map<std::string, uint32_t>& getConstantDefinitions() = 0;
std::string mPreprocessorDefines;
std::string mEntryPoint = "main"; // 构造默认(OgreHighLevelGpuProgram.cpp 76)
std::shared_ptr<GpuProgram> mAssemblerProgram;
};
// 对应 GLSLangProgram / GLSL 类高级程序(OgreGLSLangProgramManager.h 29-45)
class GlslProgram : public HighLevelGpuProgram {
public:
const std::string& getLanguage() const override {
static const std::string lang = "glsl";
return lang;
}
void buildConstantDefinitions() override {
// 真实实现用反射扫 uniform 并填充 mConstantDefs,这里登记两个命名常量
mConstantDefs = {{"world_matrix", 0u}, {"time", 4u}};
}
const std::map<std::string, uint32_t>& getConstantDefinitions() override {
return mConstantDefs;
}
private:
std::map<std::string, uint32_t> mConstantDefs;
};
// 对应 GpuProgramFactory(OgreGpuProgramManager.h 48-57)
class GpuProgramFactory {
public:
virtual ~GpuProgramFactory() = default;
virtual const std::string& getLanguage() const = 0;
virtual std::shared_ptr<GpuProgram> create() const = 0;
};
class GlslFactory : public GpuProgramFactory {
public:
const std::string& getLanguage() const override {
static const std::string lang = "glsl";
return lang;
}
std::shared_ptr<GpuProgram> create() const override {
return std::make_shared<GlslProgram>();
}
};
// 对应 GpuProgramManager(OgreGpuProgramManager.h 68-)
class GpuProgramManager {
public:
using FactoryMap = std::map<std::string, GpuProgramFactory*>;
void addFactory(GpuProgramFactory* f) { mFactories[f->getLanguage()] = f; }
void removeFactory(GpuProgramFactory* f) {
auto it = mFactories.find(f->getLanguage());
if (it != mFactories.end() && it->second == f) mFactories.erase(it);
}
GpuProgramFactory* getFactory(const std::string& lang) {
auto it = mFactories.find(lang);
return it == mFactories.end() ? nullptr : it->second;
}
// create(OgreGpuProgramManager.cpp 185-199):getFactory(language)->create + setType/setSyntaxCode
std::shared_ptr<GpuProgram> create(GpuProgramType gptype, const std::string& language) {
GpuProgramFactory* f = getFactory(language);
if (!f) return nullptr;
auto prg = f->create();
prg->setType(gptype);
prg->setSyntaxCode(language);
return prg;
}
// createProgramFromString(OgreGpuProgramManager.cpp 210-217)
std::shared_ptr<GpuProgram> createProgramFromString(GpuProgramType gptype,
const std::string& language,
const std::string& code) {
auto prg = create(gptype, language);
if (prg) prg->setSource(code);
return prg;
}
private:
FactoryMap mFactories;
};
} // namespace ogre_repro
int main() {
using namespace ogre_repro;
// GpuProgramType 是 uint8 标签,值从 0 递增
CHECK(GPT_VERTEX_PROGRAM == 0);
CHECK_EQ(std::string(getProgramTypeName(GPT_FRAGMENT_PROGRAM)), std::string("fragment"));
// 低层程序语言固定 asm(OgreGpuProgram.cpp 422-427)
GpuProgram asmProg;
CHECK_EQ(asmProg.getLanguage(), std::string("asm"));
// 高级程序默认入口点 main、低层委托缺省指向自身
GlslProgram glsl;
CHECK_EQ(glsl.getEntryPoint(), std::string("main"));
CHECK(glsl.getBindingDelegate() == static_cast<GpuProgram*>(&glsl));
// setPreprocessorDefines / setEntryPoint
glsl.setPreprocessorDefines("MAX_LIGHTS=4");
CHECK_EQ(glsl.getPreprocessorDefines(), std::string("MAX_LIGHTS=4"));
glsl.setEntryPoint("main_vs");
CHECK_EQ(glsl.getEntryPoint(), std::string("main_vs"));
// createParameters 从高级程序创建,携带语言(OgreHighLevelGpuProgram.cpp 115-138)
auto params = glsl.createParameters();
CHECK(params != nullptr);
CHECK_EQ(params->getLanguage(), std::string("glsl"));
// buildConstantDefinitions 填充命名常量(world_matrix -> physical 0)
glsl.buildConstantDefinitions();
CHECK(glsl.getConstantDefinitions().at("world_matrix") == 0u);
// 低级汇编程序委托(OgreHighLevelGpuProgram.h 124-)
auto asmImpl = std::make_shared<GpuProgram>();
asmImpl->setSource("!!ARBvp1.0");
glsl.setAssemblerProgram(asmImpl);
CHECK(glsl.getBindingDelegate() == asmImpl.get());
// 工厂分发:未注册语言返回空
GpuProgramManager mgr;
CHECK(mgr.getFactory("glsl") == nullptr);
GlslFactory factory;
mgr.addFactory(&factory);
CHECK(mgr.getFactory("glsl") == &factory);
// createProgramFromString 走 getFactory -> create -> setSource(OgreGpuProgramManager.cpp 210-217)
auto prog = mgr.createProgramFromString(GPT_VERTEX_PROGRAM, "glsl", "void main(){}");
CHECK(prog != nullptr);
CHECK(prog->getType() == GPT_VERTEX_PROGRAM);
CHECK_EQ(prog->getLanguage(), std::string("glsl"));
CHECK_EQ(prog->getSource(), std::string("void main(){}"));
CHECK_EQ(prog->getSyntaxCode(), std::string("glsl"));
// 未注册语言(如 hlsl)创建失败
auto missing = mgr.create(GPT_FRAGMENT_PROGRAM, "hlsl");
CHECK(missing == nullptr);
// removeFactory 后 getFactory 返回空
mgr.removeFactory(&factory);
CHECK(mgr.getFactory("glsl") == nullptr);
return lab::report("06-1 高级着色器程序");
}
本机实测(Apple clang,clang++ -std=c++20 -Wall):编译通过(零警告),断言 20/20 通过。
小结
GpuProgram::getLanguage()固定返回"asm";高级语言靠HighLevelGpuProgram子类各自覆写。HighLevelGpuProgram是壳:持低层程序mAssemblerProgram、入口点mEntryPoint(默认"main")与预处理器定义mPreprocessorDefines。createLowLevelImpl()与buildConstantDefinitions()是纯虚,语言插件负责实现「编译到低层」与「扫 uniform」。- 高级程序的参数对象必须从程序本身
createParameters()创建,因为命名常量映射只有程序自己知道。 - 高层管理器与低层管理器共用一张工厂表,语言名是键;
createProgramFromString走getFactory -> create -> setSource的固定管线。
阅读导航:上一节:5.3 静态几何 · 下一节:6.2 着色器参数绑定 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。