Real-time rendering is the discipline of turning a 3D scene description into pixels on screen fast enough to feel interactive, typically 30-144 times per second, which is what separates game graphics from offline film rendering where a single frame can take hours. Every visual choice in a game, from a character's skin to a puddle's reflection, is the output of a pipeline: a fixed sequence of GPU stages plus a set of shading, lighting, and post-processing techniques layered on top, all running under a strict time budget. The central tension a graphics programmer manages is quality versus milliseconds — a physically accurate technique like path-traced global illumination looks better than a cheap approximation like a baked light probe, but only the approximation reliably hits 16.6ms per frame on a mid-range GPU. Understanding which technique trades which kind of realism for which kind of speed, and how modern APIs like Vulkan and DirectX 12 hand programmers direct control over that trade, is the core skill this cheat sheet builds toward.
What This Cheat Sheet Covers
This topic spans 15 focused tables and 91 indexed concepts. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.
A jump-to index of every table row in this cheat sheet.
An interactive map of every table and concept in this topic.
Table 1: The Graphics Pipeline (Vertex to Pixel)
Every frame passes through a fixed sequence of GPU stages that convert 3D vertex data into 2D pixels; some stages are fixed-function (configurable but not programmable) and others are fully programmable shader stages. Knowing this order is the foundation for understanding every technique later in this sheet, since each one plugs into a specific stage.
| Stage | Example | Description |
|---|---|---|
vkCmdBindVertexBuffers(cmd, 0, 1, &vbo, offsets);vkCmdBindIndexBuffer(cmd, ibo, 0, VK_INDEX_TYPE_UINT32); | Reads raw vertex and index data from buffers and assembles it into primitives (triangles, lines, points) for the pipeline. | |
gl_Position = projection * view * model * vec4(aPos, 1.0); | Runs once per vertex, transforming positions from model space through world and view space into clip space and passing per-vertex data downstream. | |
Hull shader outputs tessellation factors → fixed-function tessellator subdivides the patch → Domain shader positions new vertices. | • Optional stage that subdivides low-poly patches into denser geometry. • Used to add detail to terrain or curved surfaces near the camera. | |
layout (triangles) in;layout (triangle_strip, max_vertices = 3) out; | Runs per-primitive and can emit zero, one, or many primitives; flexible but generally avoided in modern engines due to poor performance on most GPUs. |