Deferred Rendering: Populating the G-Buffer

Topic Overview

Forward Rendering Scales with Lights Times Objects

Forward rendering draws each object and lights it in the same pass. With 100 lights and 1000 objects, you risk 100,000 lighting calculations, most wasted because each light affects only a small screen region.

Deferred rendering (Michael Deering, 1988; popularized by Killzone 2) splits work into two passes:

1. Geometry pass: render opaque objects to a G-buffer storing per-pixel surface data (position, normal, albedo, material params) without lighting
2. Lighting pass: for each light, render a fullscreen quad or light volume; fragment shader reads G-buffer and shades only affected pixels

Tradeoffs and Tiled Variants

Lighting cost depends on screen resolution and light count, not triangle count. A million-triangle scene with few lights runs as fast as a hundred-triangle scene.

cCopy
Loading…

For example, a dynamic point light touches maybe 5% of screen pixels; deferred shades only those instead of every object surface. Tradeoffs include high G-buffer bandwidth, difficult MSAA, and transparency requiring a forward pass afterward. Modern engines add tiled deferred to cull lights per screen tile.

For This Exercise

You will simulate the geometry pass by populating a tiny G-buffer from vertex data. This task asks you to write position, normal, and albedo per pixel without computing lighting. The G-buffer layout you build here is what RenderDoc shows when debugging deferred renderers in Unreal or id Tech.

Your Task

Implement deferred shading in two passes:

1. The geometry pass rasterizes every triangle into a G-buffer, keeping for each pixel only the nearest surface: which triangle it is (and so its normal and albedo) and its depth.
2. The lighting pass then shades each covered pixel once, reading only the G-buffer.

Report the numbers that make deferred shading worthwhile: fragments rasterized, pixels covered, overdraw, and light evaluations compared with forward shading, which lights every fragment, including hidden ones.

Input

# starts a comment.

cCopy
Loading…

Geometry pass

• Coverage: pixel centres are at (x+½, y+½). Use integer edge functions on a doubled grid (vertices at 2x, 2y, centres at 2x+1, 2y+1) with the top-left rule, as in the pipeline task: a zero edge value counts only for a top edge (ay == by && bx > ax) or a left edge (by < ay).
• Winding: triangles are never culled. A negative-area triangle has vertices 1 and 2 swapped first, and zero area is skipped.
• Depth: z = round_half_up(Σ wᵢzᵢ / Σwᵢ). The fragment is kept if z < the stored depth, which starts at 1000. Every covered pixel centre counts as a fragment.
• Summary: geometry pass: T triangle(s), F fragment(s), P pixel(s) covered, plus , overdraw F/P to 2 decimals (half up) when P > 0.

Lighting pass

For each covered pixel, with its triangle's normal n and albedo a:

• sum = ambient × 10000 + Σ max(0, n·l) × intensity over the lights, with no normalization (the vectors are assumed unit ×100);
• lit = min(255, a × sum / 1000000), using integer division.
• Summary: lighting pass: P pixel(s) x L light(s) = P·L evaluations (forward shading: F·L).

Output

show prints the G-buffer, one row per line, each ending with |:

• id: the triangle letter (A = first), or . for empty;
• depth: '0' + z/100;
• albedo: the hex digit of albedo/16;
• lit: the ramp character " .:-=+*#%@"[lit × 10 / 256] (empty pixels have lit 0).

cCopy
Loading…

probe prints pixel (x, y): empty or the line above.

Errors:

• gbuffer: W (1-24) H (1-16) (a valid resize requires a new render)
• ambient: PERCENT (0-100)
• light: DX DY DZ INTENSITY%, light: at most 4 lights
• tri: X0 Y0 Z0 X1 Y1 Z1 X2 Y2 Z2 NX NY NZ ALBEDO, tri: at most 16 triangles
• show: id|depth|albedo|lit, show: render first
• probe: X Y inside the G-buffer, probe: render first
• unknown command X

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. The lighting pass may read only the G-buffer. It never looks at triangles that lost the depth test.
2. Keep everything in integers (edge functions, depth and lighting) so the image is identical on every machine.

Hidden tests cover three lights including a back-facing one, saturation at 255, surfaces facing away from all lights (ambient only), depth ordering, the depth and albedo views, an empty scene, and argument errors.