DirectX 12 Mesh Shader Cluster Culling でGPU処理50%削減｜次世代ジオメトリパイプライン実装ガイド【2026年5月新機能】

DirectX 12 の Mesh Shader は 2021 年の登場以降、ジオメトリパイプラインの革新的な選択肢として注目されてきました。2026年5月、Shader Model 6.9 のアップデートで Cluster Culling の最適化機能が大幅に強化され、従来の頂点シェーダー + テッセレーション構成と比較して GPU 処理負荷を 50% 削減できる実装パターンが確立されました。

本記事では、DirectX 12 Mesh Shader の Cluster Culling 機能を活用し、大規模シーンでの描画性能を劇的に向上させる実装手法を詳解します。Microsoft の公式ドキュメント（2026年4月更新）と AMD/NVIDIA の最新ホワイトペーパーを基に、実装可能なコード例と最適化戦略を提示します。

Mesh Shader とは｜従来のジオメトリパイプラインからの脱却

従来の DirectX ジオメトリパイプラインは、Vertex Shader → Hull Shader → Tessellator → Domain Shader → Geometry Shader という固定的なステージで構成されていました。この構造は柔軟性に欠け、GPU 上での並列処理効率が低いという課題がありました。

Mesh Shader は、この固定パイプラインを Task Shader + Mesh Shader の 2 段階構成に置き換える新しいアプローチです。Task Shader が Meshlet（メッシュの小さな塊、通常 64〜256 頂点）単位でカリング判定を行い、Mesh Shader が実際の頂点・プリミティブ生成を担当します。

以下の図は、従来パイプラインと Mesh Shader パイプラインの違いを示しています。

flowchart LR
    A["従来パイプライン"] --> B["Vertex Shader"]
    B --> C["Hull Shader"]
    C --> D["Tessellator"]
    D --> E["Domain Shader"]
    E --> F["Geometry Shader"]
    F --> G["Pixel Shader"]
    
    H["Mesh Shader パイプライン"] --> I["Task Shader<br/>(Meshlet カリング)"]
    I --> J["Mesh Shader<br/>(頂点・プリミティブ生成)"]
    J --> K["Pixel Shader"]
    
    style A fill:#ffcccc
    style H fill:#ccffcc

従来パイプラインでは各ステージが逐次実行されるのに対し、Mesh Shader パイプラインでは Task Shader が並列に Meshlet をカリングし、必要な Meshlet のみを Mesh Shader に渡すため、GPU 上のワークロードが大幅に削減されます。

Mesh Shader の主要な利点

柔軟なジオメトリ生成: プログラマブルな Meshlet 生成により、LOD 切り替えやプロシージャル生成が容易
効率的なカリング: Task Shader で Meshlet 単位のフラスタムカリング・オクルージョンカリングを実行
GPU 最適化: Wave Intrinsics を活用した並列処理により、頂点処理のスループットが向上
メモリ帯域幅削減: 不要な Meshlet を早期にカリングすることで、メモリアクセスが最小化

2026年4月の Shader Model 6.9 では、Cluster Culling の最適化として Hierarchical Culling と Wave-Level Culling が追加されました。これにより、従来の頂点シェーダー構成と比較して 50〜60% の GPU 処理負荷削減が報告されています（AMD RDNA 3 環境でのベンチマーク結果）。

Cluster Culling の基本実装｜Task Shader でのフラスタムカリング

Cluster Culling の核心は、Task Shader で Meshlet ごとにフラスタム判定・オクルージョン判定を行い、不可視な Meshlet を早期に除外することです。以下は、フラスタムカリングを実装した Task Shader の例です。

// Task Shader: Meshlet のフラスタムカリング
struct MeshletData {
    float3 boundsCenter;
    float boundsRadius;
    uint vertexOffset;
    uint triangleOffset;
    uint vertexCount;
    uint triangleCount;
};

ConstantBuffer<SceneConstants> g_Scene : register(b0);
StructuredBuffer<MeshletData> g_Meshlets : register(t0);

[numthreads(32, 1, 1)]
void TaskMain(
    uint gtid : SV_GroupThreadID,
    uint gid : SV_GroupID
) {
    uint meshletIndex = gid * 32 + gtid;
    
    if (meshletIndex >= g_Scene.meshletCount) {
        return;
    }
    
    MeshletData meshlet = g_Meshlets[meshletIndex];
    
    // バウンディングスフィアでフラスタムカリング
    float4 center = mul(float4(meshlet.boundsCenter, 1.0), g_Scene.worldMatrix);
    bool isVisible = FrustumCullSphere(center.xyz, meshlet.boundsRadius, g_Scene.viewProj);
    
    if (isVisible) {
        // Mesh Shader にディスパッチ
        DispatchMesh(1, 1, 1, meshletIndex);
    }
}

bool FrustumCullSphere(float3 center, float radius, float4x4 viewProj) {
    // ビュープロジェクション変換後の座標で判定
    float4 clipPos = mul(float4(center, 1.0), viewProj);
    
    // 6つの錐台平面に対して判定（簡易実装）
    float3 ndc = clipPos.xyz / clipPos.w;
    return (abs(ndc.x) <= 1.0 + radius / clipPos.w) &&
           (abs(ndc.y) <= 1.0 + radius / clipPos.w) &&
           (ndc.z >= 0.0 - radius / clipPos.w) &&
           (ndc.z <= 1.0 + radius / clipPos.w);
}

このコードでは、Task Shader が 32 スレッド単位で Meshlet を処理し、バウンディングスフィアによるフラスタムカリングを実行しています。可視と判定された Meshlet のみが DispatchMesh() で Mesh Shader にディスパッチされます。

以下の図は、Cluster Culling の処理フローを示しています。

sequenceDiagram
    participant CPU as CPU Side
    participant TS as Task Shader
    participant MS as Mesh Shader
    participant PS as Pixel Shader
    
    CPU->>TS: Meshlet データをバインド
    TS->>TS: Meshlet ごとにフラスタム判定
    TS->>TS: 不可視 Meshlet を除外
    TS->>MS: 可視 Meshlet のみディスパッチ
    MS->>MS: 頂点・プリミティブ生成
    MS->>PS: ラスタライズ結果を渡す
    PS->>PS: ピクセルシェーディング

従来の頂点シェーダーでは全頂点が処理されていましたが、Cluster Culling では 不可視な Meshlet の頂点処理が完全にスキップされるため、GPU の演算負荷が大幅に削減されます。

Hierarchical Culling の実装｜2段階カリングで効率最大化

2026年4月の Shader Model 6.9 で追加された Hierarchical Culling は、Meshlet を階層的に管理し、親ノードでカリングされた場合に子 Meshlet 群を一括除外する手法です。これにより、大規模シーンでのカリング効率がさらに向上します。

Meshlet 階層の構築

Meshlet を BVH（Bounding Volume Hierarchy）で階層化し、親ノードのバウンディングボックスで子ノード群をまとめてカリングします。以下は、階層化された Meshlet データ構造の例です。

struct MeshletNode {
    float3 aabbMin;
    float3 aabbMax;
    uint childOffset;    // 子ノードの開始インデックス
    uint childCount;     // 子ノードの数
    uint meshletOffset;  // Meshlet データの開始インデックス（リーフノードのみ）
    uint meshletCount;   // Meshlet 数（リーフノードのみ）
};

StructuredBuffer<MeshletNode> g_MeshletHierarchy : register(t1);

bool FrustumCullAABB(float3 aabbMin, float3 aabbMax, float4x4 viewProj) {
    // AABB の 8 頂点を生成し、すべてが錐台外にあるか判定
    float3 corners[8] = {
        float3(aabbMin.x, aabbMin.y, aabbMin.z),
        float3(aabbMax.x, aabbMin.y, aabbMin.z),
        float3(aabbMin.x, aabbMax.y, aabbMin.z),
        float3(aabbMax.x, aabbMax.y, aabbMin.z),
        float3(aabbMin.x, aabbMin.y, aabbMax.z),
        float3(aabbMax.x, aabbMin.y, aabbMax.z),
        float3(aabbMin.x, aabbMax.y, aabbMax.z),
        float3(aabbMax.x, aabbMax.y, aabbMax.z)
    };
    
    int outCount = 0;
    for (int i = 0; i < 8; i++) {
        float4 clipPos = mul(float4(corners[i], 1.0), viewProj);
        float3 ndc = clipPos.xyz / clipPos.w;
        if (abs(ndc.x) > 1.0 || abs(ndc.y) > 1.0 || ndc.z < 0.0 || ndc.z > 1.0) {
            outCount++;
        }
    }
    
    return outCount < 8; // 少なくとも1頂点が錐台内にあれば可視
}

[numthreads(32, 1, 1)]
void HierarchicalTaskMain(
    uint gtid : SV_GroupThreadID,
    uint gid : SV_GroupID
) {
    uint nodeIndex = gid * 32 + gtid;
    
    if (nodeIndex >= g_Scene.nodeCount) {
        return;
    }
    
    MeshletNode node = g_MeshletHierarchy[nodeIndex];
    
    // 親ノードの AABB でカリング
    if (!FrustumCullAABB(node.aabbMin, node.aabbMax, g_Scene.viewProj)) {
        return; // 親が不可視なら子をすべてスキップ
    }
    
    // リーフノードの場合、Meshlet を Mesh Shader にディスパッチ
    if (node.meshletCount > 0) {
        for (uint i = 0; i < node.meshletCount; i++) {
            uint meshletIndex = node.meshletOffset + i;
            DispatchMesh(1, 1, 1, meshletIndex);
        }
    } else {
        // 内部ノードの場合、子ノードを再帰的に処理
        // （実際の実装では子ノードを新しい Task Shader 呼び出しでディスパッチ）
        for (uint i = 0; i < node.childCount; i++) {
            uint childIndex = node.childOffset + i;
            DispatchMesh(1, 1, 1, childIndex);
        }
    }
}

以下の図は、Hierarchical Culling の階層構造を示しています。

graph TD
    Root["ルートノード<br/>(全体 AABB)"]
    Root --> A["親ノード A<br/>(AABB_A)"]
    Root --> B["親ノード B<br/>(AABB_B)"]
    A --> A1["Meshlet 1"]
    A --> A2["Meshlet 2"]
    A --> A3["Meshlet 3"]
    B --> B1["Meshlet 4"]
    B --> B2["Meshlet 5"]
    
    style Root fill:#ffcccc
    style A fill:#ccffcc
    style B fill:#ccccff

親ノード A が錐台外にある場合、Meshlet 1〜3 はすべてカリングされます。これにより、個別にカリング判定を行うよりも カリング処理自体の負荷が削減されます。

NVIDIA の最新ベンチマーク（2026年5月公開）によると、Hierarchical Culling を適用することで、従来の Meshlet 単位カリングと比較して さらに 15〜20% の GPU 負荷削減が報告されています。

Wave-Level Culling の活用｜SIMD並列化で高速化

Shader Model 6.9 では、Wave Intrinsics を活用した Wave-Level Culling が追加されました。これは、Wave（通常 32〜64 スレッド）単位でカリング結果を集約し、全スレッドが不可視と判定した場合に Wave 全体をスキップする最適化です。

Wave Intrinsics による並列カリング

[numthreads(64, 1, 1)]
void WaveLevelTaskMain(
    uint gtid : SV_GroupThreadID,
    uint gid : SV_GroupID
) {
    uint meshletIndex = gid * 64 + gtid;
    
    bool isVisible = false;
    
    if (meshletIndex < g_Scene.meshletCount) {
        MeshletData meshlet = g_Meshlets[meshletIndex];
        float4 center = mul(float4(meshlet.boundsCenter, 1.0), g_Scene.worldMatrix);
        isVisible = FrustumCullSphere(center.xyz, meshlet.boundsRadius, g_Scene.viewProj);
    }
    
    // Wave 内のすべてのスレッドのカリング結果を集約
    bool anyVisible = WaveActiveAnyTrue(isVisible);
    
    if (!anyVisible) {
        // Wave 全体が不可視なら早期リターン
        return;
    }
    
    // 可視な Meshlet のみディスパッチ
    if (isVisible) {
        DispatchMesh(1, 1, 1, meshletIndex);
    }
}

WaveActiveAnyTrue() は、Wave 内の少なくとも 1 スレッドが true を返す場合に true を返します。すべてのスレッドが不可視と判定した場合、Wave 全体が早期リターンするため、ディスパッチのオーバーヘッドが削減されます。

以下の図は、Wave-Level Culling の並列処理フローを示しています。

flowchart TD
    A["Task Shader 起動<br/>(64 スレッド / Wave)"] --> B["各スレッドが Meshlet カリング"]
    B --> C{"Wave 内で<br/>anyVisible?"}
    C -->|No| D["Wave 全体を早期リターン"]
    C -->|Yes| E["可視 Meshlet を DispatchMesh"]
    E --> F["Mesh Shader 実行"]
    
    style D fill:#ffcccc
    style E fill:#ccffcc

AMD の測定（RDNA 3 アーキテクチャ、2026年4月）によると、Wave-Level Culling を適用することで、密集したオブジェクトを含むシーンでの カリング処理時間が 30% 短縮されました。

実装時の最適化戦略｜メモリレイアウトとバッファ設計

Mesh Shader の性能を最大化するには、Meshlet データのメモリレイアウトとバッファ設計が重要です。以下は、最適化のポイントです。

Meshlet のサイズ調整

Meshlet のサイズ（頂点数・三角形数）は、GPU アーキテクチャによって最適値が異なります。

NVIDIA Ampere/Ada（RTX 3000/4000 シリーズ）: 64〜128 頂点、126 三角形
AMD RDNA 3（RX 7000 シリーズ）: 128〜256 頂点、252 三角形
Intel Arc（Alchemist）: 64 頂点、126 三角形

以下のコードは、Meshlet を生成するプリプロセスの例です（CPU 側で実行）。

struct Meshlet {
    std::vector<uint32_t> vertices;
    std::vector<uint32_t> triangles;
    DirectX::BoundingSphere bounds;
};

std::vector<Meshlet> GenerateMeshlets(
    const std::vector<Vertex>& vertices,
    const std::vector<uint32_t>& indices,
    uint32_t maxVertices,
    uint32_t maxTriangles
) {
    std::vector<Meshlet> meshlets;
    
    for (size_t i = 0; i < indices.size(); i += maxTriangles * 3) {
        Meshlet meshlet;
        std::unordered_set<uint32_t> uniqueVertices;
        
        // 三角形を Meshlet に追加
        for (size_t j = i; j < std::min(i + maxTriangles * 3, indices.size()); j += 3) {
            uint32_t i0 = indices[j];
            uint32_t i1 = indices[j + 1];
            uint32_t i2 = indices[j + 2];
            
            uniqueVertices.insert(i0);
            uniqueVertices.insert(i1);
            uniqueVertices.insert(i2);
            
            // 頂点数が上限を超える場合、新しい Meshlet を開始
            if (uniqueVertices.size() > maxVertices) {
                break;
            }
            
            meshlet.triangles.push_back(i0);
            meshlet.triangles.push_back(i1);
            meshlet.triangles.push_back(i2);
        }
        
        meshlet.vertices.assign(uniqueVertices.begin(), uniqueVertices.end());
        
        // バウンディングスフィアを計算
        std::vector<DirectX::XMFLOAT3> positions;
        for (uint32_t vIdx : meshlet.vertices) {
            positions.push_back(vertices[vIdx].position);
        }
        DirectX::BoundingSphere::CreateFromPoints(
            meshlet.bounds,
            positions.size(),
            positions.data(),
            sizeof(DirectX::XMFLOAT3)
        );
        
        meshlets.push_back(meshlet);
    }
    
    return meshlets;
}

バッファ配置の最適化

Meshlet データは、GPU がシーケンシャルにアクセスしやすいよう、以下のように配置します。

// Meshlet データ構造（GPU バッファ）
struct MeshletGPU {
    DirectX::XMFLOAT3 boundsCenter;
    float boundsRadius;
    uint32_t vertexOffset;
    uint32_t triangleOffset;
    uint32_t vertexCount;
    uint32_t triangleCount;
};

// バッファ作成
std::vector<MeshletGPU> meshletData;
std::vector<uint32_t> vertexIndices;
std::vector<uint32_t> triangleIndices;

for (const auto& meshlet : meshlets) {
    MeshletGPU gpuMeshlet;
    gpuMeshlet.boundsCenter = DirectX::XMFLOAT3(
        meshlet.bounds.Center.x,
        meshlet.bounds.Center.y,
        meshlet.bounds.Center.z
    );
    gpuMeshlet.boundsRadius = meshlet.bounds.Radius;
    gpuMeshlet.vertexOffset = static_cast<uint32_t>(vertexIndices.size());
    gpuMeshlet.triangleOffset = static_cast<uint32_t>(triangleIndices.size());
    gpuMeshlet.vertexCount = static_cast<uint32_t>(meshlet.vertices.size());
    gpuMeshlet.triangleCount = static_cast<uint32_t>(meshlet.triangles.size() / 3);
    
    meshletData.push_back(gpuMeshlet);
    vertexIndices.insert(vertexIndices.end(), meshlet.vertices.begin(), meshlet.vertices.end());
    triangleIndices.insert(triangleIndices.end(), meshlet.triangles.begin(), meshlet.triangles.end());
}

// StructuredBuffer として GPU にアップロード
// meshletData -> g_Meshlets
// vertexIndices -> g_VertexIndices
// triangleIndices -> g_TriangleIndices

以下の図は、バッファのメモリレイアウトを示しています。

flowchart LR
    A["Meshlet データ<br/>(StructuredBuffer)"] --> B["Meshlet 0<br/>(bounds, offset, count)"]
    A --> C["Meshlet 1"]
    A --> D["Meshlet 2"]
    
    E["頂点インデックス<br/>(Buffer)"] --> F["Meshlet 0 の頂点<br/>(32 indices)"]
    E --> G["Meshlet 1 の頂点<br/>(64 indices)"]
    
    H["三角形インデックス<br/>(Buffer)"] --> I["Meshlet 0 の三角形<br/>(24 indices)"]
    H --> J["Meshlet 1 の三角形<br/>(48 indices)"]

このレイアウトにより、Task Shader は Meshlet データをシーケンシャルに読み込み、Mesh Shader は必要な頂点・三角形インデックスを効率的に取得できます。

パフォーマンス比較｜従来手法との実測データ

2026年5月に公開された AMD と NVIDIA の共同ベンチマーク（Shader Model 6.9 環境）では、以下のような性能改善が報告されています。

テスト環境

GPU: NVIDIA RTX 4080, AMD Radeon RX 7900 XT
シーン: 1000万ポリゴン（10万 Meshlet）、視錐台内に約30%が存在
解像度: 4K (3840x2160)
測定項目: GPU 処理時間、メモリ帯域幅使用量

結果

手法	GPU 処理時間（RTX 4080）	GPU 処理時間（RX 7900 XT）	メモリ帯域幅削減率
従来の頂点シェーダー	8.2ms	9.1ms	0% (ベースライン)
Mesh Shader（基本）	5.4ms	5.9ms	35%
+ Hierarchical Culling	4.3ms	4.7ms	47%
+ Wave-Level Culling	3.9ms	4.2ms	52%

Cluster Culling を完全に適用した場合、GPU 処理時間が約 50% 削減され、メモリ帯域幅使用量も半減しています。

以下の図は、各手法の処理時間比較を示しています。

graph LR
    A["従来の頂点シェーダー<br/>8.2ms"] --> B["Mesh Shader 基本<br/>5.4ms<br/>(-34%)"]
    B --> C["+ Hierarchical Culling<br/>4.3ms<br/>(-48%)"]
    C --> D["+ Wave-Level Culling<br/>3.9ms<br/>(-52%)"]
    
    style A fill:#ffcccc
    style D fill:#ccffcc

まとめ

DirectX 12 Mesh Shader の Cluster Culling 機能は、2026年5月の Shader Model 6.9 アップデートにより、以下の最適化手法が確立されました。

Task Shader でのフラスタムカリング: Meshlet 単位で不可視なジオメトリを早期除外
Hierarchical Culling: BVH による階層的カリングで、親ノードが不可視なら子 Meshlet 群を一括スキップ
Wave-Level Culling: Wave Intrinsics で並列カリング結果を集約し、Wave 全体を早期リターン
最適なバッファ設計: Meshlet データをシーケンシャルに配置し、GPU メモリアクセスを最適化

これらの手法を組み合わせることで、従来の頂点シェーダー構成と比較して GPU 処理負荷を 50% 以上削減できます。大規模オープンワールドゲームやリアルタイムレンダリングアプリケーションにおいて、Mesh Shader は次世代ジオメトリパイプラインの標準となるでしょう。

実装時は、GPU アーキテクチャごとの Meshlet サイズ調整と、階層的カリング構造の設計が性能の鍵となります。本記事のコード例を基に、プロジェクトに適した最適化戦略を構築してください。

DirectX 12 Mesh Shader Cluster Culling でGPU処理50%削減｜次世代ジオメトリパイプライン実装ガイド【2026年5月新機能】

Mesh Shader とは｜従来のジオメトリパイプラインからの脱却

Mesh Shader の主要な利点

Cluster Culling の基本実装｜Task Shader でのフラスタムカリング

Hierarchical Culling の実装｜2段階カリングで効率最大化

Meshlet 階層の構築

Wave-Level Culling の活用｜SIMD並列化で高速化

Wave Intrinsics による並列カリング

実装時の最適化戦略｜メモリレイアウトとバッファ設計

Meshlet のサイズ調整

バッファ配置の最適化

パフォーマンス比較｜従来手法との実測データ

テスト環境

結果

まとめ

参考リンク

Vulkan VK_EXT_opacity_micromap レイトレーシング透明度最適化：GPU負荷40%削減実装ガイド【2026年6月新拡張】

Vulkan VK_EXT_opacity_micromap レイトレーシング透明度最適化：レイキャスト負荷40%削減【2026年6月新拡張】

C++26 std::simd AVX-512 明示的SIMD演算でゲーム物理計算を100倍高速化する実装検証【ベンチマーク2026年6月】

Mesh Shader とは｜従来のジオメトリパイプラインからの脱却

Mesh Shader の主要な利点

Cluster Culling の基本実装｜Task Shader でのフラスタムカリング

Hierarchical Culling の実装｜2段階カリングで効率最大化

Meshlet 階層の構築

Wave-Level Culling の活用｜SIMD並列化で高速化

Wave Intrinsics による並列カリング

実装時の最適化戦略｜メモリレイアウトとバッファ設計

Meshlet のサイズ調整

バッファ配置の最適化

パフォーマンス比較｜従来手法との実測データ

テスト環境

結果

まとめ

参考リンク

最新記事をメールで受け取る

関連記事

Vulkan VK_EXT_opacity_micromap レイトレーシング透明度最適化：GPU負荷40%削減実装ガイド【2026年6月新拡張】

Vulkan VK_EXT_opacity_micromap レイトレーシング透明度最適化：レイキャスト負荷40%削減【2026年6月新拡張】

C++26 std::simd AVX-512 明示的SIMD演算でゲーム物理計算を100倍高速化する実装検証【ベンチマーク2026年6月】