@woosh/meep-engine 3.60.3 → 3.60.4

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"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"}

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

@@ -375,6 +375,26 @@ export const PROBE_MAPS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("
  */
 export const PROBE_ESTIMATORS_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_estimators", WebGPUArray.from(vec4u), true);
 
+/**
+ * Each slot's radiance estimators, as the re-sample pass reads them: how spread each texel's samples are.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ESTIMATORS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_estimators", WebGPUArray.from(vec4u));
+
+/**
+ * The listed probes' re-samples of their neighbours, n_r² a probe by radiance texel, in list order: the
+ * accepted re-samples' radiance, each times its weight, summed, and the weights' sum
+ * (`shader_probe_clipmap_resample`), as the re-sample pass writes them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RESAMPLES_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_resamples", WebGPUArray.from(vec4f), true);
+
+/**
+ * The listed probes' re-samples, as accumulation reads them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RESAMPLES_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_resamples", WebGPUArray.from(vec4f));
+
 /**
  * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
  * @type {WebGPUStruct}

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

@@ -0,0 +1,18 @@
+/**
+ * A radiance texel's rays as accumulate pools them, by {@link PROBE_CLIPMAP_RESAMPLING}:
+ *
+ * ```wgsl
+ * fn probe_clipmap_resampled(index: u32, sum: vec3<f32>, count: u32) -> vec4<f32> // index: the texel's among the listed probes', k·n_r² + i
+ * ```
+ *
+ * Takes the texel's rays this update, their radiance's sum and their count, and gives the samples it
+ * pools: their radiance's sum and their weight, whose quotient is the texel's sample.
+ * - `false`, the default: the rays alone.
+ * - `true`: the rays and the re-samples of the probe's neighbours that `shader_probe_clipmap_resample`
+ *   wrote for the texel, each a ray's worth at a visibility of one.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_probe_clipmap_resampled: CodeChunkChoice;
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_probe_clipmap_resampled.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_clipmap_resampled.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_resampled.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,4CAFU,eAAe,CAEmE;gCAnB5D,6CAA6C"}

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

@@ -0,0 +1,42 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+import { PROBE_RESAMPLES_READ_RESOURCE } from "./chunk_probe_clipmap.js";
+import { PROBE_CLIPMAP_RESAMPLING } from "./PROBE_CLIPMAP_RESAMPLING.js";
+
+/**
+ * A radiance texel's rays as accumulate pools them, by {@link PROBE_CLIPMAP_RESAMPLING}:
+ *
+ * ```wgsl
+ * fn probe_clipmap_resampled(index: u32, sum: vec3<f32>, count: u32) -> vec4<f32> // index: the texel's among the listed probes', k·n_r² + i
+ * ```
+ *
+ * Takes the texel's rays this update, their radiance's sum and their count, and gives the samples it
+ * pools: their radiance's sum and their weight, whose quotient is the texel's sample.
+ * - `false`, the default: the rays alone.
+ * - `true`: the rays and the re-samples of the probe's neighbours that `shader_probe_clipmap_resample`
+ *   wrote for the texel, each a ray's worth at a visibility of one.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_probe_clipmap_resampled = CodeChunkChoice.from(PROBE_CLIPMAP_RESAMPLING);
+
+const rays = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_resampled(index: u32, sum: vec3<f32>, count: u32) -> vec4<f32> {
+    return vec4<f32>(sum, f32(count));
+}
+`);
+
+const resampled = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_resampled(index: u32, sum: vec3<f32>, count: u32) -> vec4<f32> {
+    return vec4<f32>(sum, f32(count)) + probe_resamples[index];
+}
+`);
+
+resampled.requireResource(PROBE_RESAMPLES_READ_RESOURCE);
+
+chunk_probe_clipmap_resampled.add(false, rays);
+chunk_probe_clipmap_resampled.add(true, resampled);

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,kDAFU,SAAS,CAqIZ;0BA5KmB,uCAAuC"}
+{"version":3,"file":"chunk_probe_clipmap_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,kDAFU,SAAS,CAsIZ;0BA7KmB,uCAAuC"}

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

@@ -63,14 +63,15 @@ struct ProbeClipmapLobe {
     sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
 }
 
-// a slot's radiance toward a direction: one bilinear tap of its tile, through its skirt
-fn probe_clipmap_radiance(slot: u32, direction: vec3<f32>) -> vec3<f32> {
+// a slot's radiance toward a direction, and its texels' count of samples in alpha: one bilinear tap of its
+// tile, through its skirt
+fn probe_clipmap_radiance(slot: u32, direction: vec3<f32>) -> vec4<f32> {
     let side = probe_sampling.radiance_resolution + 2u;
     let place = index_to_grid2d_reciprocal(slot, probe_sampling.radiance_tiles_per_row, probe_sampling.radiance_tiles_per_row_reciprocal);
     let tile = vec2<f32>(place * side);
     let in_tile = texture_octahedral_skirt_uv(uv_octahedral_unit_encode(direction), f32(side)) * f32(side);
 
-    return textureSampleLevel(probe_radiance, probe_depth_sampler, (tile + in_tile) * probe_sampling.radiance_texel, 0.0).rgb;
+    return textureSampleLevel(probe_radiance, probe_depth_sampler, (tile + in_tile) * probe_sampling.radiance_texel, 0.0);
 }
 
 // a picked probe's share for the lobe, its radiance along it and its SH
@@ -108,7 +109,7 @@ fn probe_clipmap_lobe(slot: u32, share: f32, position: vec3<f32>, normal: vec3<f
         }
     }
 
-    out.radiance = probe_clipmap_radiance(slot, direction);
+    out.radiance = probe_clipmap_radiance(slot, direction).rgb;
 
     return out;
 }

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

@@ -33,6 +33,10 @@ export const PROBE_ACCUMULATE_SETTINGS: WebGPUStruct;
  *   - Samples are clipped once the variance's window has passed, when 1/(a+1) is no longer its blend:
  *     before that it holds no spread to clip to.
  *   - A texel's first sample seeds both means. A texel no ray reached keeps its history.
+ *   - Where the frame re-samples (`PROBE_CLIPMAP_RESAMPLING`), the sample pools the rays with the texel's
+ *     re-samples of the probe's neighbours (`shader_probe_clipmap_resample`), each a ray's worth at a
+ *     visibility of one (`chunk_probe_clipmap_resampled`). Only a texel some ray reached takes them: its
+ *     time terms are a sampled texel's.
  * - **Depth**: the moments (d, d²) of the rays landing in the texel, in spacings: a miss the limit, a
  *   back face 0.2·t (DDGI 2021's shortening), a hit t, every sample held to the limit, the farthest a
  *   cage tests a relocated probe, (1 + 0.45)·√3 (`PROBE_DEPTH_LIMIT`, D9). On a uniform update the

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.js"],"names":[],"mappings":"AA0CA;;GAEG;AACH,wCAFU,YAAY,CAqBQ;AAmB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,8CAFU,aAAa,CAmVpB;6BA3c0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.js"],"names":[],"mappings":"AA4CA;;GAEG;AACH,wCAFU,YAAY,CAqBQ;AAqB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,8CAFU,aAAa,CAsVpB;6BAtd0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -28,9 +28,11 @@ import {
     PROBE_RAY_SUMS_READ_RESOURCE,
     PROBE_RAYS_READ_RESOURCE,
     PROBE_RECORDS_READ_RESOURCE,
+    PROBE_RESAMPLES_READ_RESOURCE,
     PROBE_STATES_READ_RESOURCE,
     PROBE_TRACE_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
+import { chunk_probe_clipmap_resampled } from "./chunk_probe_clipmap_resampled.js";
 import {
     PROBE_BACK_FACE_DEPTH,
     PROBE_CHANGE_SIGNIFICANCE,
@@ -79,7 +81,9 @@ resources.createGroup()
     .add(PROBE_MAPS_WRITE_RESOURCE)
     .add(PROBE_RADIANCE_HISTORY_RESOURCE)
     .add(PROBE_DEPTH_HISTORY_RESOURCE)
-    .add(PROBE_ESTIMATORS_RESOURCE);
+    .add(PROBE_ESTIMATORS_RESOURCE)
+    // read only where the frame re-samples (chunk_probe_clipmap_resampled)
+    .add(PROBE_RESAMPLES_READ_RESOURCE);
 
 /**
  * Accumulate (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8): a thread a texel of each listed probe's maps,
@@ -112,6 +116,10 @@ resources.createGroup()
  *   - Samples are clipped once the variance's window has passed, when 1/(a+1) is no longer its blend:
  *     before that it holds no spread to clip to.
  *   - A texel's first sample seeds both means. A texel no ray reached keeps its history.
+ *   - Where the frame re-samples (`PROBE_CLIPMAP_RESAMPLING`), the sample pools the rays with the texel's
+ *     re-samples of the probe's neighbours (`shader_probe_clipmap_resample`), each a ray's worth at a
+ *     visibility of one (`chunk_probe_clipmap_resampled`). Only a texel some ray reached takes them: its
+ *     time terms are a sampled texel's.
  * - **Depth**: the moments (d, d²) of the rays landing in the texel, in spacings: a miss the limit, a
  *   back face 0.2·t (DDGI 2021's shortening), a hit t, every sample held to the limit, the farthest a
  *   cage tests a relocated probe, (1 + 0.45)·√3 (`PROBE_DEPTH_LIMIT`, D9). On a uniform update the
@@ -280,7 +288,9 @@ fn main(
         var change = vec2<f32>(0.0);
 
         if (count > 0u) {
-            let sample = sum / f32(count);
+            // the rays, and the neighbours' re-samples where the frame took them
+            let pooled = probe_clipmap_resampled(k * texels + i, sum, count);
+            let sample = pooled.rgb / pooled.w;
             let estimator = slot * texels + i;
             let rate = probe_clipmap_guide_rate(probe_accumulate_expected_rays(base, i, rays, n), settings.rays_per_probe, texels, settings.uniform_period);
 
@@ -459,6 +469,7 @@ fn main(
             chunk_probe_clipmap_ray_layout,
             chunk_probe_clipmap_ray_texel,
             chunk_probe_clipmap_guide,
+            chunk_probe_clipmap_resampled,
             chunk_folded_workgroup_index,
             chunk_index_to_grid2d,
             chunk_f16_round_stochastic,

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

@@ -0,0 +1,52 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const PROBE_RESAMPLE_SETTINGS: WebGPUStruct;
+/**
+ * Re-sample: each radiance texel of each listed probe B takes what its neighbours have already seen, and
+ * traces nothing (Enshrouded's probe reprojection). A thread a texel, through accumulate's launch,
+ * `PROBE_DISPATCH_TEXELS`; the depth texels' threads do nothing. It writes the texel's
+ * `probe_resamples`: the accepted re-samples' radiance, each times its weight, summed, and the weights'
+ * sum. Accumulate adds them to the texel's rays when `PROBE_CLIPMAP_RESAMPLING` is on, each re-sample a
+ * ray's worth (`chunk_probe_clipmap_resampled`); with it off, this pass is not recorded.
+ *
+ * - **The neighbours**: `PROBE_RESAMPLE_NEIGHBOURS` distinct ones of the 26 around B's lattice point
+ *   in its cascade, from a start and a stride coprime with 26 that a hash of the slot, the texel and
+ *   the update count picks, so a texel meets every neighbour over its updates. A neighbour is taken only
+ *   if it is ALIVE and its record holds that point: the indirection's storage wraps.
+ * - **The point B sees**: along the texel's centre direction ω, at B's mean depth there, from its
+ *   published depth.
+ * - **The neighbour's radiance**: its published radiance toward the point, weighed by how well its own
+ *   depth toward the point confirms a surface there: `s² / (s² + (d − μ)²)`, d the point's distance from
+ *   it and μ its mean depth that way, in spacings, s² its depth's variance that way plus the receiver
+ *   bias squared (`PROBE_RECEIVER_BIAS`). Two-sided, unlike Chebyshev's: a neighbour that sees nearer
+ *   has an occluder between, and one that sees farther sees past a point in mid-air, which B's texel puts
+ *   there where it mixes a near depth with a far one.
+ * - **Only what depth confirms**: a texel whose depth is at the limit, everything past every probe's
+ *   moments, takes nothing, and nor is a neighbour whose distance to the point is at the limit or past it.
+ * - Measured on Sponza, the 4090, the settled frame's eight-corner diffuse against a reference of four times
+ *   the rays without re-sampling: without re-sampling +1.1–1.9% (two runs); Chebyshev one-sided, the first
+ *   read along ω itself and the second at the limit alone, +11.5%; two-sided, +9.8%; without the second,
+ *   +6.5%; without either, as built, +3.2%. Light the depth cannot confirm is light through a wall.
+ * - **Confidence**: the weight is also scaled by how much the neighbour's mean can be trusted, so a re-sample
+ *   stays at most a ray's worth:
+ *   - its spread and its count, `σ²_B / (σ²_B + σ²_A / n_A)`: σ²_A the variance of the samples of the
+ *     neighbour's texel the point is in (its estimator's deviation, luminance), n_A that texel's count of
+ *     samples (the radiance's alpha), so σ²_A / n_A is the variance of the mean read; σ²_B that of one of
+ *     B's own samples of its texel. Both are absolute, each held to the estimator's own floor of 10⁻⁵, so a
+ *     dark neighbour is not taken less for being dark;
+ *   - its freshness, `e^(−age / τ)`: age the frames since the neighbour's last update, τ
+ *     `response_frames`, the time over which a probe's own history follows a change.
+ * - A neighbour's texel no ray has reached, its count zero, is not taken.
+ * - A probe whose first update this is, or a DEAD one, takes nothing: its depth is not yet its own, or
+ *   it is inside a solid.
+ *
+ * Reads only the atlases as the last publish left them, and the frame's records and states, which no
+ * pass after relocation writes before accumulate.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_probe_clipmap_resample: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_probe_clipmap_resample.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_probe_clipmap_resample.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_resample.js"],"names":[],"mappings":"AA+BA;;GAEG;AACH,sCAFU,YAAY,CAaM;AAsB5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,4CAFU,aAAa,CA4IpB;6BAhP0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -0,0 +1,250 @@
+import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_uv_octahedral_unit_decode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+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_pcg3d } from "../../../shader/chunk/random/pcg/chunk_pcg3d.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import {
+    chunk_probe_clipmap,
+    PROBE_DEPTH_HISTORY_RESOURCE,
+    PROBE_ESTIMATORS_READ_RESOURCE,
+    PROBE_LEVELS_RESOURCE,
+    PROBE_ORIGINS_READ_RESOURCE,
+    PROBE_RADIANCE_HISTORY_RESOURCE,
+    PROBE_RECORDS_READ_RESOURCE,
+    PROBE_RESAMPLES_WRITE_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 { chunk_probe_clipmap_sample_radiance } from "./chunk_probe_clipmap_sample_radiance.js";
+import { PROBE_DEPTH_LIMIT, PROBE_RECEIVER_BIAS, PROBE_RESAMPLE_NEIGHBOURS, PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const PROBE_RESAMPLE_SETTINGS = WebGPUStruct.from({
+    /** probes a frame updates at most: the trace list's bound */
+    trace_capacity: u32,
+    /** octahedral radiance texels a side, n_r */
+    radiance_resolution: u32,
+    /** octahedral depth texels a side, n_d: the texels' launch is accumulate's, n_r² + n_d² a probe */
+    depth_resolution: u32,
+    /** the frame, of the frames the clipmap has recorded */
+    frame: u32,
+    /** the short mean's response, τ, in frames: how fast a neighbour's history goes stale */
+    response_frames: f32,
+}, "ProbeResampleSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", PROBE_RESAMPLE_SETTINGS);
+
+resources.createGroup()
+    .add(PROBE_TRACE_READ_RESOURCE)
+    .add(PROBE_ORIGINS_READ_RESOURCE)
+    .add(PROBE_RESAMPLES_WRITE_RESOURCE);
+
+resources.createGroup()
+    .add(PROBE_LEVELS_RESOURCE)
+    .add(PROBE_SAMPLING_RESOURCE)
+    .add(PROBE_INDIRECTION_READ_RESOURCE)
+    .add(PROBE_STATES_READ_RESOURCE)
+    .add(PROBE_RECORDS_READ_RESOURCE)
+    .add(PROBE_DEPTH_HISTORY_RESOURCE)
+    .add(PROBE_RADIANCE_HISTORY_RESOURCE)
+    .add(PROBE_DEPTH_SAMPLER_RESOURCE)
+    .add(PROBE_ESTIMATORS_READ_RESOURCE);
+
+/**
+ * Re-sample: each radiance texel of each listed probe B takes what its neighbours have already seen, and
+ * traces nothing (Enshrouded's probe reprojection). A thread a texel, through accumulate's launch,
+ * `PROBE_DISPATCH_TEXELS`; the depth texels' threads do nothing. It writes the texel's
+ * `probe_resamples`: the accepted re-samples' radiance, each times its weight, summed, and the weights'
+ * sum. Accumulate adds them to the texel's rays when `PROBE_CLIPMAP_RESAMPLING` is on, each re-sample a
+ * ray's worth (`chunk_probe_clipmap_resampled`); with it off, this pass is not recorded.
+ *
+ * - **The neighbours**: `PROBE_RESAMPLE_NEIGHBOURS` distinct ones of the 26 around B's lattice point
+ *   in its cascade, from a start and a stride coprime with 26 that a hash of the slot, the texel and
+ *   the update count picks, so a texel meets every neighbour over its updates. A neighbour is taken only
+ *   if it is ALIVE and its record holds that point: the indirection's storage wraps.
+ * - **The point B sees**: along the texel's centre direction ω, at B's mean depth there, from its
+ *   published depth.
+ * - **The neighbour's radiance**: its published radiance toward the point, weighed by how well its own
+ *   depth toward the point confirms a surface there: `s² / (s² + (d − μ)²)`, d the point's distance from
+ *   it and μ its mean depth that way, in spacings, s² its depth's variance that way plus the receiver
+ *   bias squared (`PROBE_RECEIVER_BIAS`). Two-sided, unlike Chebyshev's: a neighbour that sees nearer
+ *   has an occluder between, and one that sees farther sees past a point in mid-air, which B's texel puts
+ *   there where it mixes a near depth with a far one.
+ * - **Only what depth confirms**: a texel whose depth is at the limit, everything past every probe's
+ *   moments, takes nothing, and nor is a neighbour whose distance to the point is at the limit or past it.
+ * - Measured on Sponza, the 4090, the settled frame's eight-corner diffuse against a reference of four times
+ *   the rays without re-sampling: without re-sampling +1.1–1.9% (two runs); Chebyshev one-sided, the first
+ *   read along ω itself and the second at the limit alone, +11.5%; two-sided, +9.8%; without the second,
+ *   +6.5%; without either, as built, +3.2%. Light the depth cannot confirm is light through a wall.
+ * - **Confidence**: the weight is also scaled by how much the neighbour's mean can be trusted, so a re-sample
+ *   stays at most a ray's worth:
+ *   - its spread and its count, `σ²_B / (σ²_B + σ²_A / n_A)`: σ²_A the variance of the samples of the
+ *     neighbour's texel the point is in (its estimator's deviation, luminance), n_A that texel's count of
+ *     samples (the radiance's alpha), so σ²_A / n_A is the variance of the mean read; σ²_B that of one of
+ *     B's own samples of its texel. Both are absolute, each held to the estimator's own floor of 10⁻⁵, so a
+ *     dark neighbour is not taken less for being dark;
+ *   - its freshness, `e^(−age / τ)`: age the frames since the neighbour's last update, τ
+ *     `response_frames`, the time over which a probe's own history follows a change.
+ * - A neighbour's texel no ray has reached, its count zero, is not taken.
+ * - A probe whose first update this is, or a DEAD one, takes nothing: its depth is not yet its own, or
+ *   it is inside a solid.
+ *
+ * Reads only the atlases as the last publish left them, and the frame's records and states, which no
+ * pass after relocation writes before accumulate.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_probe_clipmap_resample = ComputeShader.from({
+    label: "Probe Clipmap Resample",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+// the j-th of the 26 neighbours: the 3×3×3 around the point, its centre skipped
+fn probe_resample_offset(j: u32) -> vec3<i32> {
+    let index = j + select(0u, 1u, j >= 13u);
+
+    return vec3<i32>(vec3<u32>(index % 3u, (index / 3u) % 3u, index / 9u)) - vec3<i32>(1);
+}
+
+// the variance of a texel's samples, luminance, from its estimator's words: the deviation's r in the second word's
+// high half, its g and b in the third; held to the estimator's own floor
+fn probe_resample_variance(words: vec4<u32>) -> f32 {
+    let deviation = vec3<f32>(unpack2x16float(words.y).y, unpack2x16float(words.z));
+    let d = rgb_to_luminance(sqrt(max(vec3<f32>(1e-5), deviation * deviation)));
+
+    return d * d;
+}
+
+// a stride through the 26 that meets each of them once: odd, and not 13
+fn probe_resample_stride(hash: u32) -> u32 {
+    let m = hash % 12u;
+
+    return 2u * m + 1u + select(0u, 2u, m >= 6u);
+}
+
+@compute @workgroup_size(${PROBE_THREAD_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let thread = folded_workgroup_index(workgroup_id) * PROBE_THREAD_WORKGROUP_SIZE + lane;
+
+    let n = settings.radiance_resolution;
+    let texels = n * n;
+    let per_probe = texels + settings.depth_resolution * settings.depth_resolution;
+
+    if (thread >= min(probe_trace.count, settings.trace_capacity) * per_probe) {
+        return;
+    }
+
+    let k = thread / per_probe;
+    let i = thread % per_probe;
+
+    if (i >= texels) {
+        return;
+    }
+
+    let slot = probe_trace.elements[k];
+    let state = probe_states[slot];
+
+    var sum = vec4<f32>(0.0);
+
+    if (probe_state_kind(state.x) == PROBE_STATE_ALIVE) {
+        let record = probe_records[slot];
+        let cascade = probe_record_cascade(record.flags);
+        let origin = probe_origins[k];
+        let spacing = origin.w;
+
+        let direction = uv_octahedral_unit_decode((vec2<f32>(f32(i % n), f32(i / n)) + 0.5) / f32(n));
+        let seen = probe_clipmap_depth_moments(slot, direction).x;
+        let point = origin.xyz + direction * (seen * spacing);
+        // the variance of one of B's own samples of the texel
+        let own = probe_resample_variance(probe_estimators[slot * texels + i]);
+
+        let hash = pcg3d(vec3<u32>(slot, i, probe_state_updates(state.x)));
+        let start = hash.x % 26u;
+        let stride = probe_resample_stride(hash.y);
+
+        // at the limit to a half float's step there, 2^-9 between 2 and 4: every ray that way went past it,
+        // and no depth confirms where
+        let gathered = select(0u, ${PROBE_RESAMPLE_NEIGHBOURS}u, seen < ${PROBE_DEPTH_LIMIT} - 1.0 / 512.0);
+
+        for (var t = 0u; t < gathered; t++) {
+            let lattice = record.cell + probe_resample_offset((start + t * stride) % 26u);
+            let neighbour = probe_clipmap_corner_slot(cascade, lattice);
+
+            if (neighbour == PROBE_CLIPMAP_NONE) {
+                continue;
+            }
+
+            let neighbour_state = probe_states[neighbour];
+
+            // the storage wraps: the slot is this point's only if its record says so
+            if (probe_state_kind(neighbour_state.x) != PROBE_STATE_ALIVE || any(probe_records[neighbour].cell != lattice)) {
+                continue;
+            }
+
+            let at = vec3<f32>(lattice) * spacing + probe_clipmap_offset_decode(neighbour_state.y, spacing);
+            let to_point = point - at;
+            let distance = length(to_point) / spacing;
+
+            if (distance >= ${PROBE_DEPTH_LIMIT}) {
+                continue;
+            }
+
+            let toward = to_point / max(distance * spacing, 1e-6);
+            let radiance = probe_clipmap_radiance(neighbour, toward);
+
+            if (radiance.a < 1.0) {
+                continue;
+            }
+
+            let moments = probe_clipmap_depth_moments(neighbour, toward);
+            let spread = max(moments.y - moments.x * moments.x, 0.0) + ${PROBE_RECEIVER_BIAS} * ${PROBE_RECEIVER_BIAS};
+            let gap = distance - moments.x;
+            let visibility = spread / (spread + gap * gap);
+
+            // the neighbour's texel the point is in: the variance of the mean read, its samples' over their count
+            let uv = min(vec2<u32>(uv_octahedral_unit_encode(toward) * f32(n)), vec2<u32>(n - 1u));
+            let mean_variance = probe_resample_variance(probe_estimators[neighbour * texels + uv.y * n + uv.x]) / radiance.a;
+            let confidence = own / (own + mean_variance);
+
+            // how stale its history is: the frames since its last update, over the response time
+            let age = f32(settings.frame - probe_records[neighbour].traced_frame);
+            let freshness = exp(-age / settings.response_frames);
+
+            let weight = visibility * confidence * freshness;
+
+            sum += vec4<f32>(radiance.rgb * weight, weight);
+        }
+    }
+
+    probe_resamples[k * texels + i] = sum;
+}
+`, [
+            chunk_probe_clipmap,
+            chunk_probe_clipmap_pick,
+            chunk_probe_clipmap_sample_radiance,
+            chunk_folded_workgroup_index,
+            chunk_uv_octahedral_unit_decode,
+            chunk_uv_octahedral_unit_encode,
+            chunk_rgb_to_luminance,
+            chunk_pcg3d,
+        ]),
+});

package/src/shade/renderer/light/cluster/PROPOSAL_ALGORITHM_2026_10_16.md

@@ -140,19 +140,19 @@ planes. This removes exactly those pairs (0 other cells change) and is 4–20% f
 Every entry below is **VERIFIED**, read at a pinned commit, unless tagged **SECONDARY**. The raw copies are
 in the scratchpad `src/`.
 
-### 2.1 Unreal Engine 5.4 (`LightGridInjection.usf/.cpp`, read in the installed source)
+### 2.1 Unreal Engine 5.4
 
-- **Thread mapping:** one thread per cell, `THREADGROUP_SIZE` 4, so 4×4×4 groups. The grid is 64 px tiles ×
+- **Thread mapping:** one thread per cell, 4×4×4 groups. The grid is 64 px tiles ×
   32 slices.
 - **No parent or coarse grid in 5.4.**
-- **Cell bounds:** the view-space AABB of the cell's 8 corners (`ComputeCellViewAABB`). Lights are moved to
+- **Cell bounds:** the view-space AABB of the cell's 8 corners. Lights are moved to
   view space on the CPU.
-- **Test:** `ComputeSquaredDistanceFromBoxToPoint` < r². For spot lights, one separating plane through the
-  apex facing the AABB centre (`IsAabbOutsideInfiniteAcuteConeApprox`).
+- **Test:** squared distance from box to point < r². For spot lights, one separating plane through the
+  apex facing the AABB centre.
 - **Iteration:** brute force over every local light, per cell.
-- **Default output, the linked list** (`r.Forward.LightLinkedListCulling=1`):
+- **Default output, the linked list:**
   - per hit pair: an `InterlockedAdd` on one global counter, plus an `InterlockedExchange` on the cell's head;
-  - then `LightGridCompactCS`, on the same grid, walks each list, allocates with one global
+  - then a compaction pass, on the same grid, walks each list, allocates with one global
     `InterlockedAdd` (the LDS pre-aggregation is off by default), and writes the list reversed to restore
     list order.
 - **Non-linked mode:** per-cell `InterlockedAdd` into 32 fixed slots.

package/src/shade/renderer/light/cluster/PROPOSAL_HIERARCHICAL_2026_10_16.md

@@ -690,7 +690,7 @@ engine camera are as in round 1, §6.
    - **fine stage:** every cell runs the precise test on its block's survivors, in id order.
 3. **Linked list against count-then-write, same hierarchy (G):**
    - **assignment:** the list's single sweep is 20–31% faster on the 4090 and 25–31% on the iGPU.
-   - **compaction into today's product** (UE's `LightGridCompactCS` shape) costs 9–125 µs on the 4090 and
+   - **compaction into today's product** (UE's light-grid compaction shape) costs 9–125 µs on the 4090 and
      0.4–15 ms on the iGPU.
    - **consumers walking the list directly** pay +8–30% per consumer pass on the 4090 and +6–27% on the
      iGPU (stand-in shading pass).
@@ -1063,7 +1063,7 @@ depends on the device.
 | subgroup allocation | `chunk_vsm_append_mover` |
 | ordered compaction | `chunk_subgroup_active_count_bits` pattern, `workgroupUniformLoad` |
 | tile / block gather (BT) | the structural session's R1 bin step, which is the rejected gather here |
-| compaction | UE 5.4 `LightGridCompactCS` (VERIFIED, round 1 §2.1) |
+| compaction | UE 5.4 light-grid compaction (round 1 §2.1) |
 | decals | `shader_cluster_assign_decals` takes the same fine pass with keep-largest; not built |
 
 ## 6. Forks for Alex

package/src/shade/renderer/light/environment/environment_level_1_blur_plan.d.ts

@@ -0,0 +1,39 @@
+/**
+ * How level 1 of a map of side `map_size` is filtered.
+ *
+ * Level 1's samples are uniform in its cone, so each stands for Ω_s = Ω_cone / N. They read a copy of
+ * level 0 blurred by a Gaussian of σ = 0.7 · max(√Ω_s, the copy's largest texel), wide enough that
+ * neither the samples nor the copy's texels alias. The copy is level 0 averaged down to level 1's
+ * size when that leaves the lobe room for the blur, else level 0's own size.
+ *
+ * The lobe exp(2 (N·H - 1) / r^4) is a Gaussian of variance 2 r^4 an axis (N·H = cos(θ/2)), and
+ * Gaussians add variances, so it is narrowed by what the copy adds: the blur, and the bilinear tent
+ * across the copy's texels beyond the one across level 0's. It narrows to the minimum roughness when
+ * the map's texels are coarser than the lobe itself, and level 1 is then the blur alone.
+ *
+ * @param {number} map_size side of the map's level 0
+ * @returns {{
+ *   blurred_size: number,
+ *   average_first: boolean,
+ *   sigma: number,
+ *   radius: number,
+ *   lobe_roughness: number,
+ * }} `average_first`: the copy is level 0 averaged to level 1's size before the blur; `sigma` the
+ * blur still to apply (radians), past what averaging adds; `radius` in the copy's texels
+ */
+export function environment_level_1_blur_plan(map_size: number): {
+    blurred_size: number;
+    average_first: boolean;
+    sigma: number;
+    radius: number;
+    lobe_roughness: number;
+};
+/**
+ * Samples per texel of level 1. They read a Gaussian-blurred copy of level 0, so the count sets how
+ * fine that blur can be and how much of the lobe is the lobe's own. Measured on a 1024 map against
+ * level 1 from 8192 point taps (sun lobe 1.315° rms): 64 → sky rms error 0.092, sun 1.345°, a bright
+ * texel's share 0.998 ± 0.008; 128 → 0.057, 1.342°, 0.998 ± 0.003, never above 1.
+ * @type {number}
+ */
+export const LEVEL_1_SAMPLE_COUNT: number;
+//# sourceMappingURL=environment_level_1_blur_plan.d.ts.map

package/src/shade/renderer/light/environment/environment_level_1_blur_plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment_level_1_blur_plan.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/environment_level_1_blur_plan.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wDAVW,MAAM,GACJ;IACZ,YAAgB,EAAE,MAAM,CAAC;IACzB,aAAiB,EAAE,OAAO,CAAC;IAC3B,KAAS,EAAE,MAAM,CAAC;IAClB,MAAU,EAAE,MAAM,CAAC;IACnB,cAAkB,EAAE,MAAM,CAAC;CACxB,CAmDH;AAjHD;;;;;;GAMG;AACH,mCAFU,MAAM,CAEwB"}