> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Utilisation du pipeline Mesh Shader

> Utilisation du pipeline Mesh Shader

L'utilisation du pipeline Mesh Shader dans Direct3D 12 se résume aux étapes familières suivantes.

1. Écrire et compiler un Mesh Shader et (facultativement) un Amplification Shader à l'aide de DXC.
2. Créer un objet d'état de pipeline Mesh Shader à l'aide du bytecode du shader compilé.
3. Enregistrer la distribution de l'objet d'état de pipeline Mesh Shader à l'aide d'une liste de commandes.
4. Exécuter la liste de commandes sur une file d'attente de commandes.

## Objets d'état de pipeline Mesh Shader

Direct3D 12 expose le pipeline Mesh Shader par le biais des API familières d'objets d'état de pipeline graphique. La création de l'objet d'état de pipeline Mesh Shader utilise les API de flux d'état de pipeline, comme illustré dans les deux exemples de code suivants.

Les API ID3D12Device et ID3D12GraphicsCommandList permettent de vérifier la prise en charge matérielle et de distribuer les charges de travail du pipeline Mesh Shader (deuxième exemple de code). Notez qu'il n'est pas nécessaire de vérifier la prise en charge matérielle sur XBOX Series X|S.

L'exemple de code suivant montre une description de flux de pipeline Mesh Shader à fournir aux API de création de flux de pipeline.

```text theme={null}
struct MyPsoStreamDesc
{
    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE        pRootSignature;
    CD3DX12_PIPELINE_STATE_STREAM_AS                    AS;
    CD3DX12_PIPELINE_STATE_STREAM_MS                    MS;
    CD3DX12_PIPELINE_STATE_STREAM_PS                    PS;
    CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC            BlendState;
    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1        DepthStencilState;
    CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER            RasterizerState;
    CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTFormats;
    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT  DepthFormat;
    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC           SampleDesc;
    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK           SampleMask;
};
```

L'exemple de code suivant montre la création et l'utilisation d'un état de pipeline Mesh Shader.

```text theme={null}
{
    // Check the hardware for Mesh Shader pipeline feature support, which is unnecessary on Xbox Series X|S.
    D3D12_FEATURE_DATA_D3D12_OPTIONS7 options;
    device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS7, &options, sizeof(options));
    
    if (options.MeshShaderTier == D3D12_MESH_SHADER_TIER_NOT_SUPPORTED)
        throw std::exception("Mesh Shaders not supported!"); 

    // Create the Mesh Shader pipeline by using the pipeline state stream APIs.
    MyPsoStreamDesc psoDesc;
    psoDesc.AS = {...};
    psoDesc.MS = {...};
    ...

    D3D12_PIPELINE_STATE_STREAM_DESC desc = { sizeof(psoDesc), &psoDesc };
    device->CreatePipelineState(&desc, IID_PPV_ARGS(&msPso));

    ...

    // Set the graphics root signature, Mesh Shader pipeline state object, and root parameters.
    cmdList->SetGraphicsRootSignature(&msRootSig);
    cmdList->SetPipelineState(&msPso); 
    ...

    // Dispatch the bound Mesh Shader pipeline directly ...
    cmdList->DispatchMesh(groupCount, 1, 1);
    
    // ... or indirectly.
    cmdList->ExecuteIndirect(&msCommandSig, ...);
}
```

## Mesh Shaders

Les Mesh Shaders sont compilés avec l'outil en ligne de commande DXC ou avec la bibliothèque du compilateur, en utilisant le nouveau profil de shader Mesh Shader « *ms* », par exemple *ms\_6\_5*. Le troisième exemple de code fournit un exemple d'implémentation d'un Mesh Shader de triangle en espace écran ; suivez les explications en utilisant cet exemple de code comme référence.

Voici un exemple de compilation d'un Mesh Shader en ligne de commande.

```text theme={null}
dxc.exe -T ms_6_5 -E main -Fo ExampleMS.cso ExampleMS.hlsl
```

La fonction **main** du shader est décorée avec des attributs de métadonnées.

* **NumThreads** déclare la dimensionnalité du groupe de threads
* **OutputTopology** déclare le type de primitive

Les seules entrées sont les ID de threads familiers des compute shaders. Toutes les autres données doivent être lues manuellement via des vues de tampon constant (CBV), des vues de ressource de shader (SRV) ou des vues d'accès non ordonné (UAV).

Les sorties géométriques sont déclarées via les paramètres *out* en tant que *tableaux de sortie partagés*. Il s'agit de paramètres de tableau en écriture seule dont les types déclarent les types de sommets et de primitives définis par l'utilisateur à exporter depuis le shader. Les modificateurs *vertices*, *indices* et *primitives* désignent chaque paramètre comme l'une des trois sorties géométriques distinctes. La longueur de ces tableaux doit être une constante de compilation et définit le nombre maximal de sommets et de primitives pouvant être exportés.

La fonction intrinsèque [SetMeshOutputCounts](https://microsoft.github.io/DirectX-Specs/d3d/MeshShader.html#setmeshoutputcounts) déclare le nombre réel de sommets et de primitives exportés pour le groupe de threads. Cet appel est facultatif : la valeur par défaut est zéro pour numVerts et numPrims. Ces valeurs doivent être inférieures ou égales aux longueurs des tableaux de sortie. Cet appel peut avoir lieu à tout moment *avant* les écritures dans les tableaux de sortie partagés. Les valeurs fournies sont censées être constantes au sein du groupe de threads et seront lues à partir de la première voie (lane).

Les sommets et les primitives sont ensuite transformés par le groupe de threads et écrits dans les tableaux de sortie partagés. L'appel à **SetMeshOutputCounts()** doit être effectué avant toute écriture, et les écritures doivent rester dans les limites déclarées par cet appel.

L'exemple de code suivant montre un Mesh Shader qui effectue le rendu d'un seul triangle en espace écran.

```text theme={null}
static const float4 Vertices[3] = 
{
    float4(-0.5f, -0.5f, 0.0f, 1.0f),
    float4( 0.0f,  0.5f, 0.0f, 1.0f),
    float4( 0.5f, -0.5f, 0.0f, 1.0f)
};
static const uint3 Primitives[1] = { uint3(0, 1, 2) };

[NumThreads(32, 1, 1)]
[OutputTopology("triangle")]
void main(
    uint groupThreadId : SV_GroupIndex,
    out vertices VertexOut verts[3],
    out indices uint3 tris[1],
    out primitives PrimitiveOut prims[1])
{
    SetMeshOutputCounts(3, 1);

    if (groupThreadId < 3)
    {
        VertexOut vout;
        vout.Position = Vertices[groupThreadId];
        vout.Color = float3(1.0, 1.0, 1.0);
        
        verts[groupThreadId] = vout;
    }

    if (groupThreadId < 1)
    {
        tris[groupThreadId] = Primitives[groupThreadId];

        prims[groupThreadId].PrimitiveId = groupThreadId;
    }
}
```

## Amplification Shaders

Les Amplification Shaders sont compilés avec l'outil en ligne de commande DXC ou avec la bibliothèque, en utilisant le nouveau profil de shader Amplification Shader « *as* », par exemple *as\_6\_5*.

Voici un exemple de compilation d'un Amplification Shader en ligne de commande.

```text theme={null}
dxc.exe -T as_6_5 -E main -Fo ExampleAS.cso ExampleAS.hlsl
```

Leur structure est identique à celle des compute shaders, à l'exception de l'appel facultatif à la fonction intrinsèque [DispatchMesh](https://microsoft.github.io/DirectX-Specs/d3d/MeshShader.html#dispatchmesh-intrinsic), qui distribue un ensemble de Mesh Shaders enfants. L'exemple de code suivant présente un Amplification Shader très générique, simplement pour montrer la structure globale.

Pour une application complète des Amplification Shaders, consultez [Exemple d'élimination des meshlets](/fr/build/core-features/graphics/newfeatures/ms/ms-meshlet-culling).

L'exemple de code suivant montre la structure générique d'un Amplification Shader.

```text theme={null}
struct MyPayload 
{ 
    uint   SomeData;
    float4 MoreData;
    float3 DataData[32];
};

groupshared MyPayload payload;

[NumThreads(32, 1, 1)] 
void main(
    uint3 dispatchThreadId : SV_DispatchThreadID,
    uint3 groupThreadId : SV_GroupThreadID,
    uint groupId : SV_GroupID
)
{
    ReadMyResourceData(dispatchThreadId);

    uint count = GetMyThreadgroupCount(groupId, groupThreadId);
    BuildMyPayload(groupId, groupThreadId, payload);

    DispatchMesh(count, 1, 1, payload);
}
```

## Voir aussi

[Vue d'ensemble du pipeline Mesh Shader](/fr/build/core-features/graphics/newfeatures/ms/ms-overview)

[Pourquoi les Mesh Shaders](/fr/build/core-features/graphics/newfeatures/ms/ms-why)

[Vue d'ensemble de l'API Mesh Shader](/fr/build/core-features/graphics/newfeatures/ms/ms-api-design)

[Meshlets](/fr/build/core-features/graphics/newfeatures/ms/ms-meshlet-render)

[Exemple d'élimination des meshlets](/fr/build/core-features/graphics/newfeatures/ms/ms-meshlet-culling)


## Related topics

- [Pourquoi les Mesh Shaders ?](/fr/build/core-features/graphics/newfeatures/ms/ms-why.md)
- [Vue d'ensemble de l'API du pipeline Mesh Shader](/fr/build/core-features/graphics/newfeatures/ms/ms-api-design.md)
- [Mesh shaders et meshlets sur XBOX Series X|S](/fr/build/core-features/graphics/newfeatures/ms/index.md)
- [Vue d'ensemble du pipeline Mesh Shader](/fr/build/core-features/graphics/newfeatures/ms/ms-overview.md)
- [Meshlets](/fr/build/core-features/graphics/newfeatures/ms/ms-meshlet-render.md)