@woosh/meep-engine 3.60.3 → 3.60.5

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

@@ -1,16 +1,11 @@
 import { GPU_DATABASE_NULL } from "../../../buffer/table/GPU_DATABASE_NULL.js";
 import { chunk_mesh_card_surface } from "../../../geometry/sdf/cards/chunk_mesh_card_surface.js";
 import { MESH_CARD_ROWS_RESOURCE } from "../../../geometry/sdf/cards/MESH_CARD_RESOURCES.js";
-import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../../../material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
 import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
 import { SCENE_DATABASE_RESOURCE } from "../../../scene/SCENE_DATABASE_RESOURCE.js";
 import { chunk_mat4_inverse } from "../../../shader/chunk/geometry/mat4/chunk_mat4_inverse.js";
 import { chunk_mat4_linear_determinant } from "../../../shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js";
-import { chunk_albedo_unpremultiply } from "../../../shader/chunk/material/chunk_albedo_unpremultiply.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
-import { vec4f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 
 /**
  * The tolerance a card's depth is held to at a GI hit, in voxels of the hit's brick cascade: a hit is
@@ -20,18 +15,6 @@ import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
  */
 export const PROBE_HIT_SURFACE_TOLERANCE_VOXELS = 1.5;
 
-/**
- * The resident materials' table, as the ray passes read it: `materials[mesh.material]`.
- * @type {ShaderResourceDescriptor}
- */
-export const PROBE_HIT_MATERIALS_RESOURCE = ShaderResourceDescriptor.uniform("materials", INDIRECT_MATERIAL_ARRAY_TYPE);
-
-/**
- * Each resident texture slot's mean, `GPUResidentMaterialContext.buffer_texture_means`.
- * @type {ShaderResourceDescriptor}
- */
-export const PROBE_HIT_TEXTURE_MEANS_RESOURCE = ShaderResourceDescriptor.storageBuffer("texture_means", WebGPUArray.from(vec4f));
-
 /**
  * What a GI hit's surface is (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6), its diffuse albedo and its
  * emissive, from the `meshes` row the hit is on:
@@ -44,10 +27,11 @@ export const PROBE_HIT_TEXTURE_MEANS_RESOURCE = ShaderResourceDescriptor.storage
  *   the geometry's local space through its node, the normal by the transpose of the node's linear
  *   part, and the tolerance {@link PROBE_HIT_SURFACE_TOLERANCE_VOXELS} voxels of the hit's cascade,
  *   `voxel`, in local units by the transform's mean scale, the cube root of its determinant.
- * - **The material's mean**, where no card set is resident or no card sees the hit: the colour factor
- *   × the albedo slot's mean colour × (1 − the metallic factor × the ORM slot's mean metalness), and the
- *   emissive factor × the emissive slot's mean. What a card would have held, Lumen's diffuse colour,
- *   from the means of what it is made of.
+ * - **Black**, where no card set is resident or no card sees the hit, as UE's Lumen leaves a hit no
+ *   card covers: a surface whose albedo is not known brings back no light rather than light it may not
+ *   have. The cost is energy, never invented energy: a material's colour factor is all of a flat one's
+ *   albedo but only the bound of a textured one's, and in Sponza it made the bounce-lit gallery 60%
+ *   brighter on screen (§6.6).
  * - **Row 0** names no object, the scene root never being a mesh: the hit is black.
  *
  * @type {CodeChunk}
@@ -67,11 +51,10 @@ fn probe_clipmap_hit_surface(row: u32, position: vec3<f32>, normal: vec3<f32>, v
         return out;
     }
 
-    let mesh = scene_read_mesh(&scene_database, row);
     let card_set = mesh_card_rows[row];
 
     if (card_set != ${GPU_DATABASE_NULL}u) {
-        let global = scene_read_node(&scene_database, mesh.node).global;
+        let global = scene_read_node(&scene_database, scene_read_mesh(&scene_database, row).node).global;
         let linear = mat3x3<f32>(global[0].xyz, global[1].xyz, global[2].xyz);
 
         let p = (mat4_inverse(global) * vec4<f32>(position, 1.0)).xyz;
@@ -83,28 +66,17 @@ fn probe_clipmap_hit_surface(row: u32, position: vec3<f32>, normal: vec3<f32>, v
         if (seen.found) {
             out.albedo = seen.albedo;
             out.emissive = seen.emissive;
-
-            return out;
         }
     }
 
-    let material = materials[mesh.material];
-    let metalness = material.metallic_factor * texture_means[material.texture_orm].b;
-
-    out.albedo = albedo_unpremultiply(texture_means[material.texture_albedo]) * material.color_albedo.rgb * (1.0 - metalness);
-    out.emissive = texture_means[material.texture_emissive].rgb * material.emissive_factor;
-
     return out;
 }
 `, [
         chunk_scene_database_access,
         chunk_mat4_inverse,
         chunk_mat4_linear_determinant,
-        chunk_albedo_unpremultiply,
         chunk_mesh_card_surface,
     ]);
 
 chunk_probe_clipmap_hit_surface.requireResource(SCENE_DATABASE_RESOURCE);
 chunk_probe_clipmap_hit_surface.requireResource(MESH_CARD_ROWS_RESOURCE);
-chunk_probe_clipmap_hit_surface.requireResource(PROBE_HIT_MATERIALS_RESOURCE);
-chunk_probe_clipmap_hit_surface.requireResource(PROBE_HIT_TEXTURE_MEANS_RESOURCE);

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/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":"AA2DA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yCAFU,aAAa,CAyDpB;8BAxH2B,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":"AAqDA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yCAFU,aAAa,CAyDpB;8BAlH2B,kCAAkC"}

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

@@ -19,11 +19,7 @@ import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { BRICK_TRACE_HIT, BRICK_TRACE_MISS } from "../brick/BRICK_CLIPMAP.js";
 import { BRICK_LEVELS_RESOURCE } from "../brick/chunk_brick_clipmap_trace.js";
-import {
-    chunk_probe_clipmap_hit_surface,
-    PROBE_HIT_MATERIALS_RESOURCE,
-    PROBE_HIT_TEXTURE_MEANS_RESOURCE
-} from "./chunk_probe_clipmap_hit_surface.js";
+import { chunk_probe_clipmap_hit_surface } from "./chunk_probe_clipmap_hit_surface.js";
 import {
     chunk_probe_clipmap,
     chunk_probe_clipmap_ray_origin,
@@ -49,8 +45,6 @@ resources.createGroup()
 resources.createGroup()
     .add(SCENE_DATABASE_RESOURCE)
     .add(MESH_CARD_ROWS_RESOURCE)
-    .add(PROBE_HIT_MATERIALS_RESOURCE)
-    .add(PROBE_HIT_TEXTURE_MEANS_RESOURCE)
     .add(MESH_SDF_HEADERS_RESOURCE)
     .add(MESH_SDF_INDIRECTION_RESOURCE)
     .add(MESH_CARD_SETS_RESOURCE)

package/src/shade/renderer/hiz/HZBFootprint.d.ts

@@ -0,0 +1,14 @@
+/**
+ * How many source texels, along one axis, the mip 0 reduction reads per HZB texel: the widest footprint
+ * any HZB texel of the dispatch has on that axis ({@link hzb_footprint_texels }). Narrower footprints in
+ * the same dispatch read their last texel again.
+ *
+ * Two when the axis halves exactly, three when mip 0 is padded past half the source, which the HZB's
+ * sizing caps at three ({@link HierarchicalZBuffersetViewportSize }).
+ */
+export type HZBFootprint = number;
+export namespace HZBFootprint {
+    let Two: number;
+    let Three: number;
+}
+//# sourceMappingURL=HZBFootprint.d.ts.map

package/src/shade/renderer/hiz/HZBFootprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HZBFootprint.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/HZBFootprint.js"],"names":[],"mappings":";;;;;;;;2BAQU,MAAM"}

package/src/shade/renderer/hiz/HZBFootprint.js

@@ -0,0 +1,16 @@
+/**
+ * How many source texels, along one axis, the mip 0 reduction reads per HZB texel: the widest footprint
+ * any HZB texel of the dispatch has on that axis ({@link hzb_footprint_texels}). Narrower footprints in
+ * the same dispatch read their last texel again.
+ *
+ * Two when the axis halves exactly, three when mip 0 is padded past half the source, which the HZB's
+ * sizing caps at three ({@link HierarchicalZBuffer#setViewportSize}).
+ *
+ * @enum {number}
+ */
+export const HZBFootprint = {
+    /** Two texels: the source is exactly twice the HZB's mip 0 on this axis. */
+    Two: 0,
+    /** Three texels: the HZB's mip 0 is padded past half the source on this axis. */
+    Three: 1,
+};

package/src/shade/renderer/hiz/HZB_FOOTPRINT_X.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The mip 0 reduction's footprint across x — decided by {@link chunk_hzb_footprint_x}.
+ *
+ * `HierarchicalZBuffer` sets it from the viewport and its mip 0 width, each time the viewport changes.
+ *
+ * @type {ShaderSwitch}
+ */
+export const HZB_FOOTPRINT_X: ShaderSwitch;
+import { ShaderSwitch } from "../shader/compiler/ShaderSwitch.js";
+//# sourceMappingURL=HZB_FOOTPRINT_X.d.ts.map