{"id":2612,"date":"2019-11-08T10:36:49","date_gmt":"2019-11-08T18:36:49","guid":{"rendered":"http:\/\/devblogs.microsoft.com\/directx\/?p=2612"},"modified":"2019-11-08T10:36:49","modified_gmt":"2019-11-08T18:36:49","slug":"coming-to-directx-12-mesh-shaders-and-amplification-shaders-reinventing-the-geometry-pipeline","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/directx\/coming-to-directx-12-mesh-shaders-and-amplification-shaders-reinventing-the-geometry-pipeline\/","title":{"rendered":"Coming to DirectX 12\u2014 Mesh Shaders and Amplification Shaders:\u00a0Reinventing the\u00a0Geometry Pipeline\u00a0\u00a0"},"content":{"rendered":"
\n

D3D12 <\/span>is<\/span>\u00a0add<\/span>ing<\/span>\u00a0two new shader stages: the Mesh Shader and the Amplification Shader. These additions will streamline the rendering pipeline, while simultaneously boosting flexibility and efficiency.\u00a0 In\u00a0<\/span>this\u00a0<\/span>new and improved pre-rasterization pipeline, Mesh and Amplification Shaders\u00a0<\/span>will\u00a0<\/span>optionally<\/span>\u00a0replace\u00a0<\/span>the section of the pipeline consisting of\u00a0<\/span>the Input Assembler<\/span>\u00a0as well as<\/span>\u00a0<\/span>Vertex<\/span>, Geometry, Domain, and Hull Shaders\u00a0<\/span>with richer and more\u00a0<\/span>general purpose<\/span>\u00a0capabilities<\/span>.\u00a0<\/span>This is possible through a reimagination of how geometry is processed.<\/span>\u00a0<\/span>\u00a0<\/span><\/p>\n

\n

Topics<\/h3>\n

What does the geometry pipeline look like now?<\/a><\/p>\n

How can we fix it?<\/a><\/p>\n

How do Mesh Shaders work?<\/a><\/p>\n

What does an Amplification Shader do?<\/a><\/p>\n

What exactly is a meshlet?<\/a><\/p>\n

Now that I’m sold, how do I build a Mesh Shader?<\/a><\/p>\n

How to build an Amplification Shader<\/a><\/p>\n

Calling shaders in the runtime<\/a><\/p>\n

Getting Started<\/a><\/p>\n

\n

<\/a>What\u00a0<\/span>does the geometry pipeline look like now?<\/span>\u00a0<\/span>\u00a0<\/span><\/h4>\n

In current pipelines, geometry is processed whole. This means that for a mesh with hundreds of millions of triangles,\u00a0<\/span>all the\u00a0<\/span>v<\/span>alues<\/span>\u00a0in the index buffer<\/span>\u00a0need to be processed\u00a0<\/span>in order,<\/span>\u00a0and\u00a0<\/span>all the vertices of a triangle must be processed<\/span>\u00a0before even culling can occur<\/span>. Although not all geometry is that dense, we live in a world of increasing complexity, where users want more detail without sacrificing on speed. This means that a pipeline with a\u00a0<\/span>linear bottleneck<\/span><\/b>\u00a0like the index buffer is unsustainable.\u00a0<\/span>\u00a0<\/span><\/p>\n

Additionally, the process is rigid.\u00a0<\/span>Because of the use of the index buffer, all index data must be 16 or 32 bits in size, and a single index value applies to all the vertex attributes at once.<\/span>\u00a0Options for compressing geometry data are limited.\u00a0 Culling can be performed by software at the level of an entire draw call, or by hardware on a per-primitive basis only after all the vertices of a primitive have been shaded, but there are no in-between options. These are all\u00a0<\/span>requirements that can limit how much a developer is able to do. For example,<\/span>\u00a0what if you want to store separate bounding boxes for pieces of a larger mesh, then frustum cull each piece individually, or split up a mesh into groups of triangles that share similar normals, so an entire backfacing triangle group can be rejected up-front by a single test?\u00a0 How about moving per-triangle backface tests as early as possible in the geometry pipeline, which could allow skipping the cost of fetching vertex attributes for rejected triangles?\u00a0 Or implementing conservative animation-aware bounding box culling for small chunks of a mesh, which could run before the expensive skinning computations.\u00a0 With mesh shaders, these choices are entirely under you<\/span>r<\/span>\u00a0control.<\/span>\u00a0<\/span><\/p>\n

\n

<\/a>How can we fix this?<\/span>\u00a0<\/span><\/h4>\n

In fact, we\u2019re not going to try. Mesh Shaders are not putting a band-aid onto a system that\u2019s\u00a0<\/span>struggling to keep up<\/span>.<\/span>\u00a0Instead, they are reinventing the pipeline. By\u00a0<\/span>using a compute\u00a0<\/span>programming\u00a0<\/span>model, the Mesh Shade<\/span>r can process chunks of the mesh, which we call \u201cmeshlets\u201d, in parallel.\u00a0<\/span>The threads that\u00a0<\/span>process\u00a0<\/span>each\u00a0<\/span>meshlet can work together using groupshared memory to\u00a0<\/span>read whatever format of input data\u00a0<\/span>they choose\u00a0<\/span>in whatever way they like<\/span>, process the geometry, then output a small indexed primitive list<\/span>. This means no\u00a0<\/span>more linear\u00a0<\/span>iterating through\u00a0<\/span>the entire mesh, and\u00a0<\/span>no limits imposed by the\u00a0<\/span>more\u00a0<\/span>rigid structure of previou<\/span>s shader stages.\u00a0<\/span>\u00a0<\/span><\/p>\n

\n

<\/a>How do Mesh Shaders work?\u00a0<\/span>\u00a0<\/span><\/h4>\n

A Mesh Shader begins its work by dispatching a\u00a0<\/span>set of\u00a0<\/span>threadgroup<\/span>s, each of which processes a subset of the larger mesh<\/span>. Each\u00a0<\/span>threadgroup<\/span>\u00a0<\/span>ha<\/span>s<\/span>\u00a0access to groupshared memory like compute shaders<\/span>, but\u00a0<\/span>output<\/span>s<\/span>\u00a0<\/span>vertices and primitives<\/span>\u00a0<\/span>that<\/span>\u00a0do not have to correlate with a specific thread in the group. As long a<\/span>s the threadgroup processes all vertices associated with the primitives in the threadgroup, resources can be allocated in whatever way is most effici<\/span>e<\/span>nt. Additionally, t<\/span>he Mesh Shader outputs\u00a0<\/span>both\u00a0<\/span><\/b>per-vertex and per-primitive attributes, which allows the user to be more precise and space efficient.\u00a0<\/span>\u00a0<\/span><\/p>\n

\n

<\/a>What does an Amplification Shader do<\/span>?<\/span>\u00a0<\/span><\/h4>\n

While the Mesh Shader is a fairly flexible tool, it does not allow for all\u00a0<\/span>tessellation<\/span>\u00a0scenarios<\/span>\u00a0and is not always the most efficient way to implement per-instance culling<\/span>. For this we have the Amplification Shader. What it does is simple: dispatch\u00a0<\/span>threadgroups of\u00a0<\/span>Mesh Shaders.\u00a0<\/span>Each Mesh Shader has access to the data from the parent Amplification Shader and does not return anything. The Amplification Shader\u00a0<\/span>is optional, and a<\/span>lso has access to groupshared memory, making it a\u00a0<\/span>powerful tool to allow the Mesh Shader to replace any current pipeline scenario.\u00a0<\/span>\u00a0<\/span><\/p>\n

\n

<\/a>W<\/span>hat<\/span>\u00a0exactly<\/span>\u00a0is a Meshlet<\/span>?<\/span>\u00a0<\/span>\u00a0<\/span><\/h4>\n

A meshlet is a subset of a mesh created through an intentional partition of the geometry.\u00a0<\/span>M<\/span>eshlets\u00a0<\/span>should be<\/span>\u00a0<\/span>somewhere in the range of 32 to around 200 vertices<\/span>,<\/span>\u00a0depending on the number of attributes<\/span>,<\/span>\u00a0<\/span>and\u00a0<\/span>will\u00a0<\/span>have<\/span>\u00a0as many shared vertices as possible<\/span>\u00a0to allow for vertex re-use during rendering.<\/span>\u00a0<\/span>This partitioning will be\u00a0<\/span>pre-computed and stored with the geometry to avoid computation at runtime<\/span>,\u00a0<\/span>unlike the current Input Assembler which must attempt to dynamically identify vertex reuse every time a mesh is drawn<\/span>. Titles can convert meshlets into regular index buffers for vertex shader fallback if a device does not support Mesh Shaders.\u00a0<\/span><\/p>\n

\n

<\/a>Now that I\u2019m sold, how do I use this feature?<\/span>\u00a0<\/span><\/h4>\n

Building a Mesh Shader is fairly simple.\u00a0<\/span>\u00a0<\/span><\/p>\n

You must specify the number of threads in your thread group using\u00a0<\/span>\u00a0<\/span><\/p>\n

[ numthreads ( X, Y, Z ) ]<\/pre>\n
And the type of primitive being used with\u00a0<\/span>\u00a0<\/span><\/p>\n
[ outputtopology ( T ) ]<\/pre>\n
The Mesh Shader can take a number of system values as inputs, including SV_DispatchThreadID<\/span> , SV_GroupThreadID<\/span> , SV_ViewID<\/span>\u00a0<\/span>and more, but must output an array for vertices and one for primitives.\u00a0<\/span>These are the arrays that you will write to at the end of your computations.\u00a0<\/span>If the Mesh Shader is attached to an Amplification Shader, it must also have an input for the payload.\u00a0<\/span>The final requirement\u00a0<\/span>is\u00a0<\/span>that you must set the\u00a0<\/span>number of primitives and vertices that the Mesh Shader will export. You do this by calling\u00a0<\/span>\u00a0<\/span><\/p>\n
SetMeshOutputCounts (\u00a0uint numVertices,\u00a0uint numPrimatives\u00a0)<\/pre>\n
This function\u00a0<\/span>must<\/span><\/b>\u00a0be called\u00a0<\/span>exactly once<\/span><\/b>\u00a0<\/span><\/b>in the Mesh Shader before the output arrays are written to. If this does not happen, the Mesh Shader will not output any data.\u00a0<\/span>\u00a0<\/span><\/p>\n
Beyond these rules, there is so much flexibility in what you can do. Here is an example Mesh Shader, but more information and examples can be found in the spec.<\/span><\/p>\n
#define MAX_MESHLET_SIZE 128 \r\n#define GROUP_SIZE MAX_MESHLET_SIZE \r\n#define ROOT_SIG \"CBV(b0), \\ \r\n    CBV(b1), \\ \r\n    CBV(b2), \\ \r\n    SRV(t0), \\ \r\n    SRV(t1), \\ \r\n    SRV(t2), \\ \r\n    SRV(t3)\"<\/pre>\n
struct Meshlet \r\n{ \r\n    uint32_t VertCount; \r\n    uint32_t VertOffset; \r\n    uint32_t PrimCount; \r\n    uint32_t PrimOffset; \r\n \r\n    DirectX::XMFLOAT3 AABBMin; \r\n    DirectX::XMFLOAT3 AABBMax; \r\n    DirectX::XMFLOAT4 NormalCone; \r\n};\r\n \r\nstruct MeshInfo \r\n{ \r\n    uint32_t IndexBytes; \r\n    uint32_t MeshletCount; \r\n    uint32_t LastMeshletSize; \r\n}; \r\n \r\nConstantBuffer<Constants>   Constants : register(b0); \r\nConstantBuffer<Instance>    Instance : register(b1); \r\nConstantBuffer<MeshInfo>    MeshInfo : register(b2); \r\nStructuredBuffer<Vertex>    Vertices : register(t0); \r\nStructuredBuffer<Meshlet>   Meshlets : register(t1); \r\nByteAddressBuffer           UniqueVertexIndices : register(t2); \r\nStructuredBuffer<uint>      PrimitiveIndices : register(t3);<\/pre>\n
uint3 GetPrimitive(Meshlet m, uint index) \r\n{ \r\n    uint3 primitiveIndex = PrimitiveIndices[m.PrimOffset + index]); \r\n    return uint3(primitiveIndex & 0x3FF, (primitiveIndex >> 10) & 0x3FF, (primitiveIndex >> 20) & 0x3FF);  \r\n}\r\n \r\nuint GetVertexIndex(Meshlet m, uint localIndex) \r\n{ \r\n    localIndex = m.VertOffset + localIndex; \r\n    if (MeshInfo.IndexBytes == 4) \/\/ 32-bit Vertex Indices \r\n    { \r\n        return UniqueVertexIndices.Load(localIndex * 4); \r\n    } \r\n    else \/\/ 16-bit Vertex Indices \r\n    { \r\n        \/\/ Byte address must be 4-byte aligned. \r\n        uint wordOffset = (localIndex & 0x1); \r\n        uint byteOffset = (localIndex \/ 2) * 4; \r\n \r\n        \/\/ Grab the pair of 16-bit indices, shift & mask off proper 16-bits. \r\n        uint indexPair = UniqueVertexIndices.Load(byteOffset); \r\n        uint index = (indexPair >> (wordOffset * 16)) & 0xffff; \r\n \r\n        return index; \r\n    } \r\n} \r\n \r\nVertexOut GetVertexAttributes(uint meshletIndex, uint vertexIndex) \r\n{ \r\n    Vertex v = Vertices[vertexIndex]; \r\n\r\n    float4 positionWS = mul(float4(v.Position, 1), Instance.World); \r\n \r\n    VertexOut vout; \r\n    vout.PositionVS   = mul(positionWS, Constants.View).xyz; \r\n    vout.PositionHS   = mul(positionWS, Constants.ViewProj); \r\n    vout.Normal       = mul(float4(v.Normal, 0), Instance.WorldInvTrans).xyz; \r\n    vout.MeshletIndex = meshletIndex; \r\n \r\n    return vout; \r\n} \r\n<\/pre>\n
 <\/p>\n
[RootSignature(ROOT_SIG)] \r\n[NumThreads(GROUP_SIZE, 1, 1)] \r\n[OutputTopology(\"triangle\")] \r\nvoid main( \r\n    uint gtid : SV_GroupThreadID, \r\n    uint gid : SV_GroupID, \r\n    out indices uint3 tris[MAX_MESHLET_SIZE], \r\n    out vertices VertexOut verts[MAX_MESHLET_SIZE] \r\n) \r\n{ \r\n    Meshlet m = Meshlets[gid]; \r\n    SetMeshOutputCounts(m.VertCount, m.PrimCount); \r\n    if (gtid < m.PrimCount) \r\n    { \r\n        tris[gtid] = GetPrimitive(m, gtid); \r\n    } \r\n \r\n    if (gtid < m.VertCount) \r\n    { \r\n        uint vertexIndex = GetVertexIndex(m, gtid); \r\n        verts[gtid] = GetVertexAttributes(gid, vertexIndex); \r\n    } \r\n}<\/pre>\n
\n
<\/a>How to build an Amplification Shader<\/span>\u00a0<\/span><\/h4>\n
Amplification Shaders are similarly easy to start using.\u00a0<\/span>If you choose to use an Amplification Shader, you only have to specify the number of\u00a0<\/span>threads<\/span>\u00a0per group<\/span>, using\u00a0<\/span>\u00a0<\/span><\/p>\n
[ numthreads ( X, Y, Z ) ]<\/pre>\n
You\u00a0<\/span>m<\/span>ay issue 0 or 1 calls to<\/span>\u00a0dispatch your Mesh Shaders using<\/span>\u00a0<\/span><\/p>\n
DispatchMesh ( ThreadGroupCount X, ThreadGroupCountY, ThreadGroupCountZ, MeshPayload )<\/pre>\n
Beyond this, you can choose to use groupshared memory, and the rest is up to your creativity on how to leverage this feature in the best way for your project.<\/span>\u00a0Here is a simple example to get you started:\u00a0<\/span>\u00a0<\/span><\/p>\n
struct payloadStruct\r\n{ \r\n    uint myArbitraryData; \r\n}; \r\n \r\n[numthreads(1,1,1)] \r\nvoid AmplificationShaderExample(in uint3 groupID : SV_GroupID)    \r\n{ \r\n    payloadStruct p; \r\n    p.myArbitraryData = groupID.z; \r\n    DispatchMesh(1,1,1,p);\r\n}<\/pre>\n
\n
<\/a>Calling Shaders in the Runtime\u00a0<\/span>\u00a0<\/span><\/h4>\n
To use Mesh Shaders on the API side, make sure to call CheckFeatureSupport as follows\u00a0<\/span>to ensure that Mesh Shaders are available on your device<\/span>:<\/span>\u00a0<\/span>\u00a0<\/span><\/p>\n
D3D12_FEATURE_DATA_D3D12_OPTIONS7 featureData = {};  \r\npDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS7, &featureData, sizeof(featureData)); \r\n \r\nIf ( featureData.MeshShaderTier >= D3D12_MESH_SHADER_TIER_1 ) { \r\n  \/\/Supported Mesh Shader Use \r\n}<\/pre>\n
Additionally,\u00a0<\/span>the Pipeline State Object must be compliant with the restrictions of Mesh Shaders, meaning that no incompatible shaders can be attached (Vertex, Geometry, Hull, or Domain), IA and streamout must be disabled,\u00a0<\/span>and\u00a0<\/span>your pixel shader, if provided,\u00a0<\/span>must\u00a0<\/span>be<\/span>\u00a0DXIL<\/span>. Shaders can be attached to a D3D12_PIPELINE_STATE_STREAM_DESC\u00a0<\/span>\u00a0<\/span>struct with the types CD3DX12_PIPELINE_STATE_STREAM_AS\u00a0<\/span>\u00a0<\/span>and CD3DX12_PIPELINE_STATE_STREAM_MS<\/span>\u00a0<\/span>.\u00a0<\/span>\u00a0<\/span><\/p>\n
To call the shader, run\u00a0<\/span>\u00a0<\/span><\/p>\n
DispatchMesh(ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ)<\/pre>\n
Which will launch either the Mesh Shader or the Amplification Shader if it is present. You can also use\u00a0<\/span>\u00a0<\/span><\/p>\n
void ExecuteIndirect(  \r\n    ID3D12CommandSignature *pCommandSignature,  \r\n    UINT MaxCommandCount,  \r\n    ID3D12Resource *pArgumentBuffer,  \r\n    UINT64 ArgumentBufferOffset,  \r\n    ID3D12Resource *pCountBuffer,  \r\n    UINT64 CountBufferOffset );<\/pre>\n
To launch the shaders from the GPU instead of the CPU.\u00a0<\/span>\u00a0<\/span><\/p>\n
\n
<\/a>Getting Started<\/span>\u00a0<\/span><\/h4>\n
To use Mesh Shaders and Amplification Shaders in your application, install the latest Windows 10 Insider Preview build and SDK Preview Build for\u00a0<\/span>Windows 10 (20H1)<\/span><\/a>\u00a0from the\u00a0<\/span>Windows Insider Program<\/span><\/a>. You\u2019ll also need to download and use the latest DirectX Shader Compiler. Finally, because this feature relies on GPU hardware support, you\u2019ll need to contact GPU vendors to find out specifics regarding supported hardware and drivers.<\/span>\u00a0<\/span><\/p>\n
You can find more information in the Mesh Shader specification, located here: https:\/\/microsoft.github.io\/DirectX-Specs\/d3d\/MeshShader.html<\/a>.<\/span>\u00a0<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
D3D12 is\u00a0adding\u00a0two new shader stages: the Mesh Shader and the Amplification Shader. These additions will streamline the rendering pipeline, while simultaneously boosting flexibility and efficiency.\u00a0 In\u00a0this\u00a0new and improved pre-rasterization pipeline, Mesh and Amplification Shaders\u00a0will\u00a0optionally\u00a0replace\u00a0the section of the pipeline consisting of\u00a0the Input Assembler\u00a0as well as\u00a0Vertex, Geometry, Domain, and Hull Shaders\u00a0with richer and more\u00a0general purpose\u00a0capabilities.\u00a0This is possible […]<\/p>\n","protected":false},"author":10279,"featured_media":12651,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-2612","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-directx"],"acf":[],"blog_post_summary":"
D3D12 is\u00a0adding\u00a0two new shader stages: the Mesh Shader and the Amplification Shader. These additions will streamline the rendering pipeline, while simultaneously boosting flexibility and efficiency.\u00a0 In\u00a0this\u00a0new and improved pre-rasterization pipeline, Mesh and Amplification Shaders\u00a0will\u00a0optionally\u00a0replace\u00a0the section of the pipeline consisting of\u00a0the Input Assembler\u00a0as well as\u00a0Vertex, Geometry, Domain, and Hull Shaders\u00a0with richer and more\u00a0general purpose\u00a0capabilities.\u00a0This is possible […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/directx\/wp-json\/wp\/v2\/posts\/2612","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/directx\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/directx\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/directx\/wp-json\/wp\/v2\/users\/10279"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/directx\/wp-json\/wp\/v2\/comments?post=2612"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/directx\/wp-json\/wp\/v2\/posts\/2612\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/directx\/wp-json\/wp\/v2\/media\/12651"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/directx\/wp-json\/wp\/v2\/media?parent=2612"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/directx\/wp-json\/wp\/v2\/categories?post=2612"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/directx\/wp-json\/wp\/v2\/tags?post=2612"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}