How it works
You carry a light through a flat room of sculptures, neon tubes and paper cut-outs, and every frame the page solves how that light travels in the plane. Shadows are sharp where a shape touches the floor and widen with distance. Light pools inside the broken ring and beams out of its gap. Lit faces throw their colour onto the floor. This is radiance cascades, the 2D global-illumination method behind Vercel’s home-page hero. The idea that makes it real-time: close to a point you need fine positions but few directions, and far away you need many directions but coarse positions. So the work is split into cascades that trade one for the other (4× the rays and 2× the probe spacing per level), and every cascade costs the same.
Pipeline
Numbers for the default (1280 × 720 CSS at 2× = 2560 × 1440 canvas, render scale 0.5, Auto = 5 cascades,
4 base rays, base interval 1.5). One "unit" = one cascade-0 probe spacing = 4 CSS px.
ONCE PER SCENE OR RESIZE
Canvas2D shapes and glyphs at full resolution ──▶ occ RGBA8 2560×1440 + mips albedo, coverage
──▶ emi RGBA8 2560×1440 + mips emission, coverage
seed AA edge texels → 50% crossing of the full-res coverage, found by a quarter-texel walk
along its gradient ─────────────────────────▶ RG32F 1280×720
jump flood 11 passes (step 1024 … 1) + 1 extra, 9 taps ───▶ RG32F 1280×720 nearest edge point
distance signed, in units (negative inside) ─────────────▶ sdf R16F 1280×720 (linear)
collision distance to the occluders only (Neon re-floods without its tubes), a cell per 6 CSS px
─▶ RGBA32F 214×120 ─▶ float readPixels once ─▶ CPU grid for the lights
visibility one pass per cascade, 3 outputs: each of a texel's 12 rays (1 in the top cascade) marched
cache through the sdf as the old per-frame march did, minus the lights ─▶ where it first enters
a shape ─▶ 3 × RGBA16F 640×384 per cascade, 26 MB with the mask. Neon: where it enters its first
tube and what stops it (16-bit fractions of the ray + 1 bit: tube or block) ─▶ RGBA32UI, 52 MB
+ cascades 0, 1: which of the 16 corners the merge drops (buried) ─▶ R16UI 640×384
(also rebuilt when the cascade layout or the base interval changes)
EVERY FRAME (JS ≈ 0.2 ms)
CPU pointer ─▶ target pushed clear of the occluders ─▶ damped spring (0.8–8 Hz, ζ 0.9,
240 Hz substeps) that collides with them ─▶ light disc
+ 0–3 accent discs on slow orbits, same spring and collisions ─▶ uniforms only
(lights never enter the SDF) ▸ budget guard (every 2 s)
cascades one RGBA16F 640×384 ping-pong pair, direction-first: tile = direction, texel = probe
i probes rays/probe interval (units) steps* merge with i+1
4 20 × 12 1024 127.5 – 511.5 64 none: escaped rays take the sky
3 40 × 24 256 31.5 – 127.5 64 bilinear fix: 4 child rays × 3 upper probes
2 80 × 48 64 7.5 – 31.5 32 bilinear fix
1 160 × 96 16 1.5 – 7.5 32 bilinear fix, buried upper probes left out
0 320 × 192 4 0 – 1.5 32 bilinear fix, buried upper probes left out
(the 4th, 1/16-weight upper probe takes the more occluded of its two neighbours' rays)
* sphere-tracing budget, spent once per scene by the visibility cache
per texel: cull the lights its rays can reach (its direction's sector, bent ≤ 1.06 upper
spacings); read its rays' first shapes ▸ a child direction whose 3 rays meet nothing (no
shape, no light in reach, no dropped corner) = bilinear blend of its 4 upper probes,
one filtered fetch ▸ otherwise per ray: light discs solved exactly (the cursor light stops
it, an accent adds and lets it pass); reaches its shape → albedo (occ mip 2) × last frame's
irradiance (bounce); Neon: the first tube adds its glow (emi mip 2) and passes half the
light, a second tube or a block stops it
occluder opacity < 1: rays cross any number of shapes, so every ray sphere-traces sdf ∪
light discs every frame (up to 20 more steps on −sdf per budgeted step to find each exit)
irradiance mean of cascade 0's 4 rays × "probe is outside" weight ─▶ E RGBA16F 320×192
(ping-pong: this frame's E is next frame's bounce source)
composite canvas 2560×1440, without the lights' near field and discs (exactly 0 beyond 4R + 2),
then the full composite again, scissored to a box of 4R + 2 round each light
floor albedo · (E + exact share of each light within 4 radii) (+ page colour, dark themes)
shapes: crisp coverage ▸ rim = E 2.25 units outside the nearest edge × bevel profile
▸ top face lit by the hovering lights ▸ glass tint below full opacity
emitters (hot core) ▸ light discs (dark: hue at the rim, white core; light: floor + light,
soft glow) ▸ filmic shoulder ▸ sRGB ▸ static TPDF dither
The ideas that matter
- The penumbra condition sets the budget. The radiance arriving at a point from distance r changes slowly in position (by about one penumbra width, which grows with r) but quickly in angle (a source of size s subtends s/r). So cascade i places probes every 2i units, gives each 4·4i rays, and only traces the interval from L(4i−1)/3 to L(4i+1−1)/3. Probes ÷ 4 and rays × 4 per level means every cascade is the same 640 × 384 texture. The cost barely depends on the number of lights (each adds one distance evaluation per march step), which is why the extra lights are nearly free.
- Merging top-down turns intervals into full rays. Cascade i’s ray brings back what it met on its interval plus its transmittance times the cascade above it: the average of the 4 finer directions that subdivide its cone, interpolated between the 4 upper probes around it. After the last merge, cascade 0 holds the radiance of complete rays, and the mean of its 4 directions is the irradiance at that probe.
- The bilinear fix is what makes it look physical. A plain merge joins a ray from this probe to intervals that start at other probes, so ray segments overlap or leave gaps. Shadow edges come out blotchy, and small lights ring. The fix casts each child ray from this probe to exactly where each of the 4 upper probes’ intervals begin, then blends the 4 results (Osborne & Sannikov 2024, §2.5). That is 16 rays per texel instead of one (12 here; see the next point). Switch Merge to “Plain bilinear” to see the difference.
- Making the fix affordable, without its leaks. The 4 rays of a child direction leave from the same point, so one distance sample there is a free disc they all share. Rays shorter than it skip marching, and longer ones start at its edge. The upper probes always sit at bilinear weights 9/16, 3/16, 3/16 and 1/16. The 1/16 corner casts no ray: it takes the more occluded of its two neighbours’ rays (and fetches its own radiance), so there are 12 rays per texel. An earlier version reused the nearest probe’s ray there, and that leaked. Where the nearest ray stops just short of a wall, the far corner’s ray would have crossed it, so the far probe’s view past the wall came through as faint lit blocks in full shadow. Measured with the light inside the broken ring (direct light only, against a brute-force ray-traced reference, on floor at least 10 units from any truly lit point), the worst excess fell from 4.0 to 1.2 levels at render scale 0.5 and from 8.1 to 1.4 at 0.4. Against the 16-ray fix (Gallery, three light spots) it differs by 0.5–0.7 levels on average, ≤ 0.02% of pixels by more than 4, at most 11. Against the reference at five spots its mean error is 1.36 levels, compared with 1.20 for 16 rays and 1.35 for the old reuse. 1-ray far field casts only the nearest probe’s ray from cascade 3 up (intervals that start 21 base intervals out) and shares it with all four corners. It takes 0–7% less GPU time (a fifth before the visibility cache made rays cheap), but it differs from the fix by 0.9–1.3 levels on average, with 3–6% of pixels off by more than 4 and at most 28. It shows blotches and stair-steps in far shadows and in the beam leaving the ring, and up to 11–14 levels of leak in the ring test (scale 0.5–0.4). So the budget guard no longer uses it. It saves too little now, and a smaller render scale costs less quality anyway: the full fix at 0.4 stays within 2.3 levels in the same test and keeps the beam’s edges smooth.
- Upper probes buried in a shape are left out. Near a wall some of the four upper probes a texel blends sit inside the shape. Where such a probe’s interval also starts inside it, that corner holds only a blocked ray, not a view of anything this texel can see, and blending it in printed a row of dark specks on the floor just outside every lit edge, one per row of upper probes the edge crosses (about every 70 px along the Gallery triangle’s base at render scale 0.5). The merges of cascades 0 and 1 leave those corners out and renormalise the other weights. Corners whose probe is outside the shape always count, so shadows still start right at the silhouette: a first try that dropped every corner whose interval started inside a shape let light into the start of every shadow (up to 9 levels more leak in the ring test at scale 0.4). 2 px outside the triangle’s base the ripple (periods 12–150 px) fell from 18–27 to 9–11 levels; the ring test’s leak numbers did not change at scale 0.5 or 0.4. The test depends only on the scene, so the visibility cache (below) stores it as a 16-bit mask per texel. The merge reads one integer instead of up to 20 full-resolution coverage samples, and the one-fetch merge below needs only its own child’s 4 bits clear.
- The scene is distance-fielded once; lights are analytic. Canvas2D draws the shapes and glyphs, and a jump flood turns their anti-aliased edges into a signed distance field. The moving lights are discs, never part of the field, so moving them never re-runs the flood.
- Visibility is cached; only the lights are traced every frame. Every ray a cascade casts is fixed: its start, its end and the shapes in its way change only with the scene, the size, the cascade layout or the base interval. So where each ray first enters a shape is sphere-traced once, by one pass per cascade with three outputs (12 rays per texel), and kept: 26 MB at the default size. Each frame a ray is then a cache read, an exact ray–disc test per light (the cursor light stops it; an accent adds its light and lets it pass), and, if it reaches its shape, the bounce read there. Against the old per-frame marcher, at five fixed light spots per preset, the image differs by 0.04–0.27 levels on average and at most 6, with ≤ 0.004% of pixels more than 4 apart. Those few are in a faint ring round each light, where exact disc hits replace the marcher’s sampled ones. Neon tubes are glass, so their cache keeps two fractions of each ray instead: where it enters its first tube and what stops it, with one bit saying whether that is a second tube or a block. A light met past the tube’s entry re-marches only that tube’s exit, so lights inside tubes are seen exactly when the marcher saw them. With the light over the word the difference stays within 4 levels. Below full occluder opacity a ray can cross any number of shapes, so those settings still march every ray every frame (2.6–2.9× the default’s GPU time at opacity 0.5).
- Most rays are nowhere near a light. A texel’s rays all leave its probe inside its direction’s angular sector and cover that cascade’s interval. The bilinear fix bends each one by at most 1.06 upper-probe spacings. A light whose disc can’t touch that region is never tested, which leaves the disc tests to a thin wedge of texels per light in each cascade.
- Where nothing is in the way, the fix is one bilinear fetch. When none of a child direction’s three cached rays meets a shape, no light is in reach and no upper probe is buried, all four corners carry the full upper radiance and nothing of their own. The merge is then exactly the bilinear blend of the four upper probes. Their weights are always 9/16, 3/16, 3/16 and 1/16, which the texture filter represents exactly, so one filtered fetch replaces three rays and four reads. On open floor that covers most children of cascades 0–2.
- Scattered reads come from small mips. Ray hits land all over the stage, and reading a shape’s or tube’s colour there from the 2560 × 1440 textures missed the cache on nearly every ray. In Neon those reads cost about 3 ms a frame. The colours now come from mip 2 (640 × 360), which is premultiplied, so dividing by its coverage still gives the shape’s own colour. Whether a ray’s stop is a tube or a block comes from the cache bit, not a texture read. Everything that needs edges (seeds, coverage, the composite) still reads level 0.
- Per-light detail is drawn only near the light. The exact near-field swap and the light discs are exactly zero beyond 4 radii + 2 units of every light. The composite runs once full-screen without them (the light theme’s soft glow, which reaches further, stays in), then again with them, scissored to a box round each light. The image is the same as one full pass, and the light loops, with five
asinper light, run on about 5% of the screen per light instead of all of it. The composite alone took about 2.7 ms before; with the cascades stubbed out, a whole frame (irradiance and composite) now takes 0.5–1.2 ms. - Clean seeds make clean rims. Each edge texel seeds the flood with the point where the full-resolution coverage crosses 50%, found by walking along the coverage gradient in quarter-texel steps. A one-step estimate from a 2-texel stencil is biased wherever the anti-aliasing ramp is narrower than the stencil. On a slanted edge that bias repeats every time the edge crosses a texel row, about every 9 px at render scale 0.5 and 11 px at 0.4. The bevelled highlights drawn from the field showed it as a beaded rim, which first looked like the probe grid. Along the Gallery triangle’s base, the highlight’s half-brightness contour now wavers by 0.37 px peak to peak at scale 0.4 (1.0 px before), and the 6–14 px ripple in the rim’s brightness is 0.13 levels at 0.5 (0.9 before).
- Probes inside shapes are weighted out. A probe even slightly inside a solid shape sees only black. Bilinear upsampling would smear that onto the floor as dark specks along every lit edge. The irradiance pass stores E premultiplied by an “outside” weight, and the composite divides it back out. Slivers where no nearby probe is outside widen to a 4-tap neighbourhood instead of dividing by zero.
- Bounce costs one texture read. When a ray hits a shape, it picks up the shape’s albedo × last frame’s irradiance just in front of the hit. Light therefore gains one more bounce per frame and converges within a few frames. The loop gain is capped at 0.9, so a deep cavity cannot run away.
- Ambient occlusion comes free. Rays that leave the stage, or survive the top cascade, take the sky’s radiance, so creases and contact points see less sky. Paper uses a cool sky (#dfe7ff) with a mild window lobe and a moderate bounce (0.6). Its penumbrae therefore come out a neutral cool grey (about 142, 138, 141 in the arch’s shadow with the light at the reduced-motion spot) against the warm sun that follows you, rather than the warm greige a higher bounce off the cream floor gives.
- Shapes are shaded at full resolution. Their edges come from the full-resolution coverage, so they stay crisp. The bevelled rim takes the irradiance 2.25 units outside the nearest edge (along the SDF normal), where all four bilinear taps are clear of the shape, so a rim glows exactly where light reaches it. Taken 1.25 units out, the taps mixed probes with partial “outside” weights, and the rim’s brightness rippled by 18–27 levels at the probe pitch along straight edges; now the ripple at those periods is 2–4 levels, about the dither. In a notch narrower than 2.25 units, where a glyph’s bowl meets its stem, that sample lands in the shape across the notch and read black, so a sample 1 unit out takes over wherever the far one has no outside probes. It takes only what exceeds about 60% of the sky there (a shape hides roughly half the sky from its own edge); otherwise the sky would light every edge alike and read as a drawn outline on Paper. The top faces are lit by the lights hovering at five radii above the floor, with the 3D point-light law h/(d²+h²)1.5. It matches the floor under the light and fades much faster than the floor’s flatland 1/r, so only nearby sculptures catch it. Lighting the faces from a coarse irradiance mip would show the probe grid on them, and a flatland 1/r fill would light every face the same flat grey.
- Size is decoupled from brightness. In flatland a disc of radius R and radiance I gives E ≈ I·R/(πr). The light’s radiance is set so the irradiance 100 px away equals Intensity, so Light size changes only the softness of shadows.
- Glass is Beer–Lambert, and crossing it is free. Below full opacity a full pass through a shape transmits (1−α)1+3(1−tint) per channel: clear glass at 0, and darker and more saturated in the shape’s own colour as it gets denser, so the shadow is coloured. Inside a shape the distance to the nearest wall shrinks toward the exit, so sphere-tracing out takes many short steps. Those steps (up to 20 for each budgeted step spent inside a shape, which crosses all but the deepest in one batch) don’t count against the step budget, otherwise long rays would stop inside a shape and cast false shadows where nothing blocks.
- Running out of steps is a leak. A ray that uses up its budget before the end of its interval counts as unblocked, and rays that graze past several shapes run out first. With 24 steps (and even with 32–48 on the far cascades) that showed as soft lit blobs, up to 6 levels, in the shadow behind Gallery’s triangle. The budget is now 32 steps on cascades 0–2 and 64 from cascade 3 up, and the visibility cache (below) spends them once per scene, not every frame. Against a 160-step reference the default then matches to 0.00–0.01 levels on average, at most 2, on Gallery (three light spots), at occluder opacity 0, 0.3 and 0.7, and in Neon and Paper.
- Neon tubes are glass too. A tube shines and passes half the light behind it, so the magenta of the word still reaches the floor under the amber wave instead of leaving a hard colour seam along it. Only the first tube on a ray passes light; a second is opaque. That keeps rays from threading a whole word stroke by stroke, which costs steps, and two tubes deep little light is left anyway.
- Lights are bodies that collide, but only the cursor light casts shadows. A distance grid to the occluders (one cell per 6 CSS px) is read back once per scene. The cursor’s target is pushed out of the shapes to the light’s radius + 2 px, and the spring-driven light resolves contacts every substep (half the overlap out, inward velocity dropped), so it glides around a sculpture instead of crossing it. The intro and thumbnail loops run through each scene’s open floor; checked numerically, they keep the light clear of every shape in landscape and portrait. The accent lights glow but don’t block: a ray adds an accent’s light and carries on past it. As solid discs they threw a long dark band through the cursor light’s pool whenever they drifted near it.
- The light’s own halo is exact. Probes inside a light disc see it in every direction (E = I) while the floor just outside sees about I/2, and the probe grid is coarser than that change, so the upsampled halo came out blocky. Within 4 radii of each light the composite swaps the interpolated share of that light for the exact flatland value I·asin(R/d)/π. The halo is then round and smooth at any render scale. At a few probes just outside the rim the cascades and that model disagree enough to dent the floor; Paper draws its sun over the floor, and the dents showed as six yellow specks on its rim (blue down to 188 of 255 on a white sun). So within 2 units of a rim the floor never drops below the light’s own exact share, which nothing can block there, since the lights keep clear of the shapes.
- Reach doesn’t depend on the render scale. The base interval is set in probe spacings at scale 0.5 (6 CSS px by default) and keeps that length in pixels at any scale. The Auto cascade count is the smallest whose reach, base interval × (4n−1)/3, covers the stage diagonal (the rule in Vercel’s hero): 5 at 1280 × 720, 6 on much larger screens. The top cascade fades its hits out toward the end of its interval, from 45% of the way along, but not before the far corner of the stage when the interval reaches that far. Under Auto the light therefore reaches every pixel unfaded. With a fixed, lower count the reach shrinks softly instead of stopping at a hard circle.
- Deterministic, so it never shimmers. There is no temporal accumulation, no jitter and no noise; the dither is static in screen space. Moving the light by 3 px leaves 95–99.6% of the pixels more than 100 px away within 2 of their 255 levels (four spots on Gallery). The largest change there, 8 levels, is on shadow edges that really moved, and the difference image has no grid or ring structure.
Parameters
Presets
Performance & compatibility
- Measured by the harness in serial, GPU-locked, uncontended runs on an Apple M5 (1280 × 720 at 2×, a 2560 × 1440 canvas; Chrome via ANGLE/Metal): 60 fps throughout the scripted sweep (frame p95 16.7–16.8 ms, no frame over 25 ms) and 0.14–0.19 ms of JS per frame. GPU mean / p95 per frame: default 5.18 / 6.80 ms and 4.35 / 6.14 ms in two full runs. Two
?preset=runs each gave Gallery 4.65 / 9.25 and 5.19 / 8.79, Neon sign 6.33 / 9.61 and 5.59 / 9.90, and Paper 5.53 / 6.65 and 4.68 / 8.57. Before the visibility cache and the split composite, the canonical run of the default gave 11.18 / 13.76 ms. This GPU steps its clock with load. At this load the frame time saws between about 3.5 ms and 7–9 ms every 20 or so frames, so the p95 follows the lower clock and varies more from run to run than the mean does. - Per configuration, as the mean GPU ms of an interleaved benchmark (every configuration in every round; two runs), relative to the default: 1-ray far field 0.93–1.0× · plain merge 0.81–0.99× · 16 base rays 1.18–1.23× · 6 cascades 1.12–1.21× · 3 extra lights 1.08–1.2× · Paper 0.98–1.06× · Neon sign 1.16–1.27× · render scale 0.25: 0.58–0.64× · 0.4: 0.79–0.93× · 1.0: 1.9–2.0× (5.1× before the cache, when every ray at 4× the texels also crossed twice as many probe spacings). Two settings still march every ray every frame. One is occluder opacity below 1, where rays cross any number of shapes: 0.5 costs 2.6–2.9×, about 13 ms mean and 20 ms p95 here, still at 61 fps. The other is Neon at render scale 1, whose cache would need 200 MB, over the page’s 128 MB limit: about 36 ms (26 fps) until the guard’s first step to 0.8, where the cache fits. Building the cache adds one frame’s worth of marching, the same work that every frame used to do, whenever the scene, the size, the cascade layout or the base interval changes.
- Budget guard: every 2 s the page averages the frame interval. Under 55 fps it steps down one level: render scale × 0.8 (0.5 → 0.4), then × 0.64 (0.32). The panel shows what is in use (“0.50 → 0.40” on Render scale). At 58 fps or more for 10 s it tries the level above, and a step up that drops frames again doubles that wait, up to 160 s. Changing Cascades, Base rays, Merge or Render scale starts it afresh at full quality. Every browser reports the frame interval, Safari and phones included. The GPU timer is not used: on a shared GPU it also counts other tabs’ work, and an earlier timer-driven guard demoted the default to its lowest level while it held 61 fps. The 1-ray far field used to be the guard’s second step. Since the visibility cache made rays cheap it saves only 0–7%, so the guard now only lowers the scale, which also costs less image quality (see the bilinear-fix notes above). Tested before the cache: at render scale 1 (then 52 fps) it stepped to 0.8 within 4 s and held 61 fps, and forced down at the default it was back at full quality 12 s later. With the cache, every level was forced on each preset and rendered without GL errors. A display capped at 30 Hz (low-power mode) leaves it at the lowest level.
- What scales it: per frame, the cascade texture size (render scale²) times the work per ray. That is a cache read, a disc test only for lights within reach, and a bounce read for rays that reach a shape. A child direction with nothing on its rays costs one filtered fetch. Sphere-tracing steps are spent once per scene, or every frame for translucent occluders. The jump flood, the lights’ collision grid and the visibility cache run only when the scene or the size changes. The cache takes 26 MB at the default size, or 52 MB with neon tubes.
- Mobile: touch screens start at render scale 0.4 with the full fix, and the budget guard steps down from there. In the harness’s 390 × 844 touch emulation (DPR 3, canvas capped at 2× = 780 × 1688) touch-drag ran at 60 fps in the full run (48–49 fps before the visibility cache). That emulation runs on the desktop GPU, so it is not a phone measurement. Cost follows CSS pixels rather than device pixels: the cascades are 160 × 352 texels there (a quarter of the desktop default). Portrait screens rotate the shape layout 90° and re-flow the glyphs, and the controls sheet fits (8–382 px).
- Idle and visibility: the loop stops 7 s after the last movement (verified: 0 frames after idle) and pauses off-screen or in a hidden tab. A static scene with a still light would give the same frame anyway.
- Reduced motion: the light is placed at a composed spot and 8 frames are rendered synchronously so the bounce settles, then nothing animates until “Play anyway”.
- Requirements: WebGL2 with
EXT_color_buffer_float(RGBA16F, R16F, RG32F and RGBA32F render targets; the cache also renders to RGBA32UI and R16UI, core in WebGL2, through up to four attachments), plus a floatreadPixelsfrom the RGBA32F collision grid once per scene. Without them the page shows its poster and a message. No textures, fonts or network requests: the scenes are drawn with Canvas2D from system fonts with generic fallbacks.
References & credits
- A. Sannikov, “Radiance Cascades: A Novel Approach to Calculating Global Illumination” (2023). Paper source: https://github.com/Raikiri/RadianceCascadesPaper (MIT). The cascade structure, interval scheme, penumbra condition and top-down merge.
- jason.today, “Radiance Cascades” (https://jason.today/rc) and “Building Real-Time Global Illumination” (https://jason.today/gi, distance fields and jump flooding): interactive walkthroughs whose controls (probe spacing, interval length, base rays) shaped this page’s. Their code license is unverified (
research/site-survey.md); none of it was used. - GM Shaders, “Radiance Cascades”, https://mini.gmshaders.com/p/radiance-cascades: a plain-language introduction (article, no code used). Yaazarai/RadianceCascades, https://github.com/Yaazarai/RadianceCascades: a reference for the direction-first layout. It has no license, so it was read only and none of its code is used here.
- C. M. J. Osborne & A. Sannikov, “Radiance Cascades: A Novel High-Resolution Formal Solution for Multidimensional Non-LTE Radiative Transfer” (RASTI, 2024), https://arxiv.org/abs/2408.14425, https://doi.org/10.1093/rasti/rzae062: §2.5 describes the bilinear fix (trace each interval to the start of the child cone on each of the four bilinearly blended upper probes, merge each, then blend with the bilinear weights). It is implemented here from that description. The paper’s own code, DexRT, is Apache-2.0 and was not used. The shared free-disc skip, the 3-ray corner rule (the far corner takes the more occluded neighbour’s ray) and the 1-ray far field are this page’s own.
- G. Rong & T.-S. Tan, “Jump Flooding in GPU with Applications to Voronoi Diagram and Distance Transform” (I3D 2006, pp. 109–116), https://doi.org/10.1145/1111411.1111431, author page https://www.comp.nus.edu.sg/~tants/jfa.html: the jump flood (paper, no code), here with an extra step-1 pass (JFA+1).
- Observed reference: the Vercel home-page hero (https://vercel.com/), as described in
research/site-survey.md: 2D radiance cascades lighting the page, a cascade count derived from the canvas diagonal, a WebGL2 +EXT_color_buffer_floatrequirement and a static fallback. No Vercel code was used; this page is not affiliated with Vercel. - Dave Hoskins, “Hash without Sine”, https://www.shadertoy.com/view/4djSRW (MIT):
hash12, used for the dither. Ian Taylor, “sRGB approximations for HLSL”, https://chilliant.blogspot.com/2012/08/srgb-approximations-for-hlsl.html: the cubic sRGB → linear fit (formula).