《OGRE 3D 渲染引擎原理与架构》8.3 Metal 与 D3D11 后端

Metal 与 D3D11 两个后端各自的机制:Metal 用 psd hash 缓存 MTLRenderPipelineState(mPSOCache),渲染编码器直接接收状态;D3D11 用 feature level 分级决定能力与 MRT 数量,描述符以 changed 标记延迟应用。lab 复现 PSO 缓存、多边形模式映射与 feature level 能力分支。

8.3 Metal 与 D3D11 后端

这一节把两个平台后端并在一起看:Apple 的 Metal 与微软的 D3D11。它们都坚持「预编译的状态对象」思路——Metal 的 MTLRenderPipelineState 与 D3D11 的 ID3D11BlendState/RasterizerState/DepthStencilState——但缓存与脏标记策略不同。

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

8.1/8.2 的 GLES2 与 Vulkan 各自展示了能力探测与设备管理;本节补齐剩下两个后端的关键机制:Metal 的 PSO 缓存与编码器状态转发、D3D11 的 feature level 分级与描述符延迟应用。lab 把两种机制的最小逻辑分别复现。

Metal:按 psd hash 缓存 MTLRenderPipelineState

Metal 的 MTLRenderPipelineDescriptor(成员 psd)描述管线全部状态;getPipelineState() 先用 [psd hash] 查 mPSOCache,命中直接返回缓存的 id<MTLRenderPipelineState>,未命中才创建——创建失败抛 ERR_RENDERINGAPI_ERROR:

// RenderSystems/Metal/src/OgreMetalRenderSystem.mm:MetalRenderSystem::getPipelineState(v14.6.3 源码摘录,已删减)
    id<MTLRenderPipelineState> MetalRenderSystem::getPipelineState()
    {
        NSUInteger psdHash = [psd hash];
        auto it = mPSOCache.find(psdHash);
        if(it != mPSOCache.end())
            return it->second;

        NSError* error = NULL;
        id <MTLRenderPipelineState> pso =
                [mActiveDevice->mDevice newRenderPipelineStateWithDescriptor:psd error:&error];

        if( !pso || error )
        {
            String errorDesc;
            if( error )
                errorDesc = [error localizedDescription].UTF8String;

            OGRE_EXCEPT( Exception::ERR_RENDERINGAPI_ERROR,
                         "Failed to created pipeline state for rendering: " + errorDesc);
        }

        mPSOCache.emplace(psdHash, pso);

        return pso;
    }

psd 本身是渲染系统的成员,各状态 setter(_setDepthBias、_setAlphaRejectSettings)在绑定前改写它,下次取 PSO 时 hash 自然反映新状态。编码器 mActiveRenderEncoder 则是「当前命令流的接收者」,渲染期状态直接转发:

// RenderSystems/Metal/src/OgreMetalRenderSystem.mm:MetalRenderSystem::_setPolygonMode / _setDepthBias(v14.6.3 源码摘录,已删减)
    void MetalRenderSystem::_setDepthBias(float constantBias, float slopeScaleBias)
    {
        [mActiveRenderEncoder setDepthBias:constantBias
                                     slopeScale:slopeScaleBias
                                     clamp:0.0f];
    }

    void MetalRenderSystem::_setPolygonMode(PolygonMode level)
    {
        MTLTriangleFillMode fillMode =
            level == PM_SOLID ? MTLTriangleFillModeFill : MTLTriangleFillModeLines;
        [mActiveRenderEncoder setTriangleFillMode:fillMode];
    }

Metal 后端没有 D3D11 那种「changed 标记」:编码器是即时态对象,每次调用直接改状态。

D3D11:feature level 分级与能力分支

D3D11 的核心机制是 D3D_FEATURE_LEVEL。createD3D11Device 维护一个从高到低的请求数组(11_1 → 9_1),按配置的最小/最大请求裁剪出窗口,由 D3D 运行时从窗口顶部选设备支持的最高 level;如果 minFL 比 maxFL 还高,直接报 ERR_INTERNAL_ERROR:

// RenderSystems/Direct3D11/src/OgreD3D11RenderSystem.cpp:createD3D11Device(v14.6.3 教学示意,参照上游同名实现,已删减)
        // determine feature levels
        D3D_FEATURE_LEVEL requestedLevels[] = {
#if !__OGRE_WINRT_PHONE
#if defined(_WIN32_WINNT_WIN8) && _WIN32_WINNT >= _WIN32_WINNT_WIN8
            D3D_FEATURE_LEVEL_11_1,
#endif
            D3D_FEATURE_LEVEL_11_0,
            D3D_FEATURE_LEVEL_10_1,
            D3D_FEATURE_LEVEL_10_0,
#endif
            D3D_FEATURE_LEVEL_9_3,
            D3D_FEATURE_LEVEL_9_2,
            D3D_FEATURE_LEVEL_9_1
        };

        D3D_FEATURE_LEVEL *pFirstFL = requestedLevels, *pLastFL = pFirstFL + ARRAYSIZE(requestedLevels) - 1;
        for(unsigned int i = 0; i < ARRAYSIZE(requestedLevels); i++)
        {
            if(minFL == requestedLevels[i])
                pLastFL = &requestedLevels[i];
            if(maxFL == requestedLevels[i])
                pFirstFL = &requestedLevels[i];
        }
        if(pLastFL < pFirstFL)
        {
            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
                "Requested min level feature is bigger the requested max level feature.",
                "D3D11RenderSystem::initialise");
        }

能力探测用 mFeatureLevel >= X 的线性比较:FL 9_2 起支持 32 位索引,FL 10_0 起支持读回纹理与双面模板;MRT 数量随 FL 阶梯上升——9_1 只有 1,9_3 有 4,高于 9_3 用 D3D11 全量 8:

// RenderSystems/Direct3D11/src/OgreD3D11RenderSystem.cpp:createRenderSystemCapabilities(v14.6.3 源码摘录,已删减)
        UINT formatSupport;
        if(mFeatureLevel >= D3D_FEATURE_LEVEL_9_2
        || SUCCEEDED(mDevice->CheckFormatSupport(DXGI_FORMAT_R32_UINT, &formatSupport)) && 0 != (formatSupport & D3D11_FORMAT_SUPPORT_IA_INDEX_BUFFER))
            rsc->setCapability(RSC_32BIT_INDEX);
...
        // Cube map
        if (mFeatureLevel >= D3D_FEATURE_LEVEL_10_0)
        {
            rsc->setCapability(RSC_READ_BACK_AS_TEXTURE);
        }
...
        if(mFeatureLevel >= D3D_FEATURE_LEVEL_10_0)
            rsc->setCapability(RSC_TWO_SIDED_STENCIL);
...
#ifdef D3D_FEATURE_LEVEL_9_3
        int numMultiRenderTargets = (mFeatureLevel > D3D_FEATURE_LEVEL_9_3) ? D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT :      // 8
                                    (mFeatureLevel == D3D_FEATURE_LEVEL_9_3) ? 4/*D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT*/ :    // 4
                                    1/*D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT*/;                                                // 1
#else
        int numMultiRenderTargets = D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT;     // 8
#endif

        rsc->setNumMultiRenderTargets(std::min(numMultiRenderTargets, (int)OGRE_MAX_MULTIPLE_RENDER_TARGETS));

D3D11:描述符 changed 标记

与 Metal 的即时编码器不同,D3D11 的状态对象(blend/rasterizer/depth-stencil)创建成本高,OGRE 用 mXxxDescChanged 布尔标记「描述符已改但未应用」。每个 setter 只改描述符字段并置脏位;到 _render 时若脏位为真才创建新的 ID3D11BlendState 等并绑定:

// RenderSystems/Direct3D11/include/OgreD3D11RenderSystem.h:D3D11RenderSystem(v14.6.3 源码摘录,已删减)
        D3D11_BLEND_DESC    mBlendDesc;
        bool                mBlendDescChanged;

        D3D11_RASTERIZER_DESC   mRasterizerDesc;
        bool                    mRasterizerDescChanged;

        UINT mStencilRef;
        D3D11_DEPTH_STENCIL_DESC    mDepthStencilDesc; 
        bool                        mDepthStencilDescChanged;
...
        ComPtr<ID3D11BlendState> mBoundBlendState;
        ComPtr<ID3D11RasterizerState> mBoundRasterizer;
        ComPtr<ID3D11DepthStencilState> mBoundDepthStencilState;

mBound* 是已经创建并绑定的状态对象;描述符 + 脏位 + 绑定对象三者构成一套「惰性重建」协议。Metal 侧的 mPSOCache 与 D3D11 侧的脏标记,是同一问题(昂贵状态对象复用)的两种解法:前者按描述符 hash 缓存全部历史,后者只保留「最新一份」。

能力查询对应实际设备与窗口

后端可被构建和加载之后,还需要真正的设备、上下文或窗口才能验证运行行为。Metal 与 D3D11 的设备等级、目标格式和支持特性不同。

同一场景上保留所选渲染后端、capability、驱动和目标格式。命令或截图缺失时,用固定版本源码解释路径并明确证据范围。

源码定位

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

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

下面复现两种后端的核心机制:Metal 的 PSO 缓存(命中/未命中/失败)与编码器状态转发(_setPolygonMode 的 Fill/Lines 映射)、D3D11 的 feature level 能力分支(32 位索引、MRT 数量)与描述符脏标记。它与 src/ogre-ext-08-3-metal-d3d11-backend.cpp 逐字节一致:

// file: src/ogre-ext-08-3-metal-d3d11-backend.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/ogre-ext-08-3-metal-d3d11-backend.cpp -o bin/ogre-ext-08-3-metal-d3d11-backend && ./bin/ogre-ext-08-3-metal-d3d11-backend
//
// 复现 Metal 与 D3D11 后端的两个核心机制
// (对应 OgreMetalRenderSystem.mm 794-818、OgreMetalRenderSystem.h 51-168、
//   OgreD3D11RenderSystem.cpp 272-299、893-901、OgreD3D11RenderSystem.h 58-118):
//   Metal:getPipelineState 按 psd hash 查 mPSOCache,未命中创建后缓存,失败抛异常;
//   渲染编码器直接收状态(triangleFillMode/cullMode);
//   D3D11:feature level 分级决定 32 位索引、读回纹理、MRT 数量;
//   描述符用 changed 标记延迟应用(mBlendDescChanged 等)。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <map>
#include <string>

namespace ogre_repro {

// D3D_FEATURE_LEVEL(OgreD3D11RenderSystem.cpp 272-284)
enum FeatureLevel {
  D3D_FEATURE_LEVEL_9_1 = 1,
  D3D_FEATURE_LEVEL_9_2,
  D3D_FEATURE_LEVEL_9_3,
  D3D_FEATURE_LEVEL_10_0,
  D3D_FEATURE_LEVEL_10_1,
  D3D_FEATURE_LEVEL_11_0,
  D3D_FEATURE_LEVEL_11_1
};

FeatureLevel parseFeatureLevel(const std::string& s) {
  if (s == "11.1") return D3D_FEATURE_LEVEL_11_1;
  if (s == "11.0") return D3D_FEATURE_LEVEL_11_0;
  if (s == "10.1") return D3D_FEATURE_LEVEL_10_1;
  if (s == "10.0") return D3D_FEATURE_LEVEL_10_0;
  if (s == "9.3") return D3D_FEATURE_LEVEL_9_3;
  if (s == "9.2") return D3D_FEATURE_LEVEL_9_2;
  return D3D_FEATURE_LEVEL_9_1;
}

// 对应 D3D11RenderSystem(OgreD3D11RenderSystem.h 58-118)
class D3D11RenderSystem {
 public:
  explicit D3D11RenderSystem(FeatureLevel fl) : mFeatureLevel(fl) {}
  // 能力分支(OgreD3D11RenderSystem.cpp 803-822)
  bool has32BitIndex() const { return mFeatureLevel >= D3D_FEATURE_LEVEL_9_2; }
  bool hasReadBackAsTexture() const { return mFeatureLevel >= D3D_FEATURE_LEVEL_10_0; }
  bool hasTwoSidedStencil() const { return mFeatureLevel >= D3D_FEATURE_LEVEL_10_0; }
  // MRT 数量(OgreD3D11RenderSystem.cpp 893-901)
  int getNumMultiRenderTargets() const {
    return (mFeatureLevel > D3D_FEATURE_LEVEL_9_3) ? 8   // D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT
         : (mFeatureLevel == D3D_FEATURE_LEVEL_9_3) ? 4  // FL 9_3
                                                    : 1;  // FL 9_1
  }
  // 描述符 changed 标记(OgreD3D11RenderSystem.h 109-117)
  void markBlendDescChanged() { mBlendDescChanged = true; }
  void applyBlendDesc() { mBlendDescChanged = false; }
  bool isBlendDescChanged() const { return mBlendDescChanged; }

 private:
  FeatureLevel mFeatureLevel;
  bool mBlendDescChanged = false;  // 对应 mBlendDescChanged
};

// PolygonMode(OgreMetalRenderSystem.mm 769-774)
enum PolygonMode { PM_SOLID = 0, PM_WIREFRAME = 1 };

// 对应 MetalRenderSystem(OgreMetalRenderSystem.h 51-168、.mm 794-818)
class MetalRenderSystem {
 public:
  // getPipelineState:按 desc hash 查 mPSOCache,未命中创建后缓存
  uint32_t getPipelineState(uint32_t descHash) {
    auto it = mPSOCache.find(descHash);
    if (it != mPSOCache.end()) return it->second;  // 命中直接返回

    uint32_t pso = createPipelineState(descHash);
    if (pso == 0) return 0;  // 创建失败(对应 OGRE_EXCEPT)
    mPSOCache.emplace(descHash, pso);
    return pso;
  }
  size_t cacheSize() const { return mPSOCache.size(); }
  bool createFailed() const { return mCreateFailed; }

  // 渲染编码器状态转发(_setPolygonMode / _setCullingMode)
  void setPolygonMode(PolygonMode level) {
    mTriangleFillMode = (level == PM_SOLID) ? 1 : 0;  // Fill / Lines
  }
  int triangleFillMode() const { return mTriangleFillMode; }
  void setCullingMode(int mode) { mCullMode = mode; }
  int cullMode() const { return mCullMode; }

 private:
  uint32_t createPipelineState(uint32_t descHash) {
    if (descHash == kBadHash) { mCreateFailed = true; return 0; }
    return mNextPsoId++;
  }

  std::map<uint32_t, uint32_t> mPSOCache;  // 对应 mPSOCache
  uint32_t mNextPsoId = 1;
  int mTriangleFillMode = 0;  // 对应 MTLTriangleFillMode
  int mCullMode = -1;         // 对应编码器 cullMode 状态
  bool mCreateFailed = false;
  static constexpr uint32_t kBadHash = 0xDEADBEEF;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // Metal:PSO 缓存命中与创建
  {
    MetalRenderSystem metal;
    uint32_t pso1 = metal.getPipelineState(0x1001);
    CHECK(pso1 == 1);               // 首次创建
    CHECK(metal.cacheSize() == 1);
    CHECK(metal.getPipelineState(0x1001) == pso1);  // 缓存命中
    CHECK(metal.cacheSize() == 1);  // 未新增
    uint32_t pso2 = metal.getPipelineState(0x1002);
    CHECK(pso2 == 2);               // 不同描述符 -> 新 PSO
    CHECK(metal.cacheSize() == 2);
  }

  // Metal:创建失败路径(对应 OGRE_EXCEPT)
  {
    MetalRenderSystem metal;
    CHECK(metal.getPipelineState(0xDEADBEEF) == 0);
    CHECK(metal.createFailed());
    CHECK(metal.cacheSize() == 0);  // 失败不缓存
  }

  // Metal:渲染编码器状态转发
  {
    MetalRenderSystem metal;
    metal.setPolygonMode(PM_SOLID);
    CHECK(metal.triangleFillMode() == 1);     // MTLTriangleFillModeFill
    metal.setPolygonMode(PM_WIREFRAME);
    CHECK(metal.triangleFillMode() == 0);     // MTLTriangleFillModeLines
    metal.setCullingMode(2);
    CHECK(metal.cullMode() == 2);
  }

  // D3D11:feature level 解析
  CHECK(parseFeatureLevel("9.3") == D3D_FEATURE_LEVEL_9_3);
  CHECK(parseFeatureLevel("11.0") == D3D_FEATURE_LEVEL_11_0);
  CHECK(parseFeatureLevel("10.1") == D3D_FEATURE_LEVEL_10_1);

  // D3D11:能力分支
  {
    D3D11RenderSystem d3d9_1(D3D_FEATURE_LEVEL_9_1);
    CHECK(d3d9_1.getNumMultiRenderTargets() == 1);
    CHECK(!d3d9_1.has32BitIndex());
    CHECK(!d3d9_1.hasReadBackAsTexture());
    CHECK(!d3d9_1.hasTwoSidedStencil());

    D3D11RenderSystem d3d9_2(D3D_FEATURE_LEVEL_9_2);
    CHECK(d3d9_2.has32BitIndex());            // >= 9_2
    CHECK(d3d9_2.getNumMultiRenderTargets() == 1);

    D3D11RenderSystem d3d9_3(D3D_FEATURE_LEVEL_9_3);
    CHECK(d3d9_3.getNumMultiRenderTargets() == 4);

    D3D11RenderSystem d3d10(D3D_FEATURE_LEVEL_10_0);
    CHECK(d3d10.hasReadBackAsTexture());      // >= 10_0
    CHECK(d3d10.hasTwoSidedStencil());
    CHECK(d3d10.getNumMultiRenderTargets() == 8);

    D3D11RenderSystem d3d11(D3D_FEATURE_LEVEL_11_0);
    CHECK(d3d11.getNumMultiRenderTargets() == 8);
  }

  // D3D11:描述符 changed 标记延迟应用
  {
    D3D11RenderSystem d3d(D3D_FEATURE_LEVEL_11_0);
    CHECK(!d3d.isBlendDescChanged());
    d3d.markBlendDescChanged();
    CHECK(d3d.isBlendDescChanged());
    d3d.applyBlendDesc();
    CHECK(!d3d.isBlendDescChanged());
  }

  return lab::report("08-3 Metal 与 D3D11 后端");
}

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

小结

  • Metal 用 [psd hash] 查 mPSOCache:命中复用、未命中创建后缓存、失败抛 ERR_RENDERINGAPI_ERROR。
  • Metal 渲染编码器是即时态对象,_setPolygonMode 等 setter 直接转发到 mActiveRenderEncoder。
  • D3D11 的 requestedLevels 数组从 11_1 排到 9_1,按 min/max 请求裁剪窗口,min > max 报内部错误。
  • D3D11 能力按 mFeatureLevel >= X 线性比较:9_2 起 32 位索引,10_0 起读回纹理/双面模板,MRT 数量 1/4/8 阶梯上升。
  • D3D11 描述符用 mXxxDescChanged 脏标记惰性重建 ID3D11*State;Metal 用描述符 hash 缓存全部历史——同一问题的两种解法。

阅读导航:上一节:8.2 Vulkan 后端 · 下一节:9.1 性能剖析器 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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