The document discusses advanced techniques and optimizations for vertex shaders in DirectX 11, highlighting common bottlenecks and providing various performance-enhancing strategies. It covers the use of features such as advanced vertex outputs, instancing methods, and UAVs (Unordered Access Views) in shaders. Additionally, it presents examples and code snippets demonstrating how to implement full-screen triangles, point sprites, and a particle system utilizing these techniques.

1. Vertex Shader Tricks
New Ways to Use the Vertex Shader to Improve
Performance
Bill Bilodeau
Developer Technology Engineer, AMD

2. Topics Covered
● Overview of the DX11 front-end pipeline
● Common bottlenecks
● Advanced Vertex Shader Features
● Vertex Shader Techniques
● Samples and Results

3. Graphics Hardware
DX11 Front-End Pipeline
● VS –vertex data
● HS – control points
● Tessellator
● DS – generated vertices
● GS – primitives
● Write to UAV at all stages
● Starting with DX11.1
Vector GPR’s
(256 2048-bit registers)
Vector ALU
(1 64-way single precision operation every 4 clocks)
Scalar ALU
(1 operation every 4 clocks)
Scalar GPR’s
(256 64-bit registers)
Vector/Scalar cross communication bus
Vector GPR’s
(256 2048-bit registers)
Vector ALU
(1 64-way single precision operation every 4 clocks)
Scalar ALU
(1 operation every 4 clocks)
Scalar GPR’s
(256 64-bit registers)
Vector/Scalar cross communication bus
Vector GPR’s
(256 2048-bit registers)
Vector ALU
(1 64-way single precision operation every 4 clocks)
Scalar ALU
(1 operation every 4 clocks)
Scalar GPR’s
(256 64-bit registers)
Vector/Scalar cross communication bus
.
.
.
Input Assembler
Hull Shader
Domain
Shader
Tessellator
Geometry
Shader
Stream
Out
CB,
SRV,
or
UAV
Vertex Shader

4. Bottlenecks - VS
● VS Attributes
● Limit outputs to 4 attributes (AMD)
●This applies to all shader stages (except PS)
● VS Texture Fetches
● Too many texture fetches can add latency
●Especially dependent texture fetches
●Group fetches together for better performance
●Hide latency with ALU instructions

5. Bottlenecks - VS
● Use the caches wisely
● Avoid large vertex formats
that waste pre-VS cache
space
● DrawIndexed() allows for
reuse of processed vertices
saved in the post-VS cache
●Vertices with the same index
only need to get processed once
Vertex Shader
Pre-VS Cache
(Hides Latency)
Input Assembler
Post-VS Cache
(Vertex Reuse)

6. Bottlenecks - GS
● GS
● Can add or remove primitives
● Adding new primitives requires storing new
vertices
●Going off chip to store data can be a bandwidth issue
● Using the GS means another shader stage
●This means more competition for shader resources
●Better if you can do everything in the VS

7. Advanced Vertex Shader Features
● SV_VertexID, SV_InstanceID
● UAV output (DX11.1)
● NULL vertex buffer
● VS can create its own vertex data

8. SV_VertexID
● Can use the vertex id to decide what
vertex data to fetch
● Fetch from SRV, or procedurally create a
vertex
VSOut VertexShader(SV_VertexID id)
{
float3 vertex = g_VertexBuffer[id];
…
}

9. UAV buffers
● Write to UAVs from a Vertex Shader
● New feature in DX11.1 (UAV at any stage)
● Can be used instead of stream-out for
writing vertex data
● Triangle output not limited to strips
●You can use whatever format you want
● Can output anything useful to a UAV

10. NULL Vertex Buffer
● DX11/DX10 allows this
● Just set the number of vertices in Draw()
● VS will execute without a vertex buffer bound
● Can be used for instancing
● Call Draw() with the total number of vertices
● Bind mesh and instance data as SRVs

11. Vertex Shader Techniques
● Full Screen Triangle
● Vertex Shader Instancing
● Merged Instancing
● Vertex Shader UAVs

12. Full Screen Triangle
● For post-processing effects
● Triangle has better performance
than quad
● Fast and easy with VS
generated coordinates
● No IB or VB is necessary
● Something you should be
using for full screen effects
Clip Space Coordinates
(-1, -1, 0)
(-1, 3, 0)
(3, -1, 0)

13. Full Screen Triangle: C++ code
// Null VB, IB
pd3dImmediateContext->IASetVertexBuffers( 0, 0, NULL, NULL, NULL );
pd3dImmediateContext->IASetIndexBuffer( NULL, (DXGI_FORMAT)0, 0 );
pd3dImmediateContext->IASetInputLayout( NULL );
// Set Shaders
pd3dImmediateContext->VSSetShader( g_pFullScreenVS, NULL, 0 );
pd3dImmediateContext->PSSetShader( … );
pd3dImmediateContext->PSSetShaderResources( … );
pd3dImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
// Render 3 vertices for the triangle
pd3dImmediateContext->Draw(3, 0);

14. Full Screen Triangle: HLSL Code
VSOutput VSFullScreenTest(uint id:SV_VERTEXID)
{
VSOutput output;
// generate clip space position
output.pos.x = (float)(id / 2) * 4.0 - 1.0;
output.pos.y = (float)(id % 2) * 4.0 - 1.0;
output.pos.z = 0.0;
output.pos.w = 1.0;
// texture coordinates
output.tex.x = (float)(id / 2) * 2.0;
output.tex.y = 1.0 - (float)(id % 2) * 2.0;
// color
output.color = float4(1, 1, 1, 1);
return output;
}
Clip Space Coordinates
(-1, -1, 0)
(-1, 3, 0)
(3, -1, 0)

15. VS Instancing: Point Sprites
● Often done on GS, but can be faster on VS
● Create an SRV point buffer and bind to VS
● Call Draw or DrawIndexed to render the full
triangle list.
● Read the location from the point buffer and
expand to vertex location in quad
● Can be used for particles or Bokeh DOF sprites
● Don’t use DrawInstanced for a small mesh

16. Point Sprites: C++ Code
pd3d->IASetIndexBuffer( g_pParticleIndexBuffer, DXGI_FORMAT_R32_UINT, 0 );
pd3d->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
pd3dImmediateContext->DrawIndexed( g_particleCount * 6, 0, 0);

17. Point Sprites: HLSL Code
VSInstancedParticleDrawOut VSIndexBuffer(uint id:SV_VERTEXID)
{
VSInstancedParticleDrawOut output;
uint particleIndex = id / 4;
uint vertexInQuad = id % 4;
// calculate the position of the vertex
float3 position;
position.x = (vertexInQuad % 2) ? 1.0 : -1.0;
position.y = (vertexInQuad & 2) ? -1.0 : 1.0;
position.z = 0.0;
position.xy *= PARTICLE_RADIUS;
position = mul( position, (float3x3)g_mInvView ) +
g_bufPosColor[particleIndex].pos.xyz;
output.pos = mul( float4(position,1.0), g_mWorldViewProj );
output.color = g_bufPosColor[particleIndex].color;
// texture coordinate
output.tex.x = (vertexInQuad % 2) ? 1.0 : 0.0;
output.tex.y = (vertexInQuad & 2) ? 1.0 : 0.0;
return output;
}

18. Point Sprite Performance
Indexed, 500K SpritesNon-Indexed, 500K SpritesGS, 500K SpritesDrawInstanced, 500K SpritesIndexed, 1M SpritesNon-Indexed, 1M SpritesGS, 1M SpritesDrawInstanced, 1M Sprit
R9 290x (ms) 0.52 0.77 1.38 1.77 1.02 1.53 2.7 3.54
Titan (ms) 0.52 0.87 0.83 5.1 1.5 1.92 1.6 10.3
0
2
4
6
8
10
12
AMD Radeon R9 290x
Nvidia Titan

19. Point Sprite Performance
● DrawIndexed() is the fastest method
● Draw() is slower but doesn’t need an IB
● Don’t use DrawInstanced() for creating
sprites on either AMD or NVidia hardware
● Not recommended for a small number of
vertices

20. Merge Instancing
● Combine multiple meshes that can be
instanced many times
● Better than normal instancing which renders
only one mesh
● Instance nearby meshes for smaller bounding box
● Each mesh is a page in the vertex data
● Fixed vertex count for each mesh
●Meshes smaller than page size use degenerate triangles

21. Merge Instancing
Mesh Vertex Data
Mesh Data 0
Mesh Data 1
Mesh Data 2
.
.
.
Mesh Instance Data
Instance 0
Mesh Index 2
Instance 1
Mesh Index 0
.
.
.
Degenerate
Triangle
Vertex 0
Vertex 1
Vertex 2
Vertex 3
.
.
.
0
0
0
Fixed Length Page

22. Merged Instancing using VS
● Use the vertex ID to look up the mesh to
instance
● All meshes are the same size, so (id / SIZE)
can be used as an offset to the mesh
● Faster than using DrawInstanced()

23. Merge Instancing Performance
0
5
10
15
20
25
30
DrawInstanced Soft Instancing
R9 290x
GTX 780
● Instancing performance test by
Cloud Imperium Games for Star
Citizen
● Renders 13.5M triangles (~40M
verts)
● DrawInstanced version calls
DrawInstanced() and uses instance
data in a vertex buffer
● Soft Instancing version uses
vertex instancing with Draw() calls
and fetches instance data from
SRV
AMD Radeon
R9 290X
Nvidia
GTX 780
ms

24. Vertex Shader UAVs
● Random access Read/Write in a VS
● Can be used to store transformed vertex
data for use in multi-pass algorithms
● Can be used for passing constant
attributes between any shader stage (not
just from VS)

25. Skinning to UAV
● Skin vertex data then output to UAV
● Instance the skinned UAV data multiple times
● Can also be used for non-instanced data
● Multiple passes can reuse the transformed
vertex data – Shadow map rendering
● Performance is about the same as
stream-out, but you can do more …

26. Bounding Box to UAV
● Can calculate and store Bbox in the VS
● Use a UAV to store the min/max values (6)
● InterlockedMin/InterlockedMax determine min
and max of the bbox
●Need to use integer values with atomics
● Use the stored bbox in later passes
● GPU physics (collision)
● Tile based processing

27. Bounding Box: HLSL Code
void UAVBBoxSkinVS(VSSkinnedIn input, uint id:SV_VERTEXID )
{
// skin the vertex
. . .
// output the max and min for the bounding box
int x = (int) (vSkinned.Pos.x * FLOAT_SCALE); // convert to integer
int y = (int) (vSkinned.Pos.y * FLOAT_SCALE);
int z = (int) (vSkinned.Pos.z * FLOAT_SCALE);
InterlockedMin(g_BBoxUAV[0], x);
InterlockedMin(g_BBoxUAV[1], y);
InterlockedMin(g_BBoxUAV[2], z);
InterlockedMax(g_BBoxUAV[3], x);
InterlockedMax(g_BBoxUAV[4], y);
InterlockedMax(g_BBoxUAV[5], z);
. . .

28. Particle System UAV
● Single pass GPU-only particle system
● In the VS:
● Generate sprites for rendering
● Do Euler integration and update the particle
system state to a UAV

29. Particle System: HLSL Code
uint particleIndex = id / 4;
uint vertexInQuad = id % 4;
// calculate the new position of the vertex
float3 oldPosition = g_bufPosColor[particleIndex].pos.xyz;
float3 oldVelocity = g_bufPosColor[particleIndex].velocity.xyz;
// Euler integration to find new position and velocity
float3 acceleration = normalize(oldVelocity) * ACCELLERATION;
float3 newVelocity = acceleration * g_deltaT + oldVelocity;
float3 newPosition = newVelocity * g_deltaT + oldPosition;
g_particleUAV[particleIndex].pos = float4(newPosition, 1.0);
g_particleUAV[particleIndex].velocity = float4(newVelocity, 0.0);
// Generate sprite vertices
. . .

30. Conclusion
● Vertex shader “tricks” can be more
efficient than more commonly used methods
● Use SV_Vertex ID for smarter instancing
●Sprites
●Merge Instancing
● UAVs add lots of freedom to vertex shaders
●Bounding box calculation
●Single pass VS particle system

31. Demos
● Particle System
● UAV Skinning
● Bbox

32. Acknowledgements
● Merge Instancing
● Emil Person, “Graphics Gems for Games”
SIGGRAPH 2011
● Brendan Jackson, Cloud Imperium
● Thanks to
● Nick Thibieroz, AMD
● Raul Aguaviva (particle system UAV), AMD
● Alex Kharlamov, AMD

33. Questions
● bill.bilodeau@amd.com