Traditional Forward Shading evaluates every light against every fragment (O(lights * fragments)), bottlenecking heavily with more than a few dozen lights. Deferred Shading solves this by rendering geometry into multiple high-bandwidth screen-space G-Buffers (diffuse, normal, specular, depth), but incurs severe memory bandwidth penalties (unfriendly to mobile GPUs and Apple Silicon tile-based architectures), breaks hardware Multisample Anti-Aliasing (MSAA), and cannot easily handle translucent or refractive surfaces. Clustered Forward Shading sub-divides the 3D camera frustum into a 3D grid of view-space voxels (clusters). A fast GPU compute shader culls thousands of dynamic lights against these clusters once per frame. The forward fragment pass then looks up only the small subset of lights (e.g. 5 to 30) that actually touch its cluster, achieving O(1) lighting scaling with zero G-Buffer bandwidth overhead and full hardware MSAA support.

Perspective projection is inherently non-linear: depth resolution is dense near the near-plane and spreads out drastically toward the far-plane. If frustum depth were partitioned linearly, the vast majority of scene geometry close to the camera would end up bunched into just the first one or two depth slices, defeating the purpose of culling. Exponential depth slicing partitions slice boundaries using z_i = z_near * (z_far / z_near)^(i / N_z). This produces cluster volumes that scale proportionally with perspective foreshortening, keeping view-space screen projected cluster sizes relatively uniform and preventing light count imbalances.

In the light culling compute pass (light_cull.wgsl), each workgroup thread evaluates a cluster against global light bounding spheres. If a light intersects the cluster AABB, the thread issues an atomic addition (atomicAdd(&cluster.count, 1u)) to reserve an index slot in a global light-index storage buffer. To prevent buffer overflows from dense light overlap, the addition is clamped to a safe maximum (e.g., 64 or 128 lights per cluster). The resulting buffer layout contains an array of Cluster headers { offset: u32, count: u32 } pointing into the contiguous global light index array.

Modern mobile SoCs (Apple Silicon M-series/A-series, Qualcomm Snapdragon, MediaTek Dimensity) use Tile-Based Deferred Rendering (TBDR) architectures where memory bandwidth across the system bus is the single largest consumer of thermal headroom and battery power. Deferred shading requires constantly streaming 32 to 64 bytes of G-Buffer data per pixel out to system VRAM and reading it back. Clustered Forward Shading keeps all lighting calculations inside the fragment shader with on-chip registers, requiring only a tiny read-only light index buffer (a few hundred kilobytes). This dramatically boosts frame rates on WebGPU-enabled mobile and ultraportable devices.