From File to Pixel · Part 02: The Pipeline

03 Render Pipeline Stages

The render pipeline is the sequence of hardware and software stages that transforms geometry and material data into pixel colours in a framebuffer. Understanding which stages are programmable, which are fixed-function, and which behave differently between architectures determines how you write and optimise shader code.

Universal Stage Sequence

Programmable stages (Vertex, Fragment, Compute) run your HLSL/GLSL/MSL code on the GPU. Fixed-function stages (Rasterization, Output Merger) execute at hardware speed with no programmable code — only state configuration via API calls.

IMR vs TBDR — The Core Architectural Split

Early-Z · HSR · FPK — Depth Elimination

The most important fixed-function performance feature in the pipeline. Eliminates fragments before the fragment shader runs — saving ALU, bandwidth, and power.

Platform Pipeline Differences

PC Modern extensions — Mesh Shaders, Ray Tracing

DX12 SM6.5 / Vulkan 1.3 introduced Mesh Shaders: replace Input Assembly + Vertex + (optionally) Tessellation with two programmable stages — Amplification Shader (per-meshlet culling) and Mesh Shader (per-meshlet geometry). Nanite in Unreal 5 uses this on PC/Console for software rasterization of micro-polygons.

// DX12 Mesh Shader — per-meshlet dispatch
[numthreads(128, 1, 1)]
[OutputTopology("triangle")]
void MeshMain(
    uint3  gid  : SV_GroupID,
    uint   gtid : SV_GroupIndex,
    out vertices Vertex  verts[252],
    out indices  uint3   tris[126])
{
    Meshlet m = _Meshlets[gid.x];
    SetMeshOutputCounts(m.vertexCount, m.triangleCount);
    if (gtid < m.vertexCount)
        verts[gtid] = LoadVertex(m, gtid);
    if (gtid < m.triangleCount)
        tris[gtid]  = LoadTriangle(m, gtid);
}

Console Async Compute + ICB

PS5 and Xbox support Indirect Command Buffers (ICB) — a GPU writes draw commands into a buffer, which the GPU then executes without any CPU involvement. Combined with an Async Compute pre-pass for culling, this is how modern console engines achieve GPU-driven rendering with near-zero CPU overhead.

Mobile TBDR render pass design

On TBDR, the render pass boundary is the unit of execution. Incorrect loadOp / storeOp causes unnecessary LPDDR5 traffic. The rules are simple and absolute:

// Vulkan — correct mobile render pass configuration
VkRenderPassCreateInfo rpInfo = {};
// Depth attachment — DONT_CARE storeOp saves bandwidth
VkAttachmentDescription depthAttach = {
    .format         = VK_FORMAT_D32_SFLOAT,
    .loadOp         = VK_ATTACHMENT_LOAD_OP_CLEAR,
    .storeOp        = VK_ATTACHMENT_STORE_OP_DONT_CARE, // never hits LPDDR5
    .initialLayout  = VK_IMAGE_LAYOUT_UNDEFINED,
    .finalLayout    = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
};

VR Single-Pass Instanced Stereo

Standard stereo rendering submits every draw call twice — once per eye. Single-Pass Instanced renders both eyes in one draw: the vertex shader receives an instance ID that encodes the eye index, selects the correct VP matrix, and writes to the correct render target array layer. One draw call, two eyes, halved CPU submission cost.

Pipeline Matrix — All Platforms

04 Buffer Taxonomy

A GPU buffer is a typed allocation in memory with specific access rules. The type determines where data physically lives, who can read and write it, how the hardware caches it, and at what cost. Choosing the wrong buffer type is one of the most common sources of invisible performance loss — no compiler warning, no crash, just slower rendering.

Every Buffer Type — Where It Lives · When To Use

Access Speed Order

API Code — Vulkan / DX12 / DX11 / Metal

Vulkan

In Vulkan every buffer is a VkBuffer with usage flags. The "type" is determined by how you bind it in a descriptor set.

// Vulkan GLSL — all buffer types declared in shader
layout(set=0, binding=0) uniform FrameUBO {    // Constant Buffer
    mat4 viewProj;
    vec4 sunDir;
} frame;

layout(set=1, binding=0) readonly buffer InstanceSSBO { // Structured Buffer
    mat4 matrices[];
} instances;

layout(set=1, binding=1) buffer ParticleSSBO { // RW Structured Buffer (UAV)
    struct { vec3 pos; float life; } data[];
} particles;

layout(set=2, binding=0) uniform sampler2D albedoMap;      // Texture SRV
layout(set=2, binding=1, rgba8) uniform image2D outputTex; // RW Texture UAV

DX12

DX12 uses Descriptor Heaps — large arrays of resource descriptors (CBV, SRV, UAV, Sampler) in GPU-visible memory. Shaders index into them via the Root Signature. Bindless rendering stores thousands of texture descriptors in one heap and indexes with a root constant.

// HLSL DX12 — bindless textures via heap indexing
Texture2D textures[] : register(t0, space0); // unbounded array

uint texIndex; // passed as root constant
float4 albedo = textures[texIndex].Sample(samp, uv);

// Structured buffer — typed array
StructuredBuffer _Instances : register(t1);

// RW buffer for compute output
RWStructuredBuffer _Particles : register(u0);

DX11 / Unity Built-in

Slot-based: textures bind to t0–t127, constant buffers to b0–b13, UAVs to u0–u7. No explicit descriptor management — the driver handles it.

// HLSL DX11 / Unity — explicit register slots
Texture2D        _BaseMap    : register(t0);
SamplerState     sampler_BaseMap : register(s0);
StructuredBuffer _Instances : register(t1);

CBUFFER_START(UnityPerMaterial)
    float4 _BaseColor;
    float  _Roughness;
CBUFFER_END

// Unity NativeArray — zero-GC update
var native = new NativeArray(count, Allocator.TempJob);
// fill via Burst-compiled Job
computeBuffer.SetData(native); // memcpy native → VRAM, no GC alloc
native.Dispose();

Metal Argument Buffers — bindless as a first-class feature

Metal's Argument Buffers pack all resources for a draw — textures, samplers, constant pointers — into a single struct buffer. On Apple Silicon, the struct written by CPU is read by GPU without any copy.

// MSL — Argument Buffer
struct MaterialArgs {
    texture2d    albedo    [[id(0)]];
    texture2d    normalMap [[id(1)]];
    constant float4*    params    [[id(2)]];
    sampler             samp      [[id(3)]];
};

fragment float4 fragMain(
    Varyings in [[stage_in]],
    device MaterialArgs& mat [[buffer(0)]])
{
    float4 col = mat.albedo.sample(mat.samp, in.uv);
    return col * mat.params[0];
}

// Mobile subpass input — free tile memory read on TBDR
layout(input_attachment_index=0, set=0, binding=0)
    uniform subpassInput colorInput;
vec4 prev = subpassLoad(colorInput); // FREE on Mali/Adreno — on-chip read

Buffer Names Cross-API Reference