@woosh/meep-engine 3.60.3 → 3.60.4

package/src/shade/renderer/global_illumination/probe_clipmap/PROBE_CLIPMAP_PROPOSAL_2026_10_27.md

@@ -436,8 +436,7 @@ the SDF [49:08].
 
 ### 2.2 UE 5.4 Global Distance Field
 
-From the local source (`H:/Program Files/Epic Games/UE_5.4/Engine`). The production reference for
-the brick clipmap.
+The production reference for the brick clipmap.
 
 **Clipmaps**
 - 4 clipmaps (up to 6) of 252 voxels a side, i.e. 36 pages × 7 voxels.
@@ -473,10 +472,9 @@ objects, with a minimum object radius of max(20 cm, ½ voxel).
 
 ### 2.3 UE 5.4 mesh distance fields, composition, and Lumen's surface cache
 
-From the local source. The production reference for §6 and §7.7. Paths are under `Engine/`.
+The production reference for §6 and §7.7.
 
-**Mesh distance fields** (`Source/Runtime/Engine/Public/DistanceFieldAtlas.h`,
-`Source/Developer/MeshUtilities/Private/MeshDistanceFieldUtilities.cpp`)
+**Mesh distance fields**
 - Bricks of 8³ texels with 7 unique on the corner lattice, `G8`, a band of 4, and 3 mips. An empty
   brick is `0xFFFFFFFF` and reads +band.
 - Resolution: 0.2 voxels a centimetre (5 cm) × a per-mesh scale. Mip 0 is capped at 128 voxels a
@@ -489,12 +487,10 @@ From the local source. The production reference for §6 and §7.7. Paths are und
   - Rays are traced only where the unsigned distance is inside the band.
   - There are 98 of them (a 7×7 stratified hemisphere and its mirror), each one band long.
   - The voxel is inside when more than 25% hit back faces. Two-sided triangles never count.
-- Translucent sections, and primitives with `bAffectDistanceFieldLighting` off, are left out: the
+- Translucent sections, and primitives with distance-field lighting disabled, are left out: the
   precedent for the membership bit (D25).
 
-**Composition** (`Source/Runtime/Renderer/Private/GlobalDistanceField.cpp`,
-`Shaders/Private/DistanceField/GlobalDistanceFieldCompositeObjects.usf`,
-`Shaders/Private/MeshDistanceFieldCommon.ush`)
+**Composition**
 - Objects are culled to the clipmap, then to tiles of 4³ pages, then to each page's 4³-voxel tile in
   LDS, 511 a pass. The passes loop, so there is no hard cap.
 - Per object:
@@ -507,8 +503,7 @@ From the local source. The production reference for §6 and §7.7. Paths are und
   3 inside clipmap 1's box, 2 inside clipmap 3's, 1 elsewhere.
 - Mostly-static and movable layers are merged by a minimum: the static/dynamic category E4 refuses.
 
-**The object grid** (`Shaders/Private/DistanceField/GlobalDistanceFieldObjectGrid.ush`,
-`Shaders/Private/Lumen/LumenSoftwareRayTracing.ush`)
+**The object grid**
 - Layout: a page has 4³ cells. Each cell holds the 4 nearest objects as a `uint4`: a 24-bit instance
   index and an 8-bit distance. That is 1 KiB a page.
 - It is filled by its own pass, one thread per cell.
@@ -517,23 +512,22 @@ From the local source. The production reference for §6 and §7.7. Paths are und
   - each entry's mesh cards are sampled in turn, until the summed weight reaches 0.9 or an entry is
     empty.
 
-**Mesh cards** (`Source/Developer/MeshUtilities/Private/MeshCardRepresentationUtilities.cpp`)
+**Mesh cards**
 - Cards are axis-aligned in mesh space, six directions.
 - Surfels:
   - Per column of a 10 cm grid, 32 jittered rays march through successive hits.
-  - A hit is kept if it faces the card and follows an empty cell. Its "MinRayZ" is the layer after
+  - A hit is kept if it faces the card and follows an empty cell. Its minimum ray Z is the layer after
     the previous hit.
 - Clustering, per direction:
   - first the outer projection (near plane 0);
   - then, greedily, the near plane that best covers the unassigned surfels. A near plane N sees a
-    surfel at layer Z when MinRayZ ≤ N ≤ Z.
+    surfel at layer Z when its minimum ray Z ≤ N ≤ Z.
   - This is how concave meshes get interior cards.
 - The weakest clusters are dropped down to 12 cards a mesh (32 at most; the runtime lookup is a
   32-bit mask per direction).
 - A mesh with no card has no fallback.
 
-**The surface cache** (`Source/Runtime/Renderer/Private/Lumen/LumenSurfaceCache.cpp`,
-`LumenSceneRendering.cpp`, `LumenSceneCardCapture.cpp`)
+**The surface cache**
 - Layers: 128² physical pages in a 4096² atlas, holding depth `G16`, diffuse albedo `RGBA8` (stored
   as its square root), opacity, normal, emissive `R11G11B10`, and three lighting layers.
 - Card resolution:
@@ -542,11 +536,11 @@ From the local source. The production reference for §6 and §7.7. Paths are und
   - idle pages kept for 256 frames.
 - Capture:
   - the mesh is rasterised through an ortho camera on the card, at most 300 pages a frame;
-  - a recapture follows a resolution change, an explicit `InvalidateLumenSurfaceCache` on the
+  - a recapture follows a resolution change, an explicit surface-cache invalidation on the
     primitive, or a slow refresh of the oldest pages;
   - a material change is not tracked.
 
-**Sampling at a hit** (`Shaders/Private/Lumen/SurfaceCache/LumenSurfaceCacheSampling.ush`)
+**Sampling at a hit**
 - Cards are selected by the normal's sign per axis, weighted by n², and every card holding the point
   within the bias is blended.
 - Depth test: four depth taps, each weighted by `1 − saturate((|t − depth| − bias)/(¼·bias))` in card
@@ -564,7 +558,7 @@ The production reference for sparse probe allocation.
 - 4 clipmaps of 48³ at 1.04 m (clip 0).
 - The indirection (`R32_UINT`) is cleared and rebuilt every frame: consumers mark the eight probes
   around each sample, and a probe is reused if marked within 8 frames, else freed.
-- 16,384-probe capacity (128² atlas). By the CVar's own description, overflow renders incorrectly.
+- 16,384-probe capacity (128² atlas). Overflow renders incorrectly.
 
 **Probes**
 - 32² equal-area octahedral `R11G11B10F` radiance plus `R16F` hit distance.
@@ -1079,7 +1073,7 @@ geometry, as built in S2 (below). It is UE's surfel clustering (§2.3) at brick
 - The directions are ±X, ±Y, ±Z of local space.
 - Along a direction δ, a column is a line of bricks.
 - A **run start** is an occupied brick at layer z whose predecessor along δ is empty or outside the
-  grid. Its m is the layer after the previous run's end (0 for the first run), which is UE's MinRayZ.
+  grid. Its m is the layer after the previous run's end (0 for the first run).
 - A card (δ, [k₀, k₁)) looks along δ through brick layers k₀ to k₁ − 1.
   - In each column it sees the first surface after layer k₀.
   - It covers a run start (z, m) when m ≤ k₀ ≤ z < k₁: nothing occupied lies between its near face
@@ -1156,7 +1150,7 @@ cards are drawn rather than traced, through the material's own template.
   so the hardware clips to it as the trace's t ≤ depth does. Culling is off: a card sees either side.
 - The fragment stage is the template's `material_surface` and `material_opacity`, with the material's
   one bind group, the G-buffer pass's: its textures, their mips and hardware filtering, at the card
-  texel's footprint, unbiased as UE's card capture leaves `MaterialTextureMipBias` at 0. Coverage is
+  texel's footprint, unbiased (mip bias 0). Coverage is
   drawn as the trace draws it, from a seed fixed per (pair, card, texel); the depth test keeps the
   nearest opaque draw. A template without a surface function is traced.
 - A scatter then moves each page's texels from the pair's cells into its atlas tiles, in the trace's
@@ -3210,11 +3204,106 @@ a per-invocation function instead. Each is tier 2 whole, and no thread's loop ru
   updates)`.
   - The value it hands the store is a half already, so the device's own rounding never applies.
   - The blend moves in expectation however small its step.
-  - UE 5.4's TSR stores its history through `QuantizeForFloatRenderTarget` for the same reason.
 - The emulator's `pack2x16float` rounds to nearest even, so tier 2 sees half the devices' stall, and on
   both sides. `probe_clipmap_accumulate.spec.js` pins convergence from either side at α = 1/64; it was
   red before the change.
 
+**As built (re-sampling, 2026-10-30): Enshrouded's probe reprojection, a step of its own, off by default.**
+Alex asked for it as a prototype he can switch for testing, chasing convergence, blur accepted.
+- **The step**: `probe/shader_probe_clipmap_resample.js`, recorded before accumulate only when
+  `ProbeClipmapSettings.resampling` is on. A thread a radiance texel of each listed probe B, through the texels'
+  command. It traces nothing: it reads the atlases as the last publish left them.
+  - 4 distinct of B's 26 neighbours in its cascade's 3×3×3 (`PROBE_RESAMPLE_NEIGHBOURS`), a start and a stride
+    coprime with 26 from a hash of the slot, the texel and the update count. Over its updates a texel meets
+    all 26.
+  - The point B sees: along the texel's centre at B's mean depth there. A neighbour (ALIVE, its record's cell
+    the point asked for, since the storage wraps) is read toward it, weighed by how well its depth confirms a
+    surface there: s²/(s² + (d − μ)²), s² its depth's variance plus the receiver bias squared.
+  - Two-sided because a neighbour that sees past the point is looking past a point in mid-air, which B's
+    texel puts there where it mixes a near depth with a far one.
+  - Nothing depth cannot confirm: a texel whose depth is at the limit takes nothing, nor is a point at the
+    limit or past it from the neighbour read.
+- **Accumulate** pools a texel's rays with its re-samples, each a ray's worth at a visibility of one, through
+  the `PROBE_CLIPMAP_RESAMPLING` switch (`probe/chunk_probe_clipmap_resampled.js`): off, its WGSL is what it
+  was. Only a texel some ray reached takes them.
+- **Measured on Sponza, both GPUs (`scratchpad/device/resample.js`, 2026-10-30)**: settle at one end, cut the
+  camera to the other, where the finest probes are new. The eight-corner diffuse in 8×8 blocks each frame,
+  against a reference of four times the rays without re-sampling. 3 runs an arm; mean error, [range]:
+
+  | frames after the cut | 4090 off | 4090 on | iGPU off | iGPU on |
+  |---|---|---|---|---|
+  | 1–10 | 0.140 [0.106–0.181] | 0.158 [0.139–0.174] | 0.119 [0.100–0.129] | 0.132 [0.113–0.158] |
+  | 11–30 | 0.090 | 0.105 | 0.089 | 0.101 |
+  | 31–120 | 0.055 | 0.073 | 0.058 | 0.067 |
+  | 121–480 | 0.038 | 0.080 | 0.039 | 0.069 |
+  | 481–1200 | 0.037 | 0.094 | 0.030 | 0.081 |
+  | first frame under 5% | 53–108 | never | 71–101 | never |
+
+  - Worse in every window on both GPUs, and growing: the re-samples are the neighbours' histories, which hold
+    the re-samples they took, so the field settles on a fixed point of its own and drifts toward it. Against its
+    own settled frame, re-sampling converges no faster either (4 and 3 runs: 4090 31–120 frames 0.087 against
+    0.060; 481–1200, 0.022 against 0.026).
+  - Settled: frame-to-frame change 0.0064 against 0.0069; the mean +4.7% (4090) and +3.3% (iGPU) over the
+    reference, against +2.0% and +0.4% off; |diff| 9.3% and 7.8% against 3.6% and 2.3%.
+  - Taking what depth cannot confirm made it worse: one-sided Chebyshev, with B's far texels read along their
+    own direction and points past the limit at the limit alone, came out +11.5% on the 4090; two-sided, +9.8%;
+    without the points past the limit, +6.5%; without either, +3.2% in its first run.
+  - The sun doubled once settled: 90% of the step in 182–288 frames on the 4090 against 190–260; on the iGPU
+    280–335 against 192–261.
+  - Cost, the arms alternating frame by frame in one process: the pass 18.4 µs on the 4090 (the update's trace
+    ~0.9 ms), 1.03 ms on the AMD iGPU (its trace 4.9 ms); accumulate unchanged on both.
+- Tier 2: `probe_clipmap_resample.spec.js` (the picks, every neighbour met, the weight both ways and with the
+  neighbour's spread, the read direction, nothing unconfirmed, the wrap, the kinds, a texel no ray reached),
+  `probe_clipmap_accumulate.spec.js` (the pool, the switch off, a texel no ray reached); 12 of 12 mutants of the
+  pass killed, 3 of 3 of the pool. Tier 3: `GPUProbeClipmap.spec.js` (recorded only when on, before accumulate,
+  through the texels' command).
+
+**As built (re-sampling confidence, 2026-10-30): a re-sample weighs what it reads.** Alex asked for the
+neighbour's estimator spread, its sample count and its age.
+- **Confidence**: σ²_B / (σ²_B + σ²_A / n_A). σ²_A is the deviation of the neighbour's texel the point falls in
+  (`probe_estimators`, luma), n_A that texel's count (the radiance alpha), so σ²_A / n_A is the variance of its
+  mean; σ²_B is the variance of one of B's own rays, from B's texel. Both absolute, floored at 1e-5, so a dark
+  neighbour is not doubted for being dark. A neighbour no noisier than one of B's rays counts as one; one whose
+  mean is as noisy as a ray, as half.
+- **Freshness**: e^(−age / `response_frames`), age the frames since the neighbour's `traced_frame`.
+- Still at most a ray's worth: visibility × confidence × freshness.
+- **No solid angle.** Rays are jittered over their texel's octahedral square and averaged unweighted; the
+  solid angle enters at the projection, per texel. A re-sample is one tap along B's texel centre, and the
+  neighbour's bilinear tap averages its own texel's footprint, which is not B's. Neither is corrected.
+- **Measured** (`scratchpad/device/ab/`, 2026-10-30): plain is the pass of the block above, confidence this
+  one, against references of four times the rays without re-sampling taken that day. 4090 3 runs an arm, iGPU 2;
+  mean [range]. Stability settles 1,500 frames, TAA off: |Δ| frame to frame over the frame's mean, the same pixel
+  still, the reprojected point on an orbit; probe texels |Δ| between two reads of a probe updated between them.
+
+  | | 4090 off | plain | confidence | iGPU off | plain | confidence |
+  |---|---|---|---|---|---|---|
+  | still, eight corners | 0.0506 | 0.0476 | 0.0481 | 0.0506 | 0.0474 | 0.0482 |
+  | still, pick | 0.144 | 0.130 | 0.131 | 0.144 | 0.131 | 0.132 |
+  | orbit, eight corners | 0.111 | 0.076 | 0.090 [0.084–0.096] | 0.110 | 0.075 | 0.083 |
+  | orbit, pick | 0.237 | 0.152 | 0.201 [0.180–0.215] | 0.238 | 0.151 | 0.176 |
+  | probe texels an update | 0.019 | 0.023 | 0.022 | 0.020 | 0.033 | 0.027 |
+  | vs reference, 31–120 | 0.082 | 0.073 | 0.098 | 0.056 | 0.070 | 0.078 |
+  | vs reference, 121–480 | 0.046 | 0.064 | 0.066 | 0.032 | 0.079 | 0.061 |
+  | vs reference, 481–1200 | 0.030 | 0.069 | 0.053 | 0.029 | 0.084 | 0.055 |
+  | first frame under 5% | 197–282 | never | 455–888 | 32–117 | never | 465–494 |
+  | vs own settled, 31–120 | 0.070 | 0.071 | 0.087 | 0.055 | 0.065 | 0.073 |
+  | vs own settled, 121–480 | 0.035 | 0.036 | 0.049 | 0.031 | 0.028 | 0.046 |
+  | settled mean vs reference | −0.9% | +2.2% | −0.7% | +0.6% | +3.2% | +0.5% |
+  | sun ×2, 90% (frames) | 234–255 | 245–287 | 237–263 | 220–229 | 224–251 | 216–218 |
+  | the pass (µs) | | 18.4 | 34.1 | | 905 | 1,484 |
+
+  - Confidence takes the bias out: the settled mean is off's on both GPUs. The per-pixel error stays above
+    off's, so what is left is spatial, the blur.
+  - Re-sampling is quieter in every arm, most on an orbit: plain −31% at the eight corners, −36% at the pick;
+    confidence keeps about half of that. Still, −5% to −10% in both.
+  - It converges no faster in any arm, toward the reference or toward its own settled frame; confidence is the
+    slowest of the three toward its own. A probe's texels move more an update with re-sampling.
+  - Confidence doubles the pass.
+- Tier 2 adds to `probe_clipmap_resample.spec.js`: the confidence (a count of 4 and of 1, a dark neighbour,
+  the floor, the floor against a deviation above it), the freshness at two ages, the spread read from the
+  neighbour's texel the point falls in. Every mutant of the terms killed. Tier 3: the pass's frame and
+  response immediates, the estimators bound.
+
 ## 9. Sampling
 
 ### 9.1 The pick: `probe_clipmap_pick(position, normal, view_direction, ξ) -> pick`
@@ -4062,7 +4151,7 @@ Each says what would reverse it.
   geometry.**
   - Six bounds cards would miss every interior surface of a single-mesh room or atrium.
   - UE places its near planes from 10 cm surfels with 32 rays a column. The brick occupancy the bake
-    already holds gives the same rule (MinRayZ ≤ N ≤ Z) at 7-voxel granularity, with no rays.
+    already holds gives the same rule (m ≤ N ≤ Z) at 7-voxel granularity, with no rays.
   - *Reverse:* if coverage measures short on real assets, then surfels from the capture rays.
 - **D24. Card texels are two `rgba8unorm` planes, 8 B in all.**
   - Diffuse albedo is stored as its square root, as UE stores it.
@@ -4073,7 +4162,7 @@ Each says what would reverse it.
   - *Reverse:* an emissive that measures banded; then `rgba16float` for that plane, 4 B more a texel.
 - **D25. SDF membership is a `ShadedGeometryFlags` bit, on by default, mirrored into the row.**
   - It is the entity's data, carried as `Skinned` is, and transparent materials stay out by rule.
-  - UE's `bAffectDistanceFieldLighting` is the same switch, and UE leaves translucent sections out
+  - UE has a per-primitive distance-field lighting switch and leaves translucent sections out
     too.
 - **D26. A cascade samples the coarsest mesh level no coarser than itself.**
   - Its voxel is within a factor of two of the cascade's, and its band reaches at least half the
@@ -4089,7 +4178,7 @@ Each says what would reverse it.
   - It is the change signal every material consumer already uses, and the repack is the one place it
     is read. Nothing polls.
   - UE tracks no material change at all; there a primitive is recaptured on an explicit
-    `InvalidateLumenSurfaceCache` or by the slow refresh of its oldest pages (§2.3).
+    surface-cache invalidation or by the slow refresh of its oldest pages (§2.3).
   - *Reverse:* none foreseen.
 - **D30. Each passing card gives one texel, blended across cards by n².**
   - UE also blends four depth-weighted taps per card.
@@ -4172,7 +4261,9 @@ Each item is added only if a measurement asks for it, or, where marked, when Ale
   one.
 - **Caches persisted across sessions**, an offline bake format.
 - Ray and history reprojection between probes, if long-range propagation into enclosed spaces
-  measures short.
+  measures short. History re-sampling is built as a switch, off, and measured quieter but no faster to
+  converge; weighed by the neighbour's confidence and age it is unbiased, blurred, and slower still (§8.8, as
+  built 2026-10-30); reprojecting the frame's own rays is not built.
 - Foliage and translucency in the field, Enshrouded's open problem too.
   - Alpha-tested geometry is in the SDF as its triangles, so canopies over-occlude. The `SDFWorld`
     bit is the authored way out.
@@ -4186,18 +4277,8 @@ Each item is added only if a measurement asks for it, or, where marked, when Ale
 
 - J. Kolesik, *Realtime Global Illumination in Enshrouded*, GPC 2024 —
   https://www.youtube.com/watch?v=57F1ezwH7Mk
-- Unreal Engine 5.4 source, under `Engine/`:
-  - the global field: `Source/Runtime/Renderer/Private/GlobalDistanceField.cpp`,
-    `Shaders/Private/DistanceField/GlobalDistanceField*.usf/.ush`, `GlobalDistanceFieldObjectGrid.ush`;
-  - mesh distance fields: `Source/Runtime/Engine/Public/DistanceFieldAtlas.h`,
-    `Source/Developer/MeshUtilities/Private/MeshDistanceFieldUtilities.cpp`,
-    `Shaders/Private/MeshDistanceFieldCommon.ush`, `Shaders/Private/DistanceFieldLightingShared.ush`;
-  - mesh cards and the surface cache: `Source/Developer/MeshUtilities/Private/MeshCardRepresentationUtilities.cpp`,
-    `Source/Runtime/Renderer/Private/Lumen/LumenSurfaceCache.cpp`, `LumenSceneRendering.cpp`,
-    `LumenSceneCardCapture.cpp`, `Shaders/Private/Lumen/SurfaceCache/LumenSurfaceCacheSampling.ush`,
-    `Shaders/Private/Lumen/LumenSoftwareRayTracing.ush`;
-  - the radiance cache: `Source/Runtime/Renderer/Private/Lumen/LumenRadianceCache*.cpp`,
-    `Shaders/Private/Lumen/LumenRadianceCache*.usf/.ush`.
+- Unreal Engine 5.4 Lumen and Global Distance Field documentation:
+  https://dev.epicgames.com/documentation/en-us/unreal-engine/lumen-technical-details-in-unreal-engine
 - Z. Majercik et al., *Dynamic Diffuse Global Illumination with Ray-Traced Irradiance Fields*,
   JCGT 8(2), 2019 — https://jcgt.org/published/0008/02/01/ ; *Scaling Probe-Based Real-Time Dynamic
   Global Illumination for Production*, JCGT 10(2), 2021 — https://jcgt.org/published/0010/02/01/

package/src/shade/renderer/global_illumination/probe_clipmap/PROBE_RAYS_VARIABLE_AND_SORTED_SCOPE_2026_10_30.md

@@ -145,7 +145,7 @@ only helps if the request sees the change, which per-texel inconsistency does no
 - **Consumers:** trace, light and shade take `ray = order[thread]`. Their outputs stay at the ray's
   index, so want_hits, accumulate and projection do not change.
 - **Layout fork, measured in stage 0:**
-  - direction-major: UE's `SortProbeTraceTilesCS` bins 64 directions, with Morton position a todo;
+  - direction-major: binning 64 directions, with Morton position a todo;
   - origin-major: today's grouping by probe, with directions ordered within it;
   - interleaved.
 
@@ -270,7 +270,7 @@ otherwise, the figures are the busy time from relocation to the light pass's end
 **The local sort.** A workgroup takes a chunk of the launch's threads, packs each ray's key above its
 place in the chunk, and sorts them with the radix scatter's stable binary split, a bit a round. The
 rays move only within their chunk. Keyed by the ray's direction bin, as the trace finds its texel:
-8×8 bins of the octahedral map (6 bits, the bins of UE's `SortProbeTraceTilesCS`) or 4×4 (4 bits).
+8×8 bins of the octahedral map (6 bits) or 4×4 (4 bits).
 "Probe order, then" runs the trace-list sort below first. iGPU, Emerald avenue / Sponza:
 
 | Order | 2048-ray chunks | 1024 | 512 |

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.d.ts

@@ -274,6 +274,18 @@ export class ProbeClipmapSettings {
      * @returns {number}
      */
     get response_frames(): number;
+    /**
+     * @param {boolean} v
+     */
+    set resampling(v: boolean);
+    /**
+     * Whether each probe update also re-samples its neighbours: every radiance texel takes what four of the
+     * probe's 26 neighbours in its cascade have already seen of the point it sees, where their depth says
+     * they can see it, each a ray's worth beside its own rays. It traces nothing, and buys convergence for
+     * some spatial blur. Off, the update's pass is not recorded. Takes effect the next frame.
+     * @returns {boolean}
+     */
+    get resampling(): boolean;
     /**
      * @param {ProbeClipmapDebugView} v
      */

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProbeClipmapSettings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,gDAFU,cAAc,MAAM,CAAC,CAE8C;AAE7E;;;GAGG;AACH,sDAFU,MAAM,CAEyC;AAEzD;;GAEG;AACH,sDAFU,MAAM,CAE0C;AAE1D;;;GAGG;AACH,mDAFU,MAAM,CAEuC;AAEvD;;;;;GAKG;AACH,sDAFU,MAAM,CAE0C;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH;IAaI;;OAEG;IACH,mCAKC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;OAEG;IACH,wCAIC;IAfD;;;OAGG;IACH,uCAEC;IAuBD;;OAEG;IACH,gCAKC;IAlBD;;;;;OAKG;IACH,+BAEC;IAuBD;;OAEG;IACH,kCAKC;IAjBD;;;;OAIG;IACH,iCAEC;IAwBD;;OAEG;IACH,mCAKC;IAlBD;;;;;OAKG;IACH,kCAEC;IAyBD;;;OAGG;IACH,mCAOC;IAtBD;;;;;;OAMG;IACH,kCAEC;IAqCD;;;OAGG;IACH,oCAKC;IA7BD;;;;;;;;;;;;;;;OAeG;IACH,mCAEC;IA6CD;;;OAGG;IACH,mCAKC;IAvCD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,kCAEC;IAoCD;;OAEG;IACH,iCAIC;IA5BD;;;;;;;;;;;;;;;;OAgBG;IACH,gCAEC;IAsBD;;OAEG;IACH,mCAKC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;OAEG;IACH,wCAIC;IAfD;;;OAGG;IACH,uCAEC;IAuBD;;OAEG;IACH,6BAKC;IAlBD;;;;;OAKG;IACH,4BAEC;IAuBD;;;OAGG;IACH,mCAOC;IApBD;;;;OAIG;IACH,kCAEC;IA0BD;;;OAGG;IACH,gCAOC;IApBD;;;;OAIG;IACH,+BAEC;IA0BD;;;OAGG;IACH,8BAKC;IAlBD;;;;OAIG;IACH,6BAEC;IAyBD;;OAEG;IACH,0BAIC;IAjBD;;;;;OAKG;IACH,yBAEC;IAyBD;;OAEG;IACH,+BAKC;IApBD;;;;;;;OAOG;IACH,8BAEC;IAuBD;;OAEG;IACH,0BAIC;IAhBD;;;;OAIG;IACH,yBAEC;;CAUJ"}
+{"version":3,"file":"ProbeClipmapSettings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,gDAFU,cAAc,MAAM,CAAC,CAE8C;AAE7E;;;GAGG;AACH,sDAFU,MAAM,CAEyC;AAEzD;;GAEG;AACH,sDAFU,MAAM,CAE0C;AAE1D;;;GAGG;AACH,mDAFU,MAAM,CAEuC;AAEvD;;;;;GAKG;AACH,sDAFU,MAAM,CAE0C;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH;IAaI;;OAEG;IACH,mCAKC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;OAEG;IACH,wCAIC;IAfD;;;OAGG;IACH,uCAEC;IAuBD;;OAEG;IACH,gCAKC;IAlBD;;;;;OAKG;IACH,+BAEC;IAuBD;;OAEG;IACH,kCAKC;IAjBD;;;;OAIG;IACH,iCAEC;IAwBD;;OAEG;IACH,mCAKC;IAlBD;;;;;OAKG;IACH,kCAEC;IAyBD;;;OAGG;IACH,mCAOC;IAtBD;;;;;;OAMG;IACH,kCAEC;IAqCD;;;OAGG;IACH,oCAKC;IA7BD;;;;;;;;;;;;;;;OAeG;IACH,mCAEC;IA6CD;;;OAGG;IACH,mCAKC;IAvCD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,kCAEC;IAoCD;;OAEG;IACH,iCAIC;IA5BD;;;;;;;;;;;;;;;;OAgBG;IACH,gCAEC;IAsBD;;OAEG;IACH,mCAKC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;OAEG;IACH,wCAIC;IAfD;;;OAGG;IACH,uCAEC;IAuBD;;OAEG;IACH,6BAKC;IAlBD;;;;;OAKG;IACH,4BAEC;IAuBD;;;OAGG;IACH,mCAOC;IApBD;;;;OAIG;IACH,kCAEC;IA0BD;;;OAGG;IACH,gCAOC;IApBD;;;;OAIG;IACH,+BAEC;IA0BD;;;OAGG;IACH,8BAKC;IAlBD;;;;OAIG;IACH,6BAEC;IAyBD;;OAEG;IACH,0BAIC;IAjBD;;;;;OAKG;IACH,yBAEC;IAyBD;;OAEG;IACH,+BAKC;IApBD;;;;;;;OAOG;IACH,8BAEC;IAyBD;;OAEG;IACH,2BAIC;IAlBD;;;;;;OAMG;IACH,0BAEC;IAsBD;;OAEG;IACH,0BAIC;IAhBD;;;;OAIG;IACH,yBAEC;;CAUJ"}

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js

@@ -477,6 +477,28 @@ export class ProbeClipmapSettings {
         this.#response_frames = v;
     }
 
+    #resampling = false;
+
+    /**
+     * Whether each probe update also re-samples its neighbours: every radiance texel takes what four of the
+     * probe's 26 neighbours in its cascade have already seen of the point it sees, where their depth says
+     * they can see it, each a ray's worth beside its own rays. It traces nothing, and buys convergence for
+     * some spatial blur. Off, the update's pass is not recorded. Takes effect the next frame.
+     * @returns {boolean}
+     */
+    get resampling() {
+        return this.#resampling;
+    }
+
+    /**
+     * @param {boolean} v
+     */
+    set resampling(v) {
+        assert.isBoolean(v, 'resampling');
+
+        this.#resampling = v;
+    }
+
     #debug_view = ProbeClipmapDebugView.None;
 
     /**

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

@@ -159,8 +159,10 @@ export class GPUProbeClipmap {
      * @param {import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} options.materials
      *   the resident materials, updated this frame: what a hit no card sees takes
      * @param {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
+     * @param {boolean} options.resampling whether each update re-samples its neighbours, adding what they have
+     *   seen to its rays (`shader_probe_clipmap_resample`)
      */
-    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows }: {
+    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows, resampling }: {
         graph: FrameGraph;
         x: number;
         y: number;
@@ -178,6 +180,7 @@ export class GPUProbeClipmap {
         scene: import("../../../scene/GPUSceneContext.js").GPUSceneContext;
         materials: import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
         card_rows: GPUBuffer;
+        resampling: boolean;
     }): void;
     destroy(): void;
     #private;

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

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AAiHA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IA4NI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QACU,gBAAgB,EAAhC,MAAM;OAmGhB;IArUD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAuSjB;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;QAtB+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACa,MAAM;QACd,IAAI;QACY,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAE4C,SAAS,EAAhH,OAAO,0DAA0D,EAAE,0BAA0B;QAE1E,SAAS;aAoOtC;IAydD,gBAcC;;CACJ;mCA1sCY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU"}
+{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AAoHA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IAwOI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QACU,gBAAgB,EAAhC,MAAM;OAmGhB;IAjVD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAmTjB;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH;QAxB+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACa,MAAM;QACd,IAAI;QACY,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAE4C,SAAS,EAAhH,OAAO,0DAA0D,EAAE,0BAA0B;QAE1E,SAAS;QACX,UAAU,EAA3B,OAAO;aAiPjB;IA0eD,gBAcC;;CACJ;mCArvCY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU"}

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

@@ -16,6 +16,7 @@ import {
 } from "../../../gpu_primitive/slot_stack/shader_slot_stack_push_range.js";
 import { CLIPMAP_LEVEL_ARRAY, CLIPMAP_LEVEL_STRUCT } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
+import { ShaderSwitchSet } from "../../../shader/compiler/ShaderSwitchSet.js";
 import { GPUTileAtlas2D } from "../../../texture/atlas/GPUTileAtlas2D.js";
 import {
     PROBE_CLIPMAP_CASCADE_COUNT_MAX,
@@ -60,6 +61,7 @@ import {
 import { shader_probe_clipmap_project, shader_probe_clipmap_project_rows } from "./shader_probe_clipmap_project.js";
 import { shader_probe_clipmap_publish } from "./shader_probe_clipmap_publish.js";
 import { shader_probe_clipmap_relocate } from "./shader_probe_clipmap_relocate.js";
+import { shader_probe_clipmap_resample } from "./shader_probe_clipmap_resample.js";
 import { shader_probe_clipmap_retire } from "./shader_probe_clipmap_retire.js";
 import { shader_probe_clipmap_schedule } from "./shader_probe_clipmap_schedule.js";
 import { shader_probe_clipmap_light } from "./shader_probe_clipmap_light.js";
@@ -74,6 +76,7 @@ import { shader_probe_clipmap_order } from "./shader_probe_clipmap_order.js";
 import { shader_probe_clipmap_trace_command } from "./shader_probe_clipmap_trace_command.js";
 import { shader_probe_clipmap_want } from "./shader_probe_clipmap_want.js";
 import { shader_probe_clipmap_want_hits } from "./shader_probe_clipmap_want_hits.js";
+import { PROBE_CLIPMAP_RESAMPLING } from "./PROBE_CLIPMAP_RESAMPLING.js";
 
 /**
  * @typedef {import("../ProbeClipmapSettings.js").ProbeClipmapSettings} ProbeClipmapSettings
@@ -251,6 +254,17 @@ export class GPUProbeClipmap {
     /** The listed probes' guides, as the guide passes write them, as many as the trace list holds. @type {GPUBuffer|null} */
     #guide = null;
 
+    /**
+     * The listed probes' re-samples of their neighbours, n_r² a probe, as the re-sample pass writes them, as many
+     * as the trace list holds. Kept whether or not the frame re-samples: accumulate's variants share their
+     * resources. @type {GPUBuffer|null}
+     */
+    #resamples = null;
+
+    /** Whether the frame's updates re-sample their neighbours, and the switches accumulate is recorded with. */
+    #resampling = false;
+    #accumulate_switches = ShaderSwitchSet.EMPTY;
+
     /** The listed probes' projected rows, n_r a probe, as many as the trace list holds. @type {GPUBuffer|null} */
     #projection = null;
 
@@ -340,6 +354,7 @@ export class GPUProbeClipmap {
     #accumulate_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, depth_tiles_per_row: 0, frame: 0, response_frames: 0, uniform_period: PROBE_UNIFORM_PERIOD };
     #project_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, frame: 0, uniform_period: PROBE_UNIFORM_PERIOD, rays_min: 0, rays_max: 0, response_frames: 0 };
     #publish_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, depth_tiles_per_row: 0 };
+    #resample_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, frame: 0, response_frames: 0 };
     #push_settings = { first: 0, count: 0, counter: PROBE_COUNTER_FREE };
 
     #bindings = {};
@@ -587,8 +602,10 @@ export class GPUProbeClipmap {
      * @param {import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} options.materials
      *   the resident materials, updated this frame: what a hit no card sees takes
      * @param {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
+     * @param {boolean} options.resampling whether each update re-samples its neighbours, adding what they have
+     *   seen to its rays (`shader_probe_clipmap_resample`)
      */
-    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows }) {
+    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows, resampling }) {
         assert.defined(graph, 'graph');
         assert.defined(camera, 'camera');
         assert.defined(stbn, 'stbn');
@@ -601,6 +618,7 @@ export class GPUProbeClipmap {
         assert.defined(scene, 'scene');
         assert.defined(materials, 'materials');
         assert.defined(card_rows, 'card_rows');
+        assert.isBoolean(resampling, 'resampling');
         assert.notOk(this.#destroyed, 'destroyed');
 
         if (this.#grow_pending) {
@@ -733,6 +751,17 @@ export class GPUProbeClipmap {
         this.#project_settings.rays_max = rays_max;
         this.#project_settings.response_frames = response_frames;
 
+        const resample = this.#resample_settings;
+
+        resample.trace_capacity = trace_capacity;
+        resample.radiance_resolution = this.radiance_resolution;
+        resample.depth_resolution = this.depth_resolution;
+        resample.frame = this.#frame;
+        resample.response_frames = response_frames;
+
+        this.#resampling = resampling;
+        this.#accumulate_switches = ShaderSwitchSet.EMPTY.with(PROBE_CLIPMAP_RESAMPLING, resampling);
+
         const publish = this.#publish_settings;
 
         publish.trace_capacity = trace_capacity;
@@ -882,6 +911,7 @@ export class GPUProbeClipmap {
         this.#origins?.destroy();
         this.#maps?.destroy();
         this.#guide?.destroy();
+        this.#resamples?.destroy();
         this.#projection?.destroy();
         this.#ray_counts?.destroy();
         this.#ray_requests?.destroy();
@@ -904,6 +934,7 @@ export class GPUProbeClipmap {
         this.#origins = this.#create_buffer('probe origins', 16 * trace_capacity, 0);
         this.#maps = this.#create_buffer('probe maps', 4 * probe_clipmap_maps_words(this.radiance_resolution, this.depth_resolution) * trace_capacity, 0);
         this.#guide = this.#create_buffer('probe guide', 4 * probe_clipmap_guide_words(this.radiance_resolution) * trace_capacity, 0);
+        this.#resamples = this.#create_buffer('probe resamples', 16 * this.radiance_resolution * this.radiance_resolution * trace_capacity, 0);
         this.#projection = this.#create_buffer('probe projection', PROBE_PROJECTION_ROW_STRUCT.size * this.radiance_resolution * trace_capacity, 0);
     }
 
@@ -1207,6 +1238,22 @@ export class GPUProbeClipmap {
             command_offset: 4 * PROBE_DISPATCH_RAYS,
         });
 
+        // what each listed probe's neighbours have already seen, from the atlases and estimators as they were,
+        // where the frame re-samples; accumulate's variant without it reads none
+        b.probe_resamples = this.#resamples;
+        b.probe_estimators = this.#estimators;
+
+        if (this.#resampling) {
+            b.settings = this.#resample_settings;
+
+            shader_probe_clipmap_resample.dispatchIndirect({
+                encoder,
+                bindings: b,
+                command: this.#dispatch,
+                command_offset: 4 * PROBE_DISPATCH_TEXELS,
+            });
+        }
+
         // the probes' maps from their rays, against the atlases as they were; their SH and kind from the
         // maps; then the atlases from the maps
         b.probe_maps = this.#maps;
@@ -1214,10 +1261,9 @@ export class GPUProbeClipmap {
         b.probe_requests = this.#requests;
         b.probe_radiance = this.#radiance.texture_at(0).obtainView();
         b.probe_depth = this.#depth.texture_at(0).obtainView();
-        b.probe_estimators = this.#estimators;
         b.settings = this.#accumulate_settings;
 
-        shader_probe_clipmap_accumulate.dispatchIndirect({
+        shader_probe_clipmap_accumulate.variant(this.#accumulate_switches).dispatchIndirect({
             encoder,
             bindings: b,
             command: this.#dispatch,
@@ -1298,7 +1344,7 @@ export class GPUProbeClipmap {
         this.#radiance.destroy();
         this.#depth.destroy();
 
-        for (const buffer of [this.#levels, this.#states, this.#estimators, this.#records, this.#free, this.#counters, this.#dispatch, this.#eviction, ...this.#active, this.#wanted, this.#wanted_bits, this.#trace, this.#origins, this.#maps, this.#guide, this.#projection, this.#requests, this.#ray_counts, this.#ray_requests, this.#ray_count_sums, this.#ray_request_sums, this.#ray_sums, this.#ray_scan_spine, this.#ray_scan_command, this.#rays, this.#sampling]) {
+        for (const buffer of [this.#levels, this.#states, this.#estimators, this.#records, this.#free, this.#counters, this.#dispatch, this.#eviction, ...this.#active, this.#wanted, this.#wanted_bits, this.#trace, this.#origins, this.#maps, this.#guide, this.#resamples, this.#projection, this.#requests, this.#ray_counts, this.#ray_requests, this.#ray_count_sums, this.#ray_request_sums, this.#ray_sums, this.#ray_scan_spine, this.#ray_scan_command, this.#rays, this.#sampling]) {
             buffer?.destroy();
         }
     }

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

@@ -361,4 +361,10 @@ export const PROBE_RECEIVER_BIAS: number;
  * @type {number}
  */
 export const PROBE_RECEIVER_BIAS_VIEW: number;
+/**
+ * The neighbours a radiance texel re-samples an update when the frame re-samples (`shader_probe_clipmap_resample`):
+ * distinct ones of the probe's 26 in its cascade's 3×3×3, picked afresh each update. Enshrouded's 4:1.
+ * @type {number}
+ */
+export const PROBE_RESAMPLE_NEIGHBOURS: number;
 //# sourceMappingURL=PROBE_CLIPMAP.d.ts.map

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

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

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

@@ -463,3 +463,10 @@ export const PROBE_RECEIVER_BIAS = 0.1;
  * @type {number}
  */
 export const PROBE_RECEIVER_BIAS_VIEW = 0.2;
+
+/**
+ * The neighbours a radiance texel re-samples an update when the frame re-samples (`shader_probe_clipmap_resample`):
+ * distinct ones of the probe's 26 in its cascade's 3×3×3, picked afresh each update. Enshrouded's 4:1.
+ * @type {number}
+ */
+export const PROBE_RESAMPLE_NEIGHBOURS = 4;

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

@@ -0,0 +1,13 @@
+/**
+ * Whether the frame's updates re-sample their neighbours (`shader_probe_clipmap_resample`): accumulate
+ * then adds each radiance texel's re-samples to its rays (`chunk_probe_clipmap_resampled`). Decided by
+ * `chunk_probe_clipmap_resampled`, whose `false` alternative, the default, is the texel's own rays alone
+ * and binds nothing more, so a pass that never sets it accumulates exactly as it always did.
+ *
+ * `GPUProbeClipmap` sets it from `ProbeClipmapSettings.resampling` the frame it records the update.
+ *
+ * @type {ShaderSwitch}
+ */
+export const PROBE_CLIPMAP_RESAMPLING: ShaderSwitch;
+import { ShaderSwitch } from "../../../shader/compiler/ShaderSwitch.js";
+//# sourceMappingURL=PROBE_CLIPMAP_RESAMPLING.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PROBE_CLIPMAP_RESAMPLING.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP_RESAMPLING.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,uCAFU,YAAY,CAEgE;6BAZzD,0CAA0C"}

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

@@ -0,0 +1,13 @@
+import { ShaderSwitch } from "../../../shader/compiler/ShaderSwitch.js";
+
+/**
+ * Whether the frame's updates re-sample their neighbours (`shader_probe_clipmap_resample`): accumulate
+ * then adds each radiance texel's re-samples to its rays (`chunk_probe_clipmap_resampled`). Decided by
+ * `chunk_probe_clipmap_resampled`, whose `false` alternative, the default, is the texel's own rays alone
+ * and binds nothing more, so a pass that never sets it accumulates exactly as it always did.
+ *
+ * `GPUProbeClipmap` sets it from `ProbeClipmapSettings.resampling` the frame it records the update.
+ *
+ * @type {ShaderSwitch}
+ */
+export const PROBE_CLIPMAP_RESAMPLING = ShaderSwitch.bool('probe clipmap resampling');

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

@@ -224,6 +224,23 @@ export const PROBE_MAPS_READ_RESOURCE: ShaderResourceDescriptor;
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_ESTIMATORS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * The listed probes' re-samples, as accumulation reads them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RESAMPLES_READ_RESOURCE: ShaderResourceDescriptor;
 /**
  * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
  * @type {WebGPUStruct}