Highlights narrower than a pixel

Why highlights sparkle

Key idea. A pixel shaded once evaluates the BRDF at one normal. Where the normal turns further across the pixel than the highlight is wide, the pixel either catches the highlight or misses it, and which one changes whenever anything moves.

A smooth surface's highlight is narrow. A curved surface's normal turns across every pixel. Once the turn is wider than the highlight, the pixel's one shading point says nothing about the rest of what the pixel covers.

D, the GGX normal distribution function, depends on the angle between the normal N and the half vector H. At α = roughness², by this guide's arithmetic, D falls to half its peak when H is 0.37° from N at roughness 0.1, and 0.059° from N at the roughness floor, 0.04. Compare that with a sphere 30 pixels across: at its centre, its normal turns by 1/15 radian, about 3.8°, from one pixel to the next, and more towards its rim. The roughness-0.1 highlight is a tenth of that pixel-to-pixel step. Most pixels miss it. The few whose centres land on it show it at full strength, and as the light, the object or the camera moves, the highlight jumps from pixel to pixel instead of gliding. That is specular aliasing.

4x MSAA does not reach it. The lit pass tests coverage and depth at four samples per pixel, but runs its fragment shader once per pixel (ADR 0019), so MSAA smooths the edges of triangles, not the shading inside them. Shading per sample would only move the problem a factor of two finer, at up to four times the shading cost, and the ticket ruled it out on cost. Temporal accumulation, which averages over frames, is ruled out by ADR 0008: nothing the image depends on reads screen-space history. So the fix has to live in the shading itself. The single evaluation has to return what the pixel's average would have been.

The cooked mips already do part of this. The cooker widens each mip's roughness by how much the normal map's normals disagree within a texel, after Toksvig (Anisotropy Explained). That covers detail smaller than a texel of the mip being sampled. It does nothing for the normal's change from pixel to pixel: the curvature of the mesh, and normal-map detail at a fine mip, where each texel spans several pixels.

Filtering the distribution

Key idea. A narrow lobe averaged over a spread of normals is, near enough, a wider lobe over one normal: the two widths add in quadrature. So the pixel can be shaded once, with α² raised by the spread of the normals it covers.

The pixel should show the BRDF averaged over its footprint. Inside that footprint the normal varies. Averaging a lobe over a varying normal blurs it, and a blurred GGX lobe is close to a wider GGX lobe. So widen the lobe, and shade once.

The argument runs in slope space, where a microfacet normal m becomes the slope (−m_x/m_z, −m_y/m_z). There the Beckmann distribution is a Gaussian whose variance along each axis is α²/2. Kaplanyan, Hill, Patney and Lefohn (HPG 2016) write it as a covariance matrix, Σ_B = diag(α_s²/2, α_t²/2), "where we use the relation α² = 2σ² [BS63] between the standard deviation of a Gaussian distribution and the roughness parameter of a Beckmann distribution". Averaging a Gaussian over another Gaussian adds their covariances, so their eq. (15) filters the distribution by adding the pixel's own, Σ′_B = Σ_B + Σ_P. GGX is not a Gaussian, but the same paper uses a Beckmann lobe of the same α as a proxy for it, and Tokuyoshi and Kaplanyan (I3D 2019) note that "this roughness matrix can be used to approximate the filtering of the GGX NDF". Their roughness matrix is twice the covariance.

What is the pixel's covariance? Model the pixel as a Gaussian filter of standard deviation σ in screen space; Tokuyoshi and Kaplanyan take σ = 0.5 pixels. Near the pixel's centre the normal changes linearly, by ∂n/∂x per pixel across the screen and ∂n/∂y down it. Over the filter, it therefore spreads by about σ times those changes. For small turns, a normal's change and its slope's change are about the same size. Their isotropic form, eq. (4), adds both screen directions' squared changes, doubles the variance into roughness and caps it at κ:

In the shader, σ² is PIXEL_FILTER_VARIANCE, 0.25, and κ is MAXIMUM_FILTER_ALPHA_SQUARED, 0.18. The function takes roughness and returns roughness, since that is what decode_surface stores; the fourth root undoes α² = roughness⁴.

fn specular_antialiased_roughness(
    roughness: f32,
    normal_change_x: vec3<f32>,
    normal_change_y: vec3<f32>
) -> f32 {
    let normal_variance = PIXEL_FILTER_VARIANCE
        * (dot(normal_change_x, normal_change_x) + dot(normal_change_y, normal_change_y));
    let filter_alpha_squared = min(2.0 * normal_variance, MAXIMUM_FILTER_ALPHA_SQUARED);
    let alpha = roughness * roughness;
    return sqrt(sqrt(min(alpha * alpha + filter_alpha_squared, 1.0)));
}

How much does it widen? It depends on how many pixels the curvature is spread over. By this guide's arithmetic, at the centre of a sphere, where each derivative is 1/radius per pixel:

The small sphere's mirror becomes roughness 0.26 at its centre. That is a large change, and it is what the pixel's average looks like: at that size, each pixel covers normals spread over several degrees, and a 0.06°-wide lobe averaged over them is a lobe several degrees wide. Rough surfaces barely change, because their lobes are already wider than the pixel's spread. Variances add, so a small spread added to a large one makes little difference.

Derivatives, κ and the floor

Key idea. The derivatives come free from the 2×2 quads the GPU shades in, and under 4x MSAA they are per pixel, the footprint the filter assumes. Two limits stop the widening from running away: κ on what it adds and 1 on the total. The roughness floor applies after both.

The GPU already shades pixels in groups of four so it can compare neighbours. Asking how the normal changes costs a subtraction. The limits matter where the normal changes fastest, at the rims.

A GPU runs fragment shaders in 2×2 quads. WGSL's dpdx(v) is the difference in v between horizontal neighbours in a quad, and dpdy(v) between vertical ones. These are screen-space derivatives. A derivative is only defined while every pixel of the quad is running the same code, so fs_main samples every texture first, builds the shading normal, and takes dpdx(normal) and dpdy(normal) before any per-light branching. The normal it differences is the one after the normal map, so both the mesh's curvature and the normal map's detail count.

Under 4x MSAA the lit pass shades once per pixel, not per sample, so neighbouring invocations are one pixel apart and the derivatives are per pixel. A comment beside the call says so. That is the unit σ is measured in.

A quad belongs to one triangle. Where a quad overhangs its triangle, the extra pixels run as helpers with that triangle's interpolants, so a derivative never differences across a triangle edge. A flat facet with one normal across it therefore gets no widening at all. Its highlight lights the facet whole or not at all, as helmet's faceplate shows when the sweep draws it without its textures. That is not aliasing: it is what a flat mirror does.

κ, the cap on what filtering adds

Towards a silhouette, the normal turns ever faster per pixel and the derivatives grow without bound. Uncapped, every rim would be shaded at roughness 1. κ = 0.18 caps the α² that filtering adds, so a perfect mirror widens to at most 0.18^1/4 ≈ 0.65 roughness (this guide's arithmetic). Tokuyoshi and Kaplanyan give κ = 0.18 as "the clamping threshold" with their eq. (1), and eq. (4) keeps it. The listing in their paper then saturates the sum, so the total α² stays at or below 1, and specular_antialiased_roughness does the same with min(…, 1.0).

Then the floor

decode_surface widens the Material's roughness first and applies MINIMUM_ROUGHNESS, 0.04, to the result. The floor exists so that D stays finite (Lit Pass Explained). Widening can only raise roughness, so a widened value never needs the floor. A surface whose normal does not change, such as a flat floor or the furnace in chapter 4, still lands on the floor exactly as before.

The oracle

specular_antialiased_roughness_adds_the_normals_variance_to_alpha_squared runs the WGSL function on the GPU and compares it with eq. (4) evaluated in f64. It covers a still normal, a change along each screen axis alone, a change large enough to reach κ, and a roughness high enough to reach the cap at 1. The decode_surface oracle passes zero derivatives, so it still tests only the decoding.

A furnace from the floor

Key idea. To sum a lobe narrower than the grid, sum over the variable it is narrow in. The specular lobe is narrow in H at every view, so the furnace sums over half vectors and maps each to its light with the Jacobian 4 (V·H).

A furnace adds up how much light a white surface sends back. If the grid it adds over is coarser than the highlight, the sum depends on where the grid's points happen to fall. That tells you nothing about the shader.

The white furnace lights a surface equally from every direction and sums what it sends towards V, its directional albedo. A white metal that conserves energy reflects at most 1. Before #351, the oracle summed over 16,200 light directions in cells of 1° by 2°, at roughness 0.5 and 1 only (Lit Pass Explained). The ticket asked for the sweep to run from the floor to 1. On the old grid, the floor is meaningless:

Summing over half vectors

At every view, the specular lobe sits around H = N, as narrow in H as α. So the test puts its grid on H and derives the light from each half vector by reflecting the view about it: L = 2 (V·H) H − V. Cells of equal size in H are not equal in L. A small solid angle dω_H about H maps to dω_L = 4 (V·H) dω_H about L, the reflection Jacobian that Walter et al. (2007) derive to sample GGX. Each cell's light is weighted by that.

The half vectors lie on rings about the normal, 48 to a ring in azimuth. The first ring ends 10⁻⁵ radian from the normal, and each ring after it is 10% wider than the one inside it, until rings reach 1° wide at 10.5°; from there to the horizon they stay 1° wide. That is 184 rings and 8,832 half vectors per view, less those facing away from V. The rings are finest where the floor's lobe lives, so the sum no longer depends on where it lands.

The sweep and its bounds

The test sweeps seven roughnesses (the floor, 0.1, 0.2, 0.3, 0.5, 0.7 and 1), three views (0°, 60° and 85° off the normal) and three materials (a white metal, a white dielectric and a black dielectric): 63 furnaces. Each GPU sum must land within 10⁻⁵ of an f64 sum of Appendix B's BRDF over the same cells. On the M4 Pro they land within 2 × 10⁻⁷. Then the bounds:

• A white metal reflects at most 1, plus 10⁻³.
• A white dielectric reflects at most 1 plus what a black dielectric reflects, plus 10⁻³. Appendix B's coupling of diffuse and specular is not energy conserving, so a white dielectric can pass 1: by this guide's sums it reflects about 1.59 at the floor seen at 85°. A black dielectric of the same roughness reflects only the specular part, about 0.65 there, so the difference, about 0.94, is the diffuse lobe alone, which must stay at or below 1.
• The 10⁻³ is the grid's own error. These sums land within 7.1 × 10⁻⁴ of sums over cells half or a quarter the size, below them where the lobe is narrow.

The furnace's normal is +Z, untilted, because f32 holds it exactly. A tilted normal, rounded off unit length, moved D near the floor's peak by about 1%, and the reference's sum with it, which would hide anything smaller.

The ticket also asked that "the widened α keeps every case under its bound". Widening adds nothing when the normal is still, so the floor is a case it really produces, and the sweep has to pass there. It did not.

f32 at the peak

Key idea. Near D's peak, 1 − (N·H)² is a tiny number computed from N·H, a number near 1. Any error in N·H becomes a large relative error in it. |N × H|², which equals it for unit vectors, is built from small components and keeps its precision.

With the normal untilted, the furnace at the floor still failed. A white metal seen head-on reflected 1.011 of what it received, 1.1% more, where the f64 sum over the same cells was 0.9992. The BRDF was right. Its f32 arithmetic was not.

Appendix B's D is α² / (π ((N·H)² (α² − 1) + 1)²). PR #245, under #199, had already rearranged its denominator as (N·H)² α² + (1 − N·H)(1 + N·H), so that f32 never forms α² − 1, close to −1, only to add 1 back (Lit Pass Explained). That fixed the arithmetic, but the arithmetic starts from N·H, which is already rounded.

Just below 1, neighbouring f32 values are 2⁻²⁴ ≈ 6.0 × 10⁻⁸ apart. At the floor, by this guide's arithmetic, D falls to half its peak where 1 − N·H ≈ 5.3 × 10⁻⁷: only 8.9 f32 steps from 1. A rounding error of half a step in N·H is a few percent of 1 − N·H there, and more nearer the peak. The conditioning is the problem, not the order of operations: no rearrangement of a formula whose input is N·H can recover digits N·H has already lost.

Why a 1.1% error, not a random one

Rounding to nearest errs evenly in both directions, and much of that error cancels over the lobe. This guide modelled it by rounding H's components to f32, with N = +Z and every operation rounded, as the demo below does. The old form's D errs by up to 4.7% within 0.3° of the peak, but its sum over the lobe moves by only about +0.04%. The GPU's sum was 1.2% above the f64 one, so its errors ran mostly one way. A one-way error is enough. If N·H reads δ high throughout the lobe, 1 − (N·H)² reads about 2δ low, and the lobe's integral, ∫ α² / (α² + s − c)² ds = α² / (α² − c) with c = 2δ, grows by about 2δ/α². For 1.2%, δ ≈ 1.5 × 10⁻⁸: about a quarter of one f32 step. Leaving H a hair longer than 1 after normalize would do it. The GPU's sequence of roundings was not traced one operation at a time, and it does not need to be: the fix removes the sensitivity, whatever the error's source.

Lagrange's identity

For any two vectors, |a × b|² = |a|² |b|² − (a·b)². For unit N and H this gives |N × H|² = 1 − (N·H)², which is exactly the small term in D's denominator. Near the peak, the cross product's components are of the order of sin θ, where θ is the angle between N and H. f32 rounds each of them to a relative error of about ε/sin θ. Going through N·H costs about ε/sin² θ instead. At the floor's half maximum, sin θ ≈ 10⁻³, so that is about a thousand times better. A length error in H also scales |N × H|² by only (1 + 2η), a relative error of 2η, where through N·H it is 2η/sin² θ. Filament's mobile path computes D this way, and its comment gives the reason: "This computes 1.0 - NoH^2 directly (which is close to zero in the highlights and has enough precision)".

fn distribution_ggx(normal_dot_half: f32, normal_cross_half_squared: f32, alpha: f32) -> f32 {
    let alpha_squared = alpha * alpha;
    let denominator = max(
        normal_dot_half * normal_dot_half * alpha_squared + normal_cross_half_squared,
        alpha_squared
    );
    let distribution = alpha_squared / (PI * denominator * denominator);
    return select(0.0, distribution, normal_dot_half > 0.0);
}

reflected_luminance computes cross(normal, half_vector) once per light and passes its squared length down through metallic_roughness_brdf. The max holds the denominator at α². For unit N and H the sum is never below α² anyway, so the max changes nothing there. It catches H = 0, where the light is exactly opposite the view, both terms are 0 and D would otherwise divide by zero; review caught that case.

The tests changed with it. The D and BRDF oracles now pass |N × H|² computed in f64, so they test D's arithmetic rather than how a test vector's N·H was rounded. The D integral test, which had left the floor out because f32 cosines brought it to 0.9991, now includes it. With the fix, the GPU's furnace sums and the f64 sums agree within 2 × 10⁻⁷ at every roughness, and every bound holds.

Cost and Goldens

Key idea. The widening costs town's lit pass +0.7% and the precise D +1.3%, +2.0% together, which the owner accepted. Goldens moved where the widening reaches: smooth highlights and the rims of small spheres.

Two small changes per pixel and per light, measured against each other on the same machine in the same session.

The ticket asked for the lit pass's cost on Reference scene town. Three builds were benched three times each, interleaved, on a quiet M4 Pro: main, main with the widening only, and the whole PR. Each figure is the median of a run's 1,800 measured frames at 2560×1440.

The widening is two dot products, two mins and two square roots per pixel, plus the two derivatives. The precise D adds a cross product for every light, and town's pixels have many point lights, so it costs more than the widening even though each instance of it is cheaper.

Goldens

At Golden size, 640×360, a pbr-sweep sphere is about 70 px across, small enough that the widening reaches roughness 0.3 and above at the silhouettes. The ticket allowed for that: hold the Golden, or re-record it and say why. On Metal, the PR re-recorded minification, normal-tangent, orrery, pbr-sweep, shadows and town. On CI's software Vulkan it re-recorded minification, normal-tangent, orrery, pbr-sweep and town, taken from CI's own captures, whose debug and shipping builds came out identical. The RTX 2070 SUPER's Vulkan Goldens for those scenes stay stale until that machine runs again.

Check yourself

Reading list

Grouped by source, each with what it is good for here. Links into the code are pinned to d8162f0.

Glossary

Reference scene, Golden and Baseline are CONTEXT.md's definitions at d8162f0, Baseline shortened. Normal distribution function, roughness floor, white furnace and directional albedo follow Lit Pass Explained. The rest are this guide's own.