《OGRE 3D 渲染引擎原理与架构》3.1 GPU 程序抽象

GPU 程序(顶点/片元着色器)在 OGRE 里是一种 Resource:GpuProgramType 用 uint8 枚举做类型标签,GpuProgram 持有 mSource/mSyntaxCode/mType 并把 loadFromSource() 留给子类;GpuProgramManager 按 language 字符串注册工厂分发创建。lab 复现类型标签、抽象类与工厂路由。

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、语言键控工厂表、未注册语言返回空指针的兜底行为。

源码定位

上游引用固定到 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 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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