3.1 GPU 程序抽象
GPU 程序(着色器)不是普通的网格数据,它有自己的生命周期:从源码字符串(或文件)到语法解析、编译、绑定参数、最终交给渲染系统执行。OGRE 把它建模成一个 Resource——和纹理、Mesh 一样走「prepare / load / unload」资源管线。这一节先看它最外层的两张皮:类型标签(这个程序是顶点还是片元)和语言分派(这段代码用汇编还是 GLSL 写的、该交给哪个工厂去造实例)。
本章与站内既有内容的分工
卷一 8.x 从资源管理视角介绍过 Resource 基类;helio 四卷的「着色器模块」用从零实现的方式讲了 GPU 管线的执行语义。这里从渲染系统的角度看:OGRE 如何用枚举 + 抽象类 + 语言键控工厂三步把「一段程序代码」变成「一个可绑定、可加载的资源对象」,以及类型标签如何在渲染后端选择阶段起作用。
类型标签:GpuProgramType
程序类型在 OGRE 里是一个很薄的 uint8 枚举,排在 GpuProgram.h 开头:
// OgreMain/include/OgreGpuProgram.h:GpuProgramType(v14.6.3 源码摘录,已删减)
/** Enumerates the types of programs which can run on the GPU. */
enum GpuProgramType : uint8
{
GPT_VERTEX_PROGRAM = 0,
GPT_FRAGMENT_PROGRAM,
GPT_GEOMETRY_PROGRAM,
GPT_DOMAIN_PROGRAM,
GPT_HULL_PROGRAM,
GPT_MESH_PROGRAM, // aliases with vertex
GPT_COMPUTE_PROGRAM, // aliases with fragment
GPT_TASK_PROGRAM
};
enum {
GPT_COUNT = GPT_TASK_PROGRAM + 1,
/// max programs that can be active in a pipeline (e.g compute is separate)
GPT_PIPELINE_COUNT = GPT_HULL_PROGRAM + 1
};
要点:
| 项 | 含义 |
|---|---|
uint8 底层 | 一个字节的类型标签,值从 0 递增 |
GPT_MESH_PROGRAM 注释 | 「aliases with vertex」,后处理网格程序复用顶点阶段的槽位 |
GPT_COMPUTE_PROGRAM 注释 | 「aliases with fragment」,计算程序复用片元阶段的槽位 |
GPT_PIPELINE_COUNT | 活跃管线里最多同时存在的程序数(compute 单独) |
枚举值本身只是标签;可读名字由 getProgramTypeName() 给出。OGRE 在 OgreGpuProgram.cpp 里用 switch 把枚举翻译成字符串:
// OgreMain/src/OgreGpuProgram.cpp:getProgramTypeName(v14.6.3 源码摘录,已删减)
const String GpuProgram::getProgramTypeName(GpuProgramType programType)
{
switch (programType)
{
case GPT_VERTEX_PROGRAM:
return "vertex";
case GPT_GEOMETRY_PROGRAM:
return "geometry";
case GPT_FRAGMENT_PROGRAM:
return "fragment";
case GPT_DOMAIN_PROGRAM:
return "domain";
case GPT_HULL_PROGRAM:
return "hull";
case GPT_COMPUTE_PROGRAM:
return "compute";
这里「mesh」对用户更友好,而内部始终用数值类型。.program 脚本里写 type vertex_program 时,命令处理器先把字符串解析回枚举再存进 mType——字符串与枚举的双向往返是这套抽象的地基。
抽象资源:GpuProgram
GpuProgram 本身是抽象类(loadFromSource() 纯虚),只负责保存「一段程序的原材料与描述」:
// OgreMain/include/OgreGpuProgram.h:GpuProgram 成员(v14.6.3 源码摘录,已删减)
class _OgreExport GpuProgram : public Resource
{
protected:
/// The name of the file to load source from (may be blank)
String mFilename;
/// The assembler source of the program (may be blank until file loaded)
String mSource;
/// Syntax code e.g. arbvp1, vs_2_0 etc
String mSyntaxCode;
/// The type of the program
GpuProgramType mType;
/// Whether we need to load source from file or not
bool mLoadFromFile;
四个成员各司其职:mSource 存汇编源码(或空直到从文件加载),mSyntaxCode 记语法代号(arbvp1、vs_2_0),mType 记类型,mLoadFromFile 决定 load 时是读文件还是用内存字符串。类尾部还留了一个纯虚接口让子类真正把源码喂给编译:
// OgreMain/include/OgreGpuProgram.h:loadFromSource 声明(v14.6.3 源码摘录,已删减)
protected:
/// Virtual method which must be implemented by subclasses, load from mSource
virtual void loadFromSource(void) = 0;
};
低层汇编程序的「语言」固定是 asm。getLanguage() 在基类直接写死:
// OgreMain/src/OgreGpuProgram.cpp:getLanguage(v14.6.3 源码摘录,已删减)
const String& GpuProgram::getLanguage(void) const
{
static const String language = "asm";
return language;
}
GpuProgram 派生树大致是:基类管汇编;HighLevelGpuProgram 管 GLSL/HLSL/Cg 等高级语言,它返回 glsl/hlsl/cg 这类语言名。高级程序与汇编程序在 GpuProgramManager 里由语言字符串分流——这是下一步的入口。
语言键控工厂:GpuProgramManager
既然程序按语言分流,创建实例就不能硬编码一个类。OGRE 用工厂表:语言字符串 → 工厂对象。
// 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; }
};
工厂接口对称:getLanguage() 声明自己管哪种语言,create() 造实例,destroy() 回收。管理器持有这张表并对外提供查表与创建:
// OgreMain/include/OgreGpuProgramManager.h:GpuProgramManager 工厂表(v14.6.3 源码摘录,已删减)
class _OgreExport GpuProgramManager : public ResourceManager, public Singleton<GpuProgramManager>
{
// silence warnings
using ResourceManager::load;
/// Factories capable of creating GpuProgram instances
typedef std::map<String, GpuProgramFactory*> FactoryMap;
FactoryMap mFactories;
addFactory() / removeFactory() 增删条目;创建程序时按语言查表:
// OgreMain/include/OgreGpuProgramManager.h:create(v14.6.3 源码摘录,已删减)
GpuProgramPtr create(const String& name, const String& group,
GpuProgramType gptype, const String& language, bool isManual = false,
ManualResourceLoader* loader = 0);
实际创建在 createImpl() 里先 getFactory(language),查不到就落到 mNullFactory(一个「什么也不干」的兜底工厂)。这套「语言 → 工厂」映射是 OGRE 插件化扩展着色语言的机制:写一个插件,注册一个 GpuProgramFactory 子类,OGRE 就能创建该语言的新程序,无需改动核心代码。
lab 里复现了这条完整链路:类型标签、抽象基类、getProgramTypeName、语言键控工厂表、未注册语言返回空指针的兜底行为。
源码定位
OgreMain/include/OgreGpuProgram.h:GpuProgramType(47-58)、GpuProgram类(74-)、loadFromSource纯虚(369)OgreMain/src/OgreGpuProgram.cpp:getProgramTypeName(362-387)、getLanguage(422-427)OgreMain/include/OgreGpuProgramManager.h:GpuProgramFactory(48-57)、GpuProgramManager与mFactories(68-83)、create(204-206)、addFactory(289)
上游引用固定到 OGRE v14.6.3 源码 。
可运行产物:C++ 最小验证
下面复现类型标签、抽象程序基类与语言工厂路由。它与 src/03-1-gpu-program.cpp 逐字节一致:
// file: src/03-1-gpu-program.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/03-1-gpu-program.cpp -o bin/03-1-gpu-program && ./bin/03-1-gpu-program
//
// 复现 GpuProgram 抽象与 GpuProgramManager 工厂(对应 OgreGpuProgram.h 47-58、OgreGpuProgramManager.h 48-83):
// GpuProgramType 用 uint8 枚举标签顶点/片元等程序类型,getProgramTypeName 给出可读名;
// GpuProgram 是抽象资源:持有 mSource/mSyntaxCode/mType,loadFromSource() 留给子类实现;
// GpuProgramManager 按 language 字符串注册工厂,createProgram 通过 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
};
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";
}
return "unknown";
}
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; }
void setName(const std::string& n) { mName = n; }
const std::string& getName() const { return mName; }
const std::string& getLanguage() const { return mLanguage; } // 低层汇编固定 "asm"
void load() { loadFromSource(); }
virtual bool isLoaded() const { return false; }
protected:
virtual void loadFromSource() = 0;
std::string mName;
std::string mSource;
std::string mSyntaxCode;
GpuProgramType mType = GPT_VERTEX_PROGRAM;
std::string mLanguage = "asm";
};
class AsmGpuProgram : public GpuProgram {
protected:
void loadFromSource() override { mLoaded = true; }
public:
bool isLoaded() const override { return mLoaded; }
bool mLoaded = false;
};
class GpuProgramFactory {
public:
virtual ~GpuProgramFactory() = default;
virtual const std::string& getLanguage() const = 0;
virtual std::unique_ptr<GpuProgram> create() const = 0;
};
class AsmFactory : public GpuProgramFactory {
public:
const std::string& getLanguage() const override { return mLanguage; }
std::unique_ptr<GpuProgram> create() const override {
return std::make_unique<AsmGpuProgram>();
}
private:
std::string mLanguage = "asm";
};
class GpuProgramManager {
public:
using FactoryMap = std::map<std::string, GpuProgramFactory*>;
void addFactory(GpuProgramFactory* f) { mFactories[f->getLanguage()] = f; }
void removeFactory(const std::string& lang) { mFactories.erase(lang); }
GpuProgramFactory* getFactory(const std::string& lang) {
auto it = mFactories.find(lang);
return it == mFactories.end() ? nullptr : it->second;
}
std::unique_ptr<GpuProgram> createProgram(const std::string& name,
const std::string& language,
GpuProgramType type) {
GpuProgramFactory* f = getFactory(language);
auto prog = f ? f->create() : nullptr;
if (prog) {
prog->setName(name);
prog->setType(type);
}
return prog;
}
const FactoryMap& getFactories() const { return mFactories; }
private:
FactoryMap mFactories;
};
} // namespace ogre_repro
int main() {
using namespace ogre_repro;
// GpuProgramType 是 uint8 标签,值从 0 开始递增
CHECK(GPT_VERTEX_PROGRAM == 0);
CHECK(GPT_FRAGMENT_PROGRAM == 1);
CHECK(GPT_GEOMETRY_PROGRAM == 2);
CHECK(GPT_COMPUTE_PROGRAM == 3);
// getProgramTypeName 给出人类可读名(对应 OgreGpuProgram.cpp 362-)
CHECK_EQ(std::string(getProgramTypeName(GPT_VERTEX_PROGRAM)), std::string("vertex"));
CHECK_EQ(std::string(getProgramTypeName(GPT_FRAGMENT_PROGRAM)), std::string("fragment"));
// 未注册语言时 getFactory 返回空
GpuProgramManager mgr;
CHECK(mgr.getFactory("asm") == nullptr);
// 注册 asm 工厂,语言即键
AsmFactory asmFactory;
mgr.addFactory(&asmFactory);
CHECK(mgr.getFactory("asm") == &asmFactory);
CHECK_EQ(std::string(mgr.getFactory("asm")->getLanguage()), std::string("asm"));
// 通过工厂创建程序:走 getFactory -> create
auto prog = mgr.createProgram("main_vs", "asm", GPT_VERTEX_PROGRAM);
CHECK(prog != nullptr);
CHECK(prog->getType() == GPT_VERTEX_PROGRAM);
CHECK_EQ(prog->getName(), std::string("main_vs"));
CHECK_EQ(prog->getLanguage(), std::string("asm")); // 低层默认 asm
// 语法/源码在 load 前设置,load 触发子类 loadFromSource
prog->setSyntaxCode("arbvp1");
CHECK_EQ(prog->getSyntaxCode(), std::string("arbvp1"));
prog->setSource("!!ARBvp1.0\n");
CHECK_EQ(prog->getSource(), std::string("!!ARBvp1.0\n"));
CHECK(!prog->isLoaded());
prog->load();
CHECK(prog->isLoaded()); // AsmGpuProgram::loadFromSource 置位
// 未注册语言(如 hlsl)创建失败
auto missing = mgr.createProgram("bad", "hlsl", GPT_FRAGMENT_PROGRAM);
CHECK(missing == nullptr);
// removeFactory 后 getFactory 返回空
mgr.removeFactory("asm");
CHECK(mgr.getFactory("asm") == nullptr);
return lab::report("03-1 GPU 程序抽象");
}
本机实测(Apple clang 16,clang++ -std=c++20):编译通过(-Wall 零警告),断言 19/19 通过。
小结
GpuProgramType是uint8枚举标签(顶点=0、片元=1、…),getProgramTypeName()给出可读名。GpuProgram是抽象资源,持有mSource/mSyntaxCode/mType,loadFromSource()纯虚留给子类。- 低层汇编程序
getLanguage()固定返回"asm";高级语言(GLSL/HLSL)由派生类覆盖。 GpuProgramManager用std::map<String, GpuProgramFactory*>按语言分派创建,未注册语言落到空工厂。- 语言键控工厂让 OGRE 能以插件方式扩展任意着色语言。
阅读导航:上一节:2.3 索引缓冲 · 下一节:3.2 参数缓冲 GpuProgramParameters 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。