《OGRE 3D 渲染引擎原理与架构》6.1 高级着色器程序

高级着色器程序 HighLevelGpuProgram 是低层 GpuProgram 的壳:持有 mAssemblerProgram 低层程序、入口点与预处理器定义,参数经 createParameters 从程序本身创建。lab 复现高级程序的语言标识、低层委托与 GpuProgramManager 按语言工厂分发。

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」的落点。

源码定位

上游引用固定到 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 着色器参数绑定 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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