《OGRE 3D 渲染引擎原理与架构》9.1 Metal 渲染系统

OGRE 的 Metal 后端以 MetalRenderSystem 继承 RenderSystem:getName 自报 Metal Rendering Subsystem,MetalDevice 持有 MTLDevice 与主命令队列,首窗创建时惰性初始化并上报 16 纹理单元等能力。lab 用纯 C++ 复现设备结构、惰性初始化与能力位登记。

9.1 Metal 渲染系统

卷二第 1 章看过 RenderSystem 抽象基类,8 章看过 Vulkan 后端;这里转到 Apple 平台的官方后端——Metal。MetalRenderSystem 是 OGRE 在 macOS/iOS 上的原生路径:它把 OGRE 的渲染指令翻译成 MTLRenderCommandEncoder 调用,同时用 MetalDevice 封装 MTLDevice 与命令队列这两个全局对象。理解这一节的钥匙是「两个对象、三个时机」:设备与命令队列长什么样(对象)、什么时候初始化、什么时候上报能力。

本章与站内既有内容的分工

《游戏引擎实现原理》的 helio 四卷自实现过平台窗口与渲染上下文(MetalLayer 承载 CAMetalLayer);卷一 ogre-core 讲过 Root 选后端;这里专注 OGRE 的 Metal 后端类本身:设备封装、惰性初始化与能力上报,不与图形学原理重复。

MetalRenderSystem:继承自 RenderSystem

RenderSystems/Metal/include/OgreMetalRenderSystem.h 里,MetalRenderSystem 直接继承 RenderSystem,并把 Metal 对象作为成员按住:

// RenderSystems/Metal/include/OgreMetalRenderSystem.h:MetalRenderSystem 类定义(v14.6.3 源码摘录,已删减)
    class _OgreMetalExport MetalRenderSystem : public RenderSystem
    {
        MTLRenderPipelineDescriptor *psd;
        MTLDepthStencilDescriptor*    mDepthStencilDesc;
        ...
        MetalDevice                 *mActiveDevice;
        ...
        MetalDevice             mDevice;
        dispatch_semaphore_t    mMainGpuSyncSemaphore;
        ...
    public:
        const GpuProgramParametersPtr& getFixedFunctionParams(TrackVertexColourType tracking,
                                                                      FogMode fog) override;
        ...
        const String& getName(void) const override;
        void setConfigOption(const String &name, const String &value) override {}
        ...
        RenderSystemCapabilities* createRenderSystemCapabilities(void) const override;

三个值得注意的细节:

成员/方法含义
mDevice(按值)+ mActiveDevice(指针)系统持有一个 MetalDevice 实例,mActiveDevice 指向当前生效的那个(多 GPU 时指向别的设备)
mMainGpuSyncSemaphore信号量限制在途命令缓冲数(构造时 dispatch_semaphore_create(3),见下)
setConfigOption(...) {}空实现——Metal 后端的配置项少到不需要自定义处理

getName() 的实现直白:

// RenderSystems/Metal/src/OgreMetalRenderSystem.mm:MetalRenderSystem::getName(v14.6.3 源码摘录)
    const String& MetalRenderSystem::getName(void) const
    {
        static String strName("Metal Rendering Subsystem");
        return strName;
    }

静态局部 String 意味着每次调用返回同一份对象——Root::getAvailableRenderers 拿它当后端键时不会产生拷贝。

MetalDevice:设备与命令队列

MetalDevice 是一个结构体,不是类。OgreMetalDevice.h 的成员就是整条 Metal 工作链路:

// RenderSystems/Metal/include/OgreMetalDevice.h:MetalDevice 结构(v14.6.3 源码摘录,已删减)
    struct _OgreMetalExport MetalDevice
    {
        bool                    mFrameAborted;
        id<MTLDevice>           mDevice;
        id<MTLCommandQueue>     mMainCommandQueue;
        id<MTLCommandBuffer>    mCurrentCommandBuffer;
        id<MTLBlitCommandEncoder>   mBlitEncoder;
        id<MTLComputeCommandEncoder>mComputeEncoder;
        id<MTLRenderCommandEncoder> mRenderEncoder;
        MetalRenderSystem       *mRenderSystem;
        dispatch_semaphore_t    mStallSemaphore;
        ...
        void init(void);
        ...
        void commitAndNextCommandBuffer(void);
        ...
        void stall(void);
    };

init() 才是把 Metal 对象真正造出来的地方:

// RenderSystems/Metal/src/OgreMetalDevice.mm:MetalDevice::init(v14.6.3 源码摘录)
    void MetalDevice::init(void)
    {
        @autoreleasepool
        {
            mDevice = MTLCreateSystemDefaultDevice();
            OgreAssert(mDevice, "Could not create Metal Device");

            mMainCommandQueue = [mDevice newCommandQueue];
            mCurrentCommandBuffer = [mMainCommandQueue commandBuffer];
            mBlitEncoder = 0;
            mComputeEncoder = 0;
            mRenderEncoder = 0;
        }
    }

顺序是固定的:先取设备 → 再从设备开命令队列 → 再从队列取首个命令缓冲。mBlitEncoder/mComputeEncoder/mRenderEncoder 三种编码器一开始都是 0,用到时才由 getBlitEncoder() 等惰性创建。

首窗时的惰性初始化

Metal 后端的初始化不在构造函数里做,而是推迟到 _createRenderWindow 第一次被调用时:

// RenderSystems/Metal/src/OgreMetalRenderSystem.mm:MetalRenderSystem::_createRenderWindow(v14.6.3 源码摘录,已删减)
    RenderWindow* MetalRenderSystem::_createRenderWindow( const String &name,
                                                         unsigned int width, unsigned int height,
                                                         bool fullScreen,
                                                         const NameValuePairList *miscParams )
    {
        RenderSystem::_createRenderWindow(name, width, height, fullScreen, miscParams);
        if( !mInitialized )
        {
            // enable debug layer
            setenv("METAL_DEVICE_WRAPPER_TYPE", "1", 0);

            mDevice.init();
            setActiveDevice(&mDevice);

            const long c_inFlightCommandBuffers = 3;
            mMainGpuSyncSemaphore = dispatch_semaphore_create(c_inFlightCommandBuffers);
            ...
            mRealCapabilities = createRenderSystemCapabilities();
            ...
            mInitialized = true;
            ...
        }

        RenderWindow *win = OGRE_NEW MetalRenderWindow( &mDevice, this );
        win->create( name, width, height, fullScreen, miscParams );
        attachRenderTarget(*win);
        return win;
    }

要点:mInitialized 门闩保证设备只初始化一次;同时创建的信号量 c_inFlightCommandBuffers = 3 限制在途命令缓冲最多 3 个(Metal 通常用信号量做 CPU/GPU 同步预算);窗口对象持 &mDevice 指针,后续 MetalRenderWindow 通过它提交命令。

能力上报也在这里触发。createRenderSystemCapabilities 在设备就绪后读取 mActiveDevice:

// RenderSystems/Metal/src/OgreMetalRenderSystem.mm:MetalRenderSystem::createRenderSystemCapabilities(v14.6.3 源码摘录,已删减)
    RenderSystemCapabilities* MetalRenderSystem::createRenderSystemCapabilities(void) const
    {
        RenderSystemCapabilities* rsc = new RenderSystemCapabilities();
        rsc->setRenderSystemName(getName());

        rsc->setDeviceName(mActiveDevice->mDevice.name.UTF8String);

#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS || OGRE_CPU == OGRE_CPU_ARM
        rsc->setVendor( GPU_APPLE );
#endif

        rsc->setCapability(RSC_HWSTENCIL);
        rsc->setNumTextureUnits(16);
        rsc->setNumVertexTextureUnits(16);
        rsc->setCapability(RSC_ANISOTROPY);
        rsc->setCapability(RSC_TEXTURE_COMPRESSION);

能力对象同时记录系统名与设备名——这是 Metal 后端区别于 GL/Vulkan 的地方:MTLDevice.name 直接给出如 "Apple M1" 这样的硬件名,不需要厂商/型号解析。

在 Apple M1 Pro 上,Metal 两级离屏实验 使用真实 MSL 程序、两个 RenderTexture 及像素读回,验证设备初始化、Pass 绑定与采样。窗口仅用于引导初始化,交换链呈现另行验证。

源码定位

上游引用固定到 OGRE v14.6.3 源码 。

可运行产物:C++ 最小验证

下面用纯 C++ 复现 Metal 后端的设备结构、惰性初始化与能力上报。它与 src/09-1-metal-render-system.cpp 逐字节一致:

// file: src/09-1-metal-render-system.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/09-1-metal-render-system.cpp -o bin/09-1-metal-render-system && ./bin/09-1-metal-render-system
//
// 复现 MetalRenderSystem 与 MetalDevice(对应 RenderSystems/Metal 的
// OgreMetalRenderSystem.mm 110-154、288-341 与 OgreMetalDevice.mm 63-76):
//   getName() 返回 "Metal Rendering Subsystem";
//   MetalDevice 持有 mDevice/主命令队列,init() 创建默认设备与命令队列;
//   createRenderSystemCapabilities 填系统名、设备名、16 纹理单元与能力位;
//   _createRenderWindow 首次调用时惰性初始化设备。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <string>

namespace ogre_repro {

// 能力位:对应 RenderSystemCapabilities 的 RSC_* 枚举子集
enum RsCapability : uint32_t {
  RSC_HWSTENCIL = 1u << 0,
  RSC_ANISOTROPY = 1u << 1,
  RSC_TEXTURE_COMPRESSION = 1u << 2,
};

class RenderSystemCapabilities {
 public:
  void setRenderSystemName(const std::string& name) { mName = name; }
  const std::string& getRenderSystemName() const { return mName; }
  void setDeviceName(const std::string& name) { mDeviceName = name; }
  const std::string& getDeviceName() const { return mDeviceName; }
  void setNumTextureUnits(uint16_t n) { mNumTextureUnits = n; }
  uint16_t getNumTextureUnits() const { return mNumTextureUnits; }
  void setCapability(RsCapability cap) { mCapabilities |= cap; }
  bool hasCapability(RsCapability cap) const { return (mCapabilities & cap) != 0u; }

 private:
  std::string mName;
  std::string mDeviceName;
  uint16_t mNumTextureUnits = 0;
  uint32_t mCapabilities = 0;
};

// 对应 MetalDevice 结构(OgreMetalDevice.h 38-80)的简化版:
// mDevice + mMainCommandQueue 用两个布尔/字符串状态表示。
struct MetalDevice {
  std::string mDeviceName;        // id<MTLDevice> 的名字
  bool mCommandQueueReady = false; // mMainCommandQueue
  bool mInitialized = false;

  // 对应 MetalDevice::init():MTLCreateSystemDefaultDevice + newCommandQueue
  void init(const std::string& defaultDeviceName) {
    mDeviceName = defaultDeviceName;
    mCommandQueueReady = true;
    mInitialized = true;
  }
};

class RenderSystem {
 public:
  virtual ~RenderSystem() = default;
  virtual const std::string& getName() const = 0;
};

class MetalRenderSystem : public RenderSystem {
 public:
  const std::string& getName() const override {
    static const std::string name("Metal Rendering Subsystem");
    return name;
  }

  // 对应 createRenderSystemCapabilities():登记系统名、设备名、纹理单元数与能力位
  RenderSystemCapabilities createRenderSystemCapabilities(const MetalDevice& device) const {
    RenderSystemCapabilities rsc;
    rsc.setRenderSystemName(getName());
    rsc.setDeviceName(device.mDeviceName);
    rsc.setNumTextureUnits(16);
    rsc.setCapability(RSC_HWSTENCIL);
    rsc.setCapability(RSC_ANISOTROPY);
    rsc.setCapability(RSC_TEXTURE_COMPRESSION);
    return rsc;
  }

  // 对应 _createRenderWindow() 中的惰性初始化:首窗创建时才 init 设备
  void ensureDevice(MetalDevice& device, const std::string& defaultDeviceName) {
    if (!device.mInitialized) device.init(defaultDeviceName);
  }

  MetalDevice mDevice;  // 对应 MetalRenderSystem.mDevice(按值持有)
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  MetalRenderSystem rs;

  // getName:后端自报家门
  CHECK(rs.getName() == "Metal Rendering Subsystem");

  // 设备初始未初始化
  CHECK(!rs.mDevice.mInitialized);
  CHECK(!rs.mDevice.mCommandQueueReady);

  // 首窗创建 → 惰性初始化默认设备与命令队列
  rs.ensureDevice(rs.mDevice, "Apple M1");
  CHECK(rs.mDevice.mInitialized);
  CHECK(rs.mDevice.mCommandQueueReady);
  CHECK(rs.mDevice.mDeviceName == "Apple M1");

  // 能力对象:系统名、设备名、纹理单元数与能力位
  RenderSystemCapabilities caps = rs.createRenderSystemCapabilities(rs.mDevice);
  CHECK(caps.getRenderSystemName() == "Metal Rendering Subsystem");
  CHECK(caps.getDeviceName() == "Apple M1");
  CHECK(caps.getNumTextureUnits() == 16);
  CHECK(caps.hasCapability(RSC_HWSTENCIL));
  CHECK(caps.hasCapability(RSC_ANISOTROPY));
  CHECK(caps.hasCapability(RSC_TEXTURE_COMPRESSION));

  // 二次调用不再重置设备状态
  rs.ensureDevice(rs.mDevice, "Apple M2");
  CHECK(rs.mDevice.mDeviceName == "Apple M1");

  return lab::report("09-1 Metal 渲染系统");
}

本机实测(Apple clang 16,clang++ -std=c++20 -Wall -I.):编译零警告,断言 13/13 通过。

小结

  • MetalRenderSystem 继承 RenderSystem,getName() 返回 "Metal Rendering Subsystem";setConfigOption 是空实现。
  • MetalDevice 是结构体,封装 MTLDevice、MTLCommandQueue、MTLCommandBuffer 与三种编码器。
  • init() 按「设备 → 命令队列 → 命令缓冲」顺序创建对象。
  • 设备初始化惰性发生在首次 _createRenderWindow,并伴随 inFlightCommandBuffers=3 的信号量。
  • createRenderSystemCapabilities 上报系统名、设备名与 16 纹理单元等能力位。

阅读导航:上一节:8.3 Vulkan 渲染管线 · 下一节:9.2 D3D11 渲染系统 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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