@woosh/meep-engine 3.58.0 → 3.59.0

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_indirect_lighting.js

@@ -0,0 +1,175 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_get_ibl_irradiance } from "../../../deferred/indirect/chunk_get_ibl_irradiance.js";
+import { chunk_get_ibl_radiance } from "../../../deferred/indirect/chunk_get_ibl_radiance.js";
+import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
+import { BSDF_ROUGHNESS_MINIMUM } from "../../../light/environment/DEFINES.js";
+import { ENVIRONMENT_MAP_RESOURCE } from "../../../light/environment/ENVIRONMENT_MAP_RESOURCE.js";
+import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
+import { chunk_compute_specular_occlusion_bn } from "../../../shader/chunk/brdf/chunk_compute_specular_occlusion_bn.js";
+import { chunk_MIN_DIELECTRICS_F0 } from "../../../shader/chunk/brdf/chunk_MIN_DIELECTRICS_F0.js";
+import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_mat4_extract_position } from "../../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_compute_indirect_specular } from "../../../shader/chunk/material/chunk_compute_indirect_specular.js";
+import { chunk_decode_g_buffer_metalness } from "../../../shader/chunk/material/chunk_decode_g_buffer_metalness.js";
+import { chunk_decode_g_buffer_roughness } from "../../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
+import { chunk_metalness_to_specular_color } from "../../../shader/chunk/material/chunk_metalness_to_specular_color.js";
+import { PI_DECLARATION } from "../../../shader/chunk/math/PI_DECLARATION.js";
+import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
+import {
+    chunk_resolve_irradiance_sh_to_diffuse
+} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_diffuse.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { VIEW_UNIFORM_STRUCT } from "../../../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_probe_clipmap_pick, PROBE_CLIPMAP_SAMPLING_GROUP } from "./chunk_probe_clipmap_pick.js";
+import { chunk_probe_clipmap_sample_radiance } from "./chunk_probe_clipmap_sample_radiance.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addTexture("tDepth")
+    .addTexture("tNormals", "uint")
+    .addTexture("tBentNormals", "uint")
+    .addTexture("tGBufferAlbedo")
+    .addTexture("tGBufferPBR")
+    .add(STBN_VEC2_RESOURCE)
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .add(ENVIRONMENT_MAP_RESOURCE)
+    .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
+    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
+    .addTexture("tSplitSum", "float");
+
+resources.addGroup(PROBE_CLIPMAP_SAMPLING_GROUP);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+) -> @location(0) vec4<f32> {
+    let i_coord = vec2<u32>(coord.xy);
+
+    let depth = textureLoad(tDepth, i_coord, 0).r;
+    let texel_pbr = textureLoad(tGBufferPBR, i_coord, 0);
+    let albedo_ao = textureLoad(tGBufferAlbedo, i_coord, 0);
+
+    let albedo = albedo_ao.rgb;
+    let occlusion = albedo_ao.a;
+
+    let f_metalness = decode_g_buffer_metalness(texel_pbr);
+
+    // the radiance is sampled at the surface's roughness, as the IBL pass samples it; the resolve holds it off zero
+    let surface_roughness = decode_g_buffer_roughness(texel_pbr);
+    let roughness = max(surface_roughness, ${BSDF_ROUGHNESS_MINIMUM});
+    let alpha = roughness * roughness;
+
+    let position = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
+    let view_direction = normalize(mat4_extract_position(camera.transform) - position);
+
+    // the surface's own normal picks, as want chose by it; the bent normal resolves the diffuse, as IBL's does
+    let normal = decode_g_buffer_normal(textureLoad(tNormals, i_coord, 0).xy);
+    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, i_coord, 0).xy);
+
+    // one pick for both lobes
+    let noise = stbn_sample_vec2(vec3<u32>(i_coord, view.frame_index));
+    let pick = probe_clipmap_pick(position, normal, view_direction, noise);
+
+    let probes = probe_clipmap_sh_of(pick);
+
+    var irradiance: vec3<f32>;
+    var radiance: vec3<f32>;
+
+    if (probes.found) {
+        // the resolve gives E/π
+        irradiance = PI * resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, bent_normal);
+        radiance = probe_clipmap_radiance_of(pick, position, normal, view_direction, surface_roughness).radiance;
+    } else {
+        // a pixel no probe weighs anything for takes the environment's, as the IBL passes give it
+        irradiance = get_ibl_irradiance(bent_normal);
+        radiance = get_ibl_radiance(view_direction, normal, surface_roughness);
+    }
+
+    // what shader_resolve_indirect_lighting does with the pair: the diffuse with AO in, the specular occluded
+    // along the lobe it was taken along
+    let indirect = compute_indirect_specular(
+        radiance,
+        irradiance * occlusion,
+        normal,
+        view_direction,
+        albedo * (1.0 - f_metalness),
+        metalness_to_specular_color(f_metalness, albedo),
+        vec3(MIN_DIELECTRICS_F0),
+        albedo,
+        1.0,
+        roughness,
+    );
+
+    let spec_direction = normalize(mix(reflect(-view_direction, normal), normal, alpha));
+    let specular_occlusion = compute_specular_occlusion_bn(spec_direction, bent_normal, occlusion, roughness);
+
+    return vec4(indirect[0] * specular_occlusion + indirect[1], 1.0);
+}
+`, [
+    chunk_project_position_from_depth,
+    chunk_mat4_extract_position,
+    chunk_decode_g_buffer_normal,
+    chunk_decode_g_buffer_metalness,
+    chunk_decode_g_buffer_roughness,
+    chunk_metalness_to_specular_color,
+    chunk_MIN_DIELECTRICS_F0,
+    chunk_stbn_sample_vec2,
+    chunk_probe_clipmap_pick,
+    chunk_probe_clipmap_sample_radiance,
+    chunk_resolve_irradiance_sh_to_diffuse,
+    chunk_get_ibl_irradiance,
+    chunk_get_ibl_radiance,
+    chunk_compute_indirect_specular,
+    chunk_compute_specular_occlusion_bn,
+    PI_DECLARATION,
+]);
+
+/**
+ * The probe clipmap's deferred indirect light in one pass (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.6), for SSR
+ * off: one pick a pixel, by its own normal and the view, with the frame's STBN, for both lobes.
+ * - The diffuse is `shader_probe_clipmap_diffuse`'s: the picked SH resolved at the bent normal, times π. Its
+ *   shares are the pick's, not re-weighted for the bent normal, so SSR on and off light the diffuse alike.
+ * - The specular is the pick's radiance (`probe_clipmap_radiance_of`), its shares re-weighted for the lobe.
+ * - A pixel no probe weighs anything for takes the environment's for both.
+ * - The two are resolved as `shader_resolve_indirect_lighting` resolves the IBL pair: AO multiplies the
+ *   diffuse, the specular is occluded along its lobe, and the result is added to the scene's colour.
+ *
+ * @type {ImageShader}
+ */
+export const shader_probe_clipmap_indirect_lighting = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "Probe Clipmap / Indirect Lighting (Fused)",
+        resources,
+        body,
+    }),
+    targets: [
+        {
+            format: "rgba16float",
+            blend: {
+                color: {
+                    operation: "add",
+                    srcFactor: "one",
+                    dstFactor: "one",
+                },
+                alpha: {
+                    operation: "add",
+                    srcFactor: "zero",
+                    dstFactor: "one",
+                }
+            }
+        }
+    ],
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+});

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The light a front-face hit takes from beyond the trace (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7): a
+ * thread a ray, after shade through the same launch, `PROBE_DISPATCH_RAYS`. It adds ρ_d·(E_loc + E_ind)/π
+ * to the radiance shade left, ρ_d being the albedo shade left in the ray's \`row\`.
+ *
+ * - **E_loc, the local lights**: the point and spot lights of the hit's cell of the world light clusters,
+ *   built over the bricks' cascades so that every hit has one, at most `IRRADIANCE_CLIPMAP_LIGHT_BUDGET` of
+ *   each; past them lights are dropped. Each is the irradiance clipmap's, at the footprint of a voxel of
+ *   the hit's cascade, its cosine at the hit's normal, and its shadow map's nearest texel from a voxel off
+ *   the surface, past the field's half-voxel expand. A light whose map is cleared lights hits unshadowed.
+ * - **E_ind, the next bounce**: this mode's own diffuse at the hit, `probe_clipmap_sample_sh` from the
+ *   hit along its normal, the view back along the ray, with the ray's own jitter as the pick's noise.
+ *   The projection writes the records later in the frame, so they hold last frame's SH: each frame takes
+ *   one more bounce.
+ * - Where no probe weighs anything the bounce is **zero**, not the environment: a hit behind the camera
+ *   in a cave must not bring daylight in. The next frame's hits' wants ask for the probes it read
+ *   (`shader_probe_clipmap_want_hits`), so the bounce has them a frame or two later.
+ * - LPV's 0.97 a bounce is dropped: an albedo under one bounds the series already.
+ *
+ * Its own pass because shade binds nine of a stage's ten storage buffers, and the pick takes two more.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_probe_clipmap_light: ComputeShader;
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_probe_clipmap_light.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_probe_clipmap_light.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.js"],"names":[],"mappings":"AAyEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yCAFU,aAAa,CAmHpB;8BAlM2B,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.js

@@ -0,0 +1,210 @@
+import { MESH_SDF_BRICK_VOXELS } from "../../../geometry/sdf/MESH_SDF.js";
+import { chunk_light_cluster_counts } from "../../../light/cluster/chunk_light_cluster_counts.js";
+import { LIGHT_DATA_RESOURCE } from "../../../light/LIGHT_DATA_RESOURCE.js";
+import {
+    chunk_world_light_cluster_lookup_at,
+    WORLD_CLUSTER_DATA_RESOURCE,
+    WORLD_CLUSTER_LOOKUP_RESOURCE
+} from "../../../light/world_cluster/chunk_world_light_cluster_lookup.js";
+import { chunk_uv_octahedral_unit_decode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
+import {
+    chunk_resolve_irradiance_sh_to_diffuse
+} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_diffuse.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { SHADOWMAP_ATLAS_RESOURCE } from "../../../shadow/map/SHADOWMAP_RESOURCES.js";
+import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import { chunk_volumetrics_local_light_shadow } from "../../../volumetrics/chunk_volumetrics_local_light_shadow.js";
+import { chunk_irradiance_clipmap_local_light } from "../../../volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_local_light.js";
+import { IRRADIANCE_CLIPMAP_LIGHT_BUDGET } from "../../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js";
+import { BRICK_TRACE_HIT } from "../brick/BRICK_CLIPMAP.js";
+import { BRICK_LEVELS_RESOURCE } from "../brick/chunk_brick_clipmap_trace.js";
+import {
+    chunk_probe_clipmap,
+    chunk_probe_clipmap_ray_jitter,
+    chunk_probe_clipmap_ray_texel,
+    PROBE_DEPTH_HISTORY_RESOURCE,
+    PROBE_LEVELS_RESOURCE,
+    PROBE_ORIGINS_READ_RESOURCE,
+    PROBE_RAYS_WRITE_RESOURCE,
+    PROBE_RECORDS_READ_RESOURCE,
+    PROBE_STATES_READ_RESOURCE,
+    PROBE_TRACE_READ_RESOURCE
+} from "./chunk_probe_clipmap.js";
+import {
+    chunk_probe_clipmap_pick,
+    PROBE_DEPTH_SAMPLER_RESOURCE,
+    PROBE_INDIRECTION_READ_RESOURCE,
+    PROBE_SAMPLING_RESOURCE
+} from "./chunk_probe_clipmap_pick.js";
+import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
+import { PROBE_TRACE_SETTINGS } from "./shader_probe_clipmap_trace.js";
+
+const HALF_MAX = 65504;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", PROBE_TRACE_SETTINGS);
+
+resources.createGroup()
+    .add(PROBE_TRACE_READ_RESOURCE)
+    .add(PROBE_ORIGINS_READ_RESOURCE)
+    .add(PROBE_RAYS_WRITE_RESOURCE)
+    .add(PROBE_STATES_READ_RESOURCE)
+    .add(STBN_VEC2_RESOURCE);
+
+resources.createGroup()
+    .add(PROBE_LEVELS_RESOURCE)
+    .add(PROBE_SAMPLING_RESOURCE)
+    .add(PROBE_INDIRECTION_READ_RESOURCE)
+    .add(PROBE_RECORDS_READ_RESOURCE)
+    .add(PROBE_DEPTH_HISTORY_RESOURCE)
+    .add(PROBE_DEPTH_SAMPLER_RESOURCE);
+
+resources.createGroup()
+    .add(BRICK_LEVELS_RESOURCE)
+    .add(LIGHT_DATA_RESOURCE)
+    .add(WORLD_CLUSTER_LOOKUP_RESOURCE)
+    .add(WORLD_CLUSTER_DATA_RESOURCE)
+    .add(SHADOWMAP_ATLAS_RESOURCE);
+
+/**
+ * The light a front-face hit takes from beyond the trace (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7): a
+ * thread a ray, after shade through the same launch, `PROBE_DISPATCH_RAYS`. It adds ρ_d·(E_loc + E_ind)/π
+ * to the radiance shade left, ρ_d being the albedo shade left in the ray's \`row\`.
+ *
+ * - **E_loc, the local lights**: the point and spot lights of the hit's cell of the world light clusters,
+ *   built over the bricks' cascades so that every hit has one, at most `IRRADIANCE_CLIPMAP_LIGHT_BUDGET` of
+ *   each; past them lights are dropped. Each is the irradiance clipmap's, at the footprint of a voxel of
+ *   the hit's cascade, its cosine at the hit's normal, and its shadow map's nearest texel from a voxel off
+ *   the surface, past the field's half-voxel expand. A light whose map is cleared lights hits unshadowed.
+ * - **E_ind, the next bounce**: this mode's own diffuse at the hit, `probe_clipmap_sample_sh` from the
+ *   hit along its normal, the view back along the ray, with the ray's own jitter as the pick's noise.
+ *   The projection writes the records later in the frame, so they hold last frame's SH: each frame takes
+ *   one more bounce.
+ * - Where no probe weighs anything the bounce is **zero**, not the environment: a hit behind the camera
+ *   in a cave must not bring daylight in. The next frame's hits' wants ask for the probes it read
+ *   (`shader_probe_clipmap_want_hits`), so the bounce has them a frame or two later.
+ * - LPV's 0.97 a bounce is dropped: an albedo under one bounds the series already.
+ *
+ * Its own pass because shade binds nine of a stage's ten storage buffers, and the pick takes two more.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_probe_clipmap_light = ComputeShader.from({
+    label: "Probe Clipmap Light",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+// E_loc at a front-face hit in brick cascade \`cascade\`: its world cluster cell's point and spot lights
+fn probe_clipmap_local_irradiance(cascade: u32, position: vec3<f32>, normal: vec3<f32>) -> vec3<f32> {
+    let level = brick_levels[cascade];
+    let voxel = level.cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
+    let cell = world_light_cluster_metadata_at(cascade, level, 0.0, position);
+    let point_count = min(light_cluster_count_point(cell.counts), ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u);
+    let spot_count = min(light_cluster_count_spot(cell.counts), ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u);
+
+    // the maps' receiver: a voxel off the surface, past the half voxel the field's surface may sit off it
+    let lifted = position + normal * voxel;
+
+    var irradiance = vec3<f32>(0.0);
+
+    for (var j = 0u; j < point_count; j++) {
+        let index = world_cluster_data[cell.offset + j];
+        let light = irradiance_clipmap_get_point_light_info_by_index(&light_data, index, position, voxel);
+        let cosine = max(dot(normal, light.direction), 0.0);
+
+        if (cosine == 0.0 || all(light.color == vec3<f32>(0.0))) {
+            continue;
+        }
+
+        irradiance += light.color * (cosine * volumetrics_point_light_shadow(&light_data, index, lifted));
+    }
+
+    // the cell's spot lights follow its point lights
+    let spots = cell.offset + light_cluster_count_point(cell.counts);
+
+    for (var k = 0u; k < spot_count; k++) {
+        let index = world_cluster_data[spots + k];
+        let light = irradiance_clipmap_get_spot_light_info_by_index(&light_data, index, position, voxel);
+        let cosine = max(dot(normal, light.direction), 0.0);
+
+        if (cosine == 0.0 || all(light.color == vec3<f32>(0.0))) {
+            continue;
+        }
+
+        irradiance += light.color * (cosine * volumetrics_spot_light_shadow(&light_data, index, lifted));
+    }
+
+    return irradiance;
+}
+
+@compute @workgroup_size(${PROBE_THREAD_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let ray = folded_workgroup_index(workgroup_id) * PROBE_THREAD_WORKGROUP_SIZE + lane;
+    let rays = settings.rays_per_probe;
+
+    if (ray >= min(probe_trace.count, settings.trace_capacity) * rays) {
+        return;
+    }
+
+    let record = probe_rays[ray];
+    let albedo = unpack4x8unorm(record.row).rgb;
+    let front_hit = (record.flags & PROBE_RAY_KIND_MASK) == ${BRICK_TRACE_HIT}u && (record.flags & PROBE_RAY_BACK_FACE) == 0u;
+
+    // only a front-face hit that bounces anything takes more light
+    if (!front_hit || all(albedo == vec3<f32>(0.0))) {
+        return;
+    }
+
+    let slot = probe_trace.elements[ray / rays];
+    let i = ray % rays;
+    let n = settings.radiance_resolution;
+    let updates = probe_state_updates(probe_states[slot].x);
+    let texel = probe_clipmap_ray_texel(i, updates, rays, n * n);
+
+    let direction = uv_octahedral_unit_decode(unpack2x16unorm(record.direction));
+    let position = probe_origins[ray / rays].xyz + record.t * direction;
+    let normal = uv_octahedral_unit_decode(unpack2x16unorm(record.normal));
+
+    // E/π: the local lights', then the next bounce's, which the resolve gives as E/π
+    var e = probe_clipmap_local_irradiance(record.flags >> PROBE_RAY_CASCADE_SHIFT, position, normal) * RECIPROCAL_PI;
+
+    let probes = probe_clipmap_sample_sh(position, normal, -direction, probe_clipmap_ray_jitter(slot, texel, i, updates, rays, n));
+
+    if (probes.found) {
+        e += resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, normal);
+    }
+
+    if (all(e == vec3<f32>(0.0))) {
+        return;
+    }
+
+    let light = vec3<f32>(unpack2x16float(record.light_rg), unpack2x16float(record.light_b).x) + albedo * e;
+    let held = min(light, vec3<f32>(${HALF_MAX}.0));
+
+    probe_rays[ray].light_rg = pack2x16float(held.rg);
+    probe_rays[ray].light_b = pack2x16float(vec2<f32>(held.b, 0.0));
+}
+`, [
+            chunk_probe_clipmap,
+            chunk_probe_clipmap_ray_texel,
+            chunk_probe_clipmap_ray_jitter,
+            chunk_folded_workgroup_index,
+            chunk_uv_octahedral_unit_decode,
+            chunk_probe_clipmap_pick,
+            chunk_resolve_irradiance_sh_to_diffuse,
+            RECIPROCAL_PI_DECLARATION,
+            chunk_world_light_cluster_lookup_at,
+            chunk_light_cluster_counts,
+            chunk_irradiance_clipmap_local_light,
+            chunk_volumetrics_local_light_shadow,
+        ]),
+});

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_retire.d.ts

@@ -6,9 +6,9 @@ export const PROBE_RETIRE_SETTINGS: WebGPUStruct;
  * Retire (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): a thread a live probe, the first of the frame's
  * lifetime passes, dispatched through `PROBE_DISPATCH_ACTIVE` over the list the frame before wrote.
  *
- * A probe is freed when its lattice point has left its cascade's window, or when no pixel has wanted it
- * for longer than the retention time: its slot goes back on the free list, its state to FREE, and its
- * indirection entry, if it still names the slot, to none. The rest go on the frame's list.
+ * A probe is freed when its lattice point has left its cascade's window, or when nothing, pixel or hit,
+ * has wanted it for longer than the retention time: its slot goes back on the free list, its state to
+ * FREE, and its indirection entry, if it still names the slot, to none. The rest go on the frame's list.
  *
  * Running before want means a window's move needs no pass of its own: the storage cells it vacated
  * are emptied before any point it exposed can claim them.

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_retire.js

@@ -53,9 +53,9 @@ resources.createGroup()
  * Retire (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): a thread a live probe, the first of the frame's
  * lifetime passes, dispatched through `PROBE_DISPATCH_ACTIVE` over the list the frame before wrote.
  *
- * A probe is freed when its lattice point has left its cascade's window, or when no pixel has wanted it
- * for longer than the retention time: its slot goes back on the free list, its state to FREE, and its
- * indirection entry, if it still names the slot, to none. The rest go on the frame's list.
+ * A probe is freed when its lattice point has left its cascade's window, or when nothing, pixel or hit,
+ * has wanted it for longer than the retention time: its slot goes back on the free list, its state to
+ * FREE, and its indirection entry, if it still names the slot, to none. The rest go on the frame's list.
  *
  * Running before want means a window's move needs no pass of its own: the storage cells it vacated
  * are emptied before any point it exposed can claim them.

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.d.ts

@@ -14,7 +14,8 @@ export const PROBE_SHADE_SETTINGS: WebGPUStruct;
  * - an **unresolved** ray and a **back face** bring nothing back: accumulation discards the one and
  *   counts the other (§8.4, §8.8).
  *
- * The local lights and the next bounce join E at S5 (§13).
+ * A front-face hit's diffuse albedo goes over its `row`, `pack4x8unorm`, and every other ray's row to
+ * zero: the light pass adds ρ_d·(E_loc + E_ind)/π after it (S5).
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js"],"names":[],"mappings":"AAyCA;;GAEG;AACH,mCAFU,YAAY,CAOG;AAyBzB;;;;;;;;;;;;;;;GAeG;AACH,yCAFU,aAAa,CAoDpB;6BA1H0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js"],"names":[],"mappings":"AAyCA;;GAEG;AACH,mCAFU,YAAY,CAOG;AAyBzB;;;;;;;;;;;;;;;;GAgBG;AACH,yCAFU,aAAa,CAuDpB;6BA9H0B,sCAAsC;8BAHrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js

@@ -84,7 +84,8 @@ resources.createGroup()
  * - an **unresolved** ray and a **back face** bring nothing back: accumulation discards the one and
  *   counts the other (§8.4, §8.8).
  *
- * The local lights and the next bounce join E at S5 (§13).
+ * A front-face hit's diffuse albedo goes over its `row`, `pack4x8unorm`, and every other ray's row to
+ * zero: the light pass adds ρ_d·(E_loc + E_ind)/π after it (S5).
  *
  * @type {ComputeShader}
  */
@@ -111,6 +112,7 @@ fn main(
     let direction = uv_octahedral_unit_decode(unpack2x16unorm(record.direction));
 
     var radiance = vec3<f32>(0.0);
+    var albedo = vec3<f32>(0.0);
 
     if (kind == ${BRICK_TRACE_MISS}u) {
         radiance = sample_environment_color(tEnvironment, sEnvironment, direction);
@@ -123,12 +125,14 @@ fn main(
         let direct = vec3<f32>(unpack2x16float(record.light_rg), unpack2x16float(record.light_b).x);
 
         radiance = surface.emissive + surface.albedo * direct * RECIPROCAL_PI;
+        albedo = surface.albedo;
     }
 
     let held = min(radiance, vec3<f32>(${HALF_MAX}.0));
 
     probe_rays[ray].light_rg = pack2x16float(held.rg);
     probe_rays[ray].light_b = pack2x16float(vec2<f32>(held.b, 0.0));
+    probe_rays[ray].row = pack4x8unorm(vec4<f32>(albedo, 0.0));
 }
 `, [
             chunk_probe_clipmap,

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAuCA;;GAEG;AACH,mCAFU,YAAY,CAaG;AAsBzB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,yCAFU,aAAa,CAwGpB;6BA5L0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAsCA;;GAEG;AACH,mCAFU,YAAY,CAaG;AAsBzB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,yCAFU,aAAa,CAkGpB;6BAvL0B,sCAAsC;8BAHrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js

@@ -6,8 +6,6 @@ import { chunk_uv_octahedral_unit_decode } from "../../../shader/chunk/geometry/
 import { chunk_uv_octahedral_unit_encode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
 import { chunk_directional_lights_iteration_mask } from "../../../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
-import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
-import { chunk_hash_lowbias32 } from "../../../shader/chunk/random/chunk_hash_lowbias32.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -27,6 +25,7 @@ import {
 } from "../brick/chunk_brick_clipmap_trace.js";
 import {
     chunk_probe_clipmap,
+    chunk_probe_clipmap_ray_jitter,
     chunk_probe_clipmap_ray_texel,
     PROBE_ORIGINS_READ_RESOURCE,
     PROBE_RAYS_WRITE_RESOURCE,
@@ -125,12 +124,7 @@ fn main(
     let updates = probe_state_updates(state.x);
 
     let texel = probe_clipmap_ray_texel(i, updates, rays, texels);
-    let round = select(0u, i / texels, rays >= texels);
-    let per_texel = max(rays / texels, 1u);
-
-    let scramble = hash_lowbias32(slot);
-    let noise_xy = vec2<u32>(texel % n, texel / n) + vec2<u32>(scramble & 127u, (scramble >> 7u) & 127u);
-    let jitter = stbn_sample_vec2(vec3<u32>(noise_xy, updates * per_texel + round));
+    let jitter = probe_clipmap_ray_jitter(slot, texel, i, updates, rays, n);
 
     let direction = uv_octahedral_unit_decode((vec2<f32>(f32(texel % n), f32(texel / n)) + jitter) / f32(n));
 
@@ -189,9 +183,8 @@ fn main(
 `, [
             chunk_probe_clipmap,
             chunk_probe_clipmap_ray_texel,
+            chunk_probe_clipmap_ray_jitter,
             chunk_folded_workgroup_index,
-            chunk_hash_lowbias32,
-            chunk_stbn_sample_vec2,
             chunk_uv_octahedral_unit_decode,
             chunk_uv_octahedral_unit_encode,
             chunk_brick_clipmap_trace,

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.d.ts

@@ -6,18 +6,14 @@ export const PROBE_WANT_SETTINGS: WebGPUStruct;
  * Want (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): a thread a tile of {@link PROBE_WANT_TILE}² pixels,
  * the launch the screen's tiles.
  *
- * Each frame a tile wants the probes of one of its pixels, picked by STBN at (tile, frame), the cages
- * that pixel's pick reads (§9.1): the finest cascade whose cage window holds the point, the cage of
- * the point biased `0.1` of that cascade's spacing along `mix(n, v, 0.2)`, and in the cascade's blend
- * skirt the next cascade's cage too, biased by its own spacing. A sky pixel wants nothing; neither does
- * a cage a bias moved out of its window. Each cage point's bit is set, and a point whose bit was clear
- * goes on the wanted list, so the list holds every point wanted this frame once.
+ * Each frame a tile wants the probes of one of its pixels, picked by STBN at (tile, frame): the cages
+ * that pixel's pick reads (§9.1), biased along `mix(n, v, 0.2)`, through `probe_clipmap_want`. A sky
+ * pixel wants nothing. Its points go on the wanted list as the screen's, `PROBE_WANTED_SCREEN`; want runs
+ * before the hits' wants, so a point both want is the screen's.
  *
  * At a cascade's outer edge a lattice cell is 58 pixels on a 1080p screen at a 60° field of view, and
  * 19 at 120°, so a tile of 8 samples every cell several times a frame, and a workgroup's 64 tiles want
- * a few cages between them. So the first lane of a workgroup to want a cage claims it in the
- * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at
- * 1280×720 on Sponza, the bits' atomics were 140 of want's 345 µs and the appends 90.
+ * a few cages between them, which its claims keep to one want each.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAoCA;;GAEG;AACH,kCAFU,YAAY,CAUE;AAexB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCAFU,aAAa,CAuHpB;6BAxL0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,kCAFU,YAAY,CAUE;AAexB;;;;;;;;;;;;;;GAcG;AACH,wCAFU,aAAa,CAqCpB;6BAtF0B,sCAAsC;8BAHrC,kCAAkC"}