Vertex Buffers in DirectX

Why Use Vertex Buffers?

Directly sending vertex data to the GPU for every frame can be inefficient. Vertex buffers provide a mechanism to:

• Optimize Data Transfer: Vertex data is uploaded to GPU memory once and can be reused multiple times, significantly reducing CPU-to-GPU communication overhead.
• Enable Hardware Acceleration: The GPU is optimized to process data residing in its memory.
• Manage Complex Geometry: Large amounts of vertex data can be efficiently managed and accessed.

Creating and Populating a Vertex Buffer

Creating a vertex buffer involves defining the structure of your vertex data and then creating a buffer object on the GPU. In DirectX, this is commonly done using the Direct3D API.

1. Define the Vertex Structure

First, you define a C++ struct that represents your vertex. This struct will contain members for each attribute you want to associate with a vertex.

struct VertexPositionColor
{
    float x, y, z;      // Position
    float r, g, b, a;   // Color
};

2. Create the Vertex Buffer Object

You then use the Direct3D device to create a vertex buffer resource. This requires specifying the size of the buffer and how it will be accessed.

ID3D11Buffer* pVertexBuffer = nullptr;
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DEFAULT; // GPU will read from this buffer
bd.ByteWidth = sizeof(VertexPositionColor) * numVertices; // Size of buffer in bytes
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER; // Flags that this buffer is a vertex buffer
bd.CPUAccessFlags = 0; // No CPU access needed for this example

HRESULT hr = pDevice->CreateBuffer(&bd, NULL, &pVertexBuffer);
if (FAILED(hr))
    return hr;

3. Populate the Vertex Buffer

After creation, you need to upload your vertex data into the buffer. This is typically done by mapping the buffer, copying data, and then unmapping it.

D3D11_SUBRESOURCE_DATA initialData;
ZeroMemory(&initialData, sizeof(initialData));
initialData.pSysMem = vertices; // Pointer to your array of vertex data

pDeviceContext->UpdateSubresource(pVertexBuffer, 0, NULL, vertices, 0, 0);

Alternatively, for dynamic data or immediate updates, you might map and unmap:

D3D11_MAPPED_SUBRESOURCE ms;
pDeviceContext->Map(pVertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &ms);
memcpy(ms.pData, vertices, sizeof(vertices));
pDeviceContext->Unmap(pVertexBuffer, 0);

Binding and Rendering

Before rendering, the vertex buffer must be bound to the input assembler stage of the Direct3D pipeline. This tells the GPU which buffer to use for vertex data.

Binding the Vertex Buffer

UINT stride = sizeof(VertexPositionColor);
UINT offset = 0;
pDeviceContext->IASetVertexBuffers(0, 1, &pVertexBuffer, &stride, &offset);

• 0: The input slot number.
• 1: The number of buffers to bind.
• &pVertexBuffer: A pointer to the vertex buffer(s).
• &stride: The size, in bytes, of the element in the buffer.
• &offset: The offset, in bytes, from the start of the buffer to the first vertex.

Setting the Primitive Topology

You also need to specify how the vertices should be interpreted (e.g., as triangles, lines, points).

pDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

Issuing the Draw Call

Finally, a draw call instructs the GPU to render the geometry defined by the bound vertex buffer.

pDeviceContext->Draw(numVertices, 0);

• numVertices: The number of vertices to draw.
• 0: The starting vertex index.

Vertex Layouts

The vertex buffer contains raw data. The Input Layout tells the Input Assembler how to interpret this data. This is crucial for shaders to correctly access vertex attributes.

The input layout is created using ID3D11InputLayout and defined using D3D11_INPUT_ELEMENT_DESC structures that correspond to the vertex structure and the expected format by the vertex shader.

D3D11_INPUT_ELEMENT_DESC layout[] =
{
    { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
    { "COLOR",    0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};

// ... after creating vertex shader bytecode ...
ID3D11VertexShader* pVertexShader = ...;
ID3D11InputLayout* pInputLayout = nullptr;
hr = pDevice->CreateInputLayout(layout, ARRAYSIZE(layout), pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), &pInputLayout);
pDeviceContext->IASetInputLayout(pInputLayout);

• Semantic Name (e.g., "POSITION", "COLOR"): Identifies the data's purpose.
• Format (e.g., DXGI_FORMAT_R32G32B32_FLOAT): The data type and size.
• Input Slot: Matches the slot specified in IASetVertexBuffers.
• Offset: The byte offset from the start of the vertex data for this element.

Best Practices

• Batching: Group draw calls for similar geometry or materials to minimize state changes.
• Data Alignment: Ensure vertex data is properly aligned for performance.
• Resource Management: Release vertex buffer objects when they are no longer needed to free up GPU memory.
• Dynamic vs. Static: Use D3D11_USAGE_DYNAMIC for frequently changing data and D3D11_USAGE_DEFAULT for static or infrequently updated data.