Exemple d'élimination des meshlets

Nous vous recommandons de lire d’abord la rubrique Meshlets. La rubrique Exemple d’élimination des meshlets présente le pseudocode d’une implémentation, dans un Amplification Shader, d’une technique appelée élimination des meshlets (meshlet culling). Étant donné que les primitives d’un meshlet présentent idéalement une cohérence spatiale et d’orientation, nous pouvons stocker des données d’élimination efficaces par meshlet. Celles-ci permettent d’éliminer rapidement une liste de meshlets par rapport à une vue dans un Amplification Shader et de ne distribuer des instances de Mesh Shader que pour les meshlets restants. La technique commence par un Amplification Shader dans lequel chaque thread traite un seul meshlet. Cela signifie que nous devons distribuer ceil(MeshletCount / GROUP_SIZE) groupes de threads sur la liste de commandes. Chaque groupe de threads de l’Amplification Shader est alors chargé de traiter GROUP_SIZE meshlets. Chaque thread élimine son meshlet par rapport au frustum de la vue, détermine son emplacement d’exportation, puis écrit son index dans les données de charge utile. Il utilise ensuite DispatchMesh pour distribuer un groupe de threads de Mesh Shader pour chaque meshlet restant à rendre. Chaque groupe de threads de Mesh Shader charge alors son meshlet à partir des données de charge utile et exporte sa géométrie. L’exemple complet est disponible sur la page des téléchargements pour les développeurs XBOX.

Amplification Shader

La structure de l’Amplification Shader est identique à celle des nuanceurs de calcul, mais se termine par au plus un appel ‘DispatchMesh(…)’. Tout d’abord, chaque thread charge son meshlet et l’élimine par rapport à la vue. Ensuite, une routine de compactage est exécutée pour déterminer l’emplacement d’écriture final de chaque thread. Elle fournit également le nombre final de meshlets non éliminés pour le groupe de threads. Enfin, l’index du meshlet est écrit dans les données de charge utile groupshared, et DispatchMesh est appelé avec le nombre de meshlets restants et les données de charge utile. L’exemple suivant présente, en pseudocode, un Amplification Shader qui implémente l’élimination des meshlets.

#define GROUP_SIZE 128

struct Meshlet
{
    // Meshlet data.
    uint VertexOffset;
    uint VertexCount;
    uint PrimitiveOffset;
    uint PrimitiveCount;

    // Local Culling data.
    float4 BoundingSphere;
    float4 NormalCone;
};

StructuredBuffer<Meshlet> Meshlets : register(t0);

cbuffer ViewProps : register(b0)
{
    float4x4 ViewMat;
    float4x4 ViewProjMat;
    float3   ViewPosition;
};

struct MyPayload 
{ 
    uint MeshletIndices[GROUP_SIZE]; 
};

groupshared MyPayload payload;

bool CullTests(Meshlet m) { ... }
void CalcPayloadIndexAndCount(bool isCulled, out index, out count) { ... }

[NumThreads(GROUP_SIZE, 1, 1)] 
void main(
    uint dispatchThreadId : SV_DispatchThreadID,
    uint groupThreadId : SV_GroupThreadID
)
{
    Meshlet meshlet = Meshlets[dispatchThreadId];
    bool isCulled = CullTests(meshlet);
    
    uint index, count;
    CalcPayloadIndexAndCount(groupThreadId, isCulled, index, count);
    
    if (!isCulled)
    {
        payload.MeshletIndices[index] = dispatchThreadId;
    }

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

Mesh Shader

Le Mesh Shader du pipeline est très similaire au rendu de meshlets avec un pipeline composé uniquement d’un Mesh Shader, à ceci près que nous lisons l’index du meshlet du groupe de threads à partir des données de charge utile. Les données de charge utile sont les mêmes données que celles construites et exportées par l’Amplification Shader précédent. Les GroupID et DispatchThreadID sont localisés au cluster de Mesh Shader distribué par le groupe de threads de l’Amplification Shader appelant, et ils partagent tous les mêmes données de charge utile. Cet exemple de code présente le Mesh Shader qui suit l’Amplification Shader précédent.

#define MAX_MESHLET_SIZE 128

StructureBuffer<MyVertex>   Vertices;
StructureBuffer<Meshlet>    Meshlets;
StructuredBuffer<uint>      UniqueVertexIndices;
StructureBuffer<uint3>      PrimitiveIndices;

VertexOut TransformVertex(MyVertex v) { ... }

[NumThreads(MAX_MESHLET_SIZE, 1, 1)]
[OutputTopology("triangle")]
void main(
    uint groupThreadId : SV_GroupIndex,
    uint groupId : SV_GroupID,
    in payload MyPayload payload,
    out vertices VertexOut verts[MAX_MESHLET_SIZE],
    out indices uint3 tris[MAX_MESHLET_SIZE])
{
    uint meshletIndex = payload.MeshletIndices[groupId];
    Meshlet m = Meshlets[meshletIndex];

    SetMeshOutputCounts(m.VertCount, m.PrimCount);

    if (groupThreadId < m.PrimCount) 
    {
        tris[groupThreadId] = PrimitiveIndices[m.PrimOffset + groupThreadId];
    }

    if (groupThreadId < m.VertCount) 
    {
        uint index = UniqueVertexIndices[m.VertOffset + groupThreadId];
        MyVertex vin = Vertices[index];

        verts[groupThreadId] = TransformVertex(vin);
    }
}

Voir aussi

Vue d’ensemble du pipeline Mesh Shader Pourquoi les Mesh Shaders ? Vue d’ensemble de l’API Mesh Shader Meshlets

GDK and Game Engines Integration

Steam porting guide

Game Principles

Core Features

Console Features

Amplification Shader

Mesh Shader

Voir aussi

​Amplification Shader

​Mesh Shader

​Voir aussi

Amplification Shader

Mesh Shader

Voir aussi