@woosh/meep-engine 3.60.6 → 3.60.7

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

@@ -1,6 +1,8 @@
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
 import { chunk_index_to_grid2d } from "../../../shader/chunk/grid/chunk_index_to_grid2d.js";
-import { chunk_texture_octahedral_wrap_texel_coordinates } from "../../../shader/chunk/texture/octahedral/chunk_texture_octahedral_wrap_texel_coordinates.js";
+import {
+    chunk_texture_octahedral_wrap_texel_coordinates
+} from "../../../shader/chunk/texture/octahedral/chunk_texture_octahedral_wrap_texel_coordinates.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -27,6 +29,8 @@ export const PROBE_PUBLISH_SETTINGS = WebGPUStruct.from({
     depth_resolution: u32,
     /** tiles a row of the radiance atlas */
     radiance_tiles_per_row: u32,
+    /** texels of skirt around a radiance tile's map on each side: 1, or 0 for a clipmap whose radiance is never sampled */
+    radiance_skirt: u32,
     /** tiles a row of the depth atlas */
     depth_tiles_per_row: u32,
 }, "ProbePublishSettings");
@@ -43,11 +47,13 @@ resources.createGroup()
 
 /**
  * Publish (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8): a thread a texel of each listed probe's two
- * tiles, the radiance tile's (n_r + 2)² then the depth tile's (n_d + 2)², dispatched through
- * `PROBE_DISPATCH_PUBLISH`. A tile is its map with a one-texel skirt, each skirt texel the interior texel
- * the octahedral fold puts next to it, so a reader's bilinear tap across the edge reads what a wrap would
- * (`texture_octahedral_skirt_uv`). Every texel is written from the probe's maps, which accumulation
- * wrote whole: the atlases are only ever stored into here.
+ * tiles, the radiance tile's (n_r + 2s)² then the depth tile's (n_d + 2)², dispatched through
+ * `PROBE_DISPATCH_PUBLISH`. A tile is its map with a skirt of s texels, one for the depth and
+ * `radiance_skirt` for the radiance, each skirt texel the interior texel the octahedral fold puts next to it,
+ * so a reader's bilinear tap across the edge reads what a wrap would (`texture_octahedral_skirt_uv`). A
+ * clipmap whose radiance is never sampled, only loaded texel by texel, has none there
+ * (WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.8). Every texel is written from the probe's maps, which
+ * accumulation wrote whole: the atlases are only ever stored into here.
  *
  * @type {ComputeShader}
  */
@@ -66,7 +72,9 @@ fn main(
 
     let n = settings.radiance_resolution;
     let m = settings.depth_resolution;
-    let radiance_tile = (n + 2u) * (n + 2u);
+    let skirt = settings.radiance_skirt;
+    let side = n + 2u * skirt;
+    let radiance_tile = side * side;
     let per_probe = radiance_tile + (m + 2u) * (m + 2u);
 
     if (thread >= min(probe_trace.count, settings.trace_capacity) * per_probe) {
@@ -79,12 +87,12 @@ fn main(
     let maps = k * probe_clipmap_maps_words(n, m);
 
     if (i < radiance_tile) {
-        let at = vec2<u32>(i % (n + 2u), i / (n + 2u));
-        let source = texture_octahedral_wrap_texel_coordinates(vec2<i32>(at) - 1, i32(n));
+        let at = vec2<u32>(i % side, i / side);
+        let source = texture_octahedral_wrap_texel_coordinates(vec2<i32>(at) - i32(skirt), i32(n));
         let texel = source.y * n + source.x;
         let value = vec4<f32>(unpack2x16float(probe_maps[maps + 2u * texel]), unpack2x16float(probe_maps[maps + 2u * texel + 1u]));
 
-        textureStore(probe_radiance, index_to_grid2d(slot, settings.radiance_tiles_per_row) * (n + 2u) + at, value);
+        textureStore(probe_radiance, index_to_grid2d(slot, settings.radiance_tiles_per_row) * side + at, value);
 
         return;
     }

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

@@ -7,8 +7,8 @@ export const PROBE_RAY_COUNTS_SETTINGS: WebGPUStruct;
  * `PROBE_DISPATCH_TRACED`, writes the rays its update casts, as two parts whose counts the trace command
  * wrote:
  * - `probe_ray_counts`, what the budget does not scale: a uniform update's R, a NEW probe's among them,
- *   and a DEAD probe's fewest, whose updates are all uniform. A uniform update's map of rays to texels
- *   takes a power of two, and U = ⌊budget / R⌋ makes room for a frame of them.
+ *   and a DEAD probe's `PROBE_DEAD_RAYS`, whose updates are all uniform. A uniform update's map of rays
+ *   to texels takes a power of two, and U = ⌊budget / R⌋ makes room for a frame of them.
  * - `probe_ray_requests`, what it does: a guided update's request, the rays the probe asked for after its
  *   last update (`probe_requests`), at least the fewest.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_ray_layout.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_ray_layout.js"],"names":[],"mappings":"AAuBA;;GAEG;AACH,wCAFU,YAAY,CAaO;AAa7B;;;;;;;;;;;;;GAaG;AACH,8CAFU,aAAa,CAyCpB;AAEH;;GAEG;AACH,wCAFU,YAAY,CAOO;AAW7B;;;;;;;;;GASG;AACH,8CAFU,aAAa,CA+BpB;AAQH;;;;;;GAMG;AACH,+CAFU,aAAa,CA4BpB;6BAtM0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_ray_layout.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_ray_layout.js"],"names":[],"mappings":"AAwBA;;GAEG;AACH,wCAFU,YAAY,CAeO;AAa7B;;;;;;;;;;;;;GAaG;AACH,8CAFU,aAAa,CAyCpB;AAEH;;GAEG;AACH,wCAFU,YAAY,CAOO;AAW7B;;;;;;;;;GASG;AACH,8CAFU,aAAa,CA+BpB;AAQH;;;;;;GAMG;AACH,+CAFU,aAAa,CA6BpB;6BAzM0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -1,4 +1,5 @@
 import { chunk_folded_dispatch } from "../../../gpu_primitive/indirect/chunk_folded_dispatch.js";
+import { chunk_divide_round_up_u32 } from "../../../shader/chunk/math/chunk_divide_round_up_u32.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
@@ -29,8 +30,10 @@ export const PROBE_RAY_COUNTS_SETTINGS = WebGPUStruct.from({
     trace_capacity: u32,
     /** rays a uniform update casts, R */
     rays_per_probe: u32,
-    /** the fewest rays an update casts, a DEAD probe's, `PROBE_RAYS_PER_TEXEL_MIN` of the texels */
+    /** the fewest rays a guided update casts, `PROBE_RAYS_PER_TEXEL_MIN` of the texels */
     rays_min: u32,
+    /** rays a DEAD probe's update casts, `PROBE_DEAD_RAYS` or R where R is fewer */
+    rays_dead: u32,
     /** octahedral radiance texels a side, n_r */
     radiance_resolution: u32,
     /** updates between a probe's uniform ones, `PROBE_UNIFORM_PERIOD` */
@@ -53,8 +56,8 @@ counts_resources.createGroup()
  * `PROBE_DISPATCH_TRACED`, writes the rays its update casts, as two parts whose counts the trace command
  * wrote:
  * - `probe_ray_counts`, what the budget does not scale: a uniform update's R, a NEW probe's among them,
- *   and a DEAD probe's fewest, whose updates are all uniform. A uniform update's map of rays to texels
- *   takes a power of two, and U = ⌊budget / R⌋ makes room for a frame of them.
+ *   and a DEAD probe's `PROBE_DEAD_RAYS`, whose updates are all uniform. A uniform update's map of rays
+ *   to texels takes a power of two, and U = ⌊budget / R⌋ makes room for a frame of them.
  * - `probe_ray_requests`, what it does: a guided update's request, the rays the probe asked for after its
  *   last update (`probe_requests`), at least the fewest.
  *
@@ -87,7 +90,7 @@ fn main(
     var request = 0u;
 
     if (probe_state_kind(state) == PROBE_STATE_DEAD) {
-        fixed = settings.rays_min;
+        fixed = settings.rays_dead;
     } else if (probe_clipmap_guided(state, settings.uniform_period, settings.rays_per_probe, n * n)) {
         fixed = 0u;
         request = max(probe_requests[slot].rays, settings.rays_min);
@@ -192,7 +195,7 @@ fn main() {
         total = probe_ray_sums.elements[listed - 1u];
     }
 
-    let rays = folded_dispatch((total + PROBE_THREAD_WORKGROUP_SIZE - 1u) / PROBE_THREAD_WORKGROUP_SIZE);
+    let rays = folded_dispatch(divide_round_up_u32(total, PROBE_THREAD_WORKGROUP_SIZE));
 
     probe_dispatch[PROBE_DISPATCH_RAYS] = rays.x;
     probe_dispatch[PROBE_DISPATCH_RAYS + 1u] = rays.y;
@@ -200,6 +203,7 @@ fn main() {
 }
 `, [
             chunk_probe_clipmap,
+            chunk_divide_round_up_u32,
             chunk_folded_dispatch,
         ]),
 });

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

@@ -17,6 +17,9 @@ export const PROBE_RELOCATE_SETTINGS: WebGPUStruct;
  * the probe's origin at that offset, as the encoding holds it, to `probe_origins` at its place in the
  * list, where the update's passes after it find it.
  *
+ * Its place in the list goes to `probe_listed` at its slot, where a probe updated in the same frame finds it as a
+ * neighbour (`probe_clipmap_listed`).
+ *
  * @type {ComputeShader}
  */
 export const shader_probe_clipmap_relocate: ComputeShader;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_relocate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_relocate.js"],"names":[],"mappings":"AA6BA;;GAEG;AACH,sCAFU,YAAY,CAOM;AAiB5B;;;;;;;;;;;;;;;;GAgBG;AACH,4CAFU,aAAa,CAsDpB;6BAtH0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_relocate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_relocate.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH,sCAFU,YAAY,CAOM;AAkB5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4CAFU,aAAa,CAyDpB;6BAzH0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -15,17 +15,13 @@ import {
 import {
     chunk_probe_clipmap,
     PROBE_LEVELS_RESOURCE,
+    PROBE_LISTED_WRITE_RESOURCE,
     PROBE_ORIGINS_WRITE_RESOURCE,
     PROBE_RECORDS_READ_RESOURCE,
     PROBE_STATES_STORE_RESOURCE,
     PROBE_TRACE_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
-import {
-    PROBE_RELOCATION_CLEARANCE,
-    PROBE_RELOCATION_LIMIT,
-    PROBE_RELOCATION_STEPS,
-    PROBE_THREAD_WORKGROUP_SIZE
-} from "./PROBE_CLIPMAP.js";
+import { PROBE_RELOCATION_CLEARANCE, PROBE_RELOCATION_STEPS, PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
 
 /**
  * @type {WebGPUStruct}
@@ -47,6 +43,7 @@ resources.createGroup()
     .add(PROBE_RECORDS_READ_RESOURCE)
     .add(PROBE_TRACE_READ_RESOURCE)
     .add(PROBE_ORIGINS_WRITE_RESOURCE)
+    .add(PROBE_LISTED_WRITE_RESOURCE)
     .add(BRICK_LEVELS_RESOURCE)
     .add(BRICK_MAP_TEXTURE_RESOURCE)
     .add(BRICK_ATLAS_TEXTURE_RESOURCE)
@@ -67,6 +64,9 @@ resources.createGroup()
  * the probe's origin at that offset, as the encoding holds it, to `probe_origins` at its place in the
  * list, where the update's passes after it find it.
  *
+ * Its place in the list goes to `probe_listed` at its slot, where a probe updated in the same frame finds it as a
+ * neighbour (`probe_clipmap_listed`).
+ *
  * @type {ComputeShader}
  */
 export const shader_probe_clipmap_relocate = ComputeShader.from({
@@ -87,6 +87,9 @@ fn main(
     }
 
     let slot = probe_trace.elements[index];
+
+    probe_listed[slot] = index;
+
     let spacing = probe_levels[probe_record_cascade(probe_records[slot].flags)].cell_size;
     let lattice = vec3<f32>(probe_records[slot].cell) * spacing;
     let clearance = ${PROBE_RELOCATION_CLEARANCE} * spacing;

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

@@ -36,7 +36,7 @@ export const PROBE_RESAMPLE_SETTINGS: WebGPUStruct;
  *     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.
+ *     `response_frames`, the time over which a neighbour's history goes stale.
  * - 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.

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

@@ -1 +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"}
+{"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":"AAwCA;;GAEG;AACH,sCAFU,YAAY,CAaM;AAsB5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,4CAFU,aAAa,CAmIpB;6BA5O0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -1,6 +1,10 @@
 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_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";
@@ -26,8 +30,13 @@ import {
     PROBE_INDIRECTION_READ_RESOURCE,
     PROBE_SAMPLING_RESOURCE
 } from "./chunk_probe_clipmap_pick.js";
+import { chunk_probe_clipmap_resample } from "./chunk_probe_clipmap_resample.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";
+import {
+    PROBE_DEPTH_LIMIT,
+    PROBE_RESAMPLE_NEIGHBOURS,
+    PROBE_THREAD_WORKGROUP_SIZE
+} from "./PROBE_CLIPMAP.js";
 
 /**
  * @type {WebGPUStruct}
@@ -41,7 +50,7 @@ export const PROBE_RESAMPLE_SETTINGS = WebGPUStruct.from({
     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 */
+    /** τ, in frames: how fast a neighbour's history goes stale */
     response_frames: f32,
 }, "ProbeResampleSettings");
 
@@ -99,7 +108,7 @@ resources.createGroup()
  *     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.
+ *     `response_frames`, the time over which a neighbour's history goes stale.
  * - 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.
@@ -115,13 +124,6 @@ export const shader_probe_clipmap_resample = ComputeShader.from({
     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 {
@@ -215,10 +217,7 @@ fn main(
                 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);
+            let visibility = probe_resample_visibility(probe_clipmap_depth_moments(neighbour, toward), distance);
 
             // 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));
@@ -239,6 +238,7 @@ fn main(
 }
 `, [
             chunk_probe_clipmap,
+            chunk_probe_clipmap_resample,
             chunk_probe_clipmap_pick,
             chunk_probe_clipmap_sample_radiance,
             chunk_folded_workgroup_index,

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

@@ -0,0 +1,36 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const PROBE_RESAMPLE_RAYS_SETTINGS: WebGPUStruct;
+/**
+ * Re-sample rays (Enshrouded's "share rays"): each listed probe B takes every ray its candidate A traced this
+ * frame (`shader_probe_clipmap_candidate`), each in the radiance texel of B's its hit is in, and traces nothing.
+ * Hits are diffuse only, so what a ray brings back is the same seen from B. A thread a radiance texel of each
+ * listed probe, through accumulate's launch, `PROBE_DISPATCH_TEXELS`; thread `i` of B takes A's rays
+ * `i, i + n_r², …`, so each is read once; the depth texels' threads do nothing. It adds each taken ray's radiance
+ * times its weight, and the weight, to B's texel's `probe_resamples` (`atomic_add_f32_storage`), over what the
+ * history re-sample pass wrote there, or over nothing, the buffer cleared. Accumulate pools them with the texel's
+ * own rays (`chunk_probe_clipmap_resampled`).
+ *
+ * - **A ray**: a front-face hit, or a miss. An unresolved ray and a back face are not taken.
+ *   - A hit at `p`, from A's ray origin along its direction: B sees it along `p − o_B`, and only if the surface
+ *     faces B, by the hit's normal.
+ *   - A miss sees the sky along its own direction from anywhere, at the depth limit.
+ * - **Its weight**:
+ *   - The weight A was drawn at, the draw's density divided out.
+ *   - B's visibility of it, `probe_resample_visibility` over B's depth moments that way, its distance in B's
+ *     spacings held to the depth limit, as the moments are: the hit at the distance B's own rays found there is
+ *     taken, an occluder between or a gap past it weighs it down. A sky ray or a far hit is at the limit, taken where
+ *     B's own rays went past it too.
+ *   - Where A's update was guided, its rays' density: `(R_A / n_r²) / expected`, `expected` the rays A's guide gave
+ *     the texel the ray left from (`probe_clipmap_guide_expected`), so that the brighter texels the guide favours
+ *     are not over-represented in B's. A uniform update's rays weigh one.
+ *
+ * Reads the depth atlas as the last publish left it, and the frame's rays after light has added to them.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_probe_clipmap_resample_rays: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_probe_clipmap_resample_rays.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_probe_clipmap_resample_rays.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_resample_rays.js"],"names":[],"mappings":"AA0CA;;GAEG;AACH,2CAFU,YAAY,CAaU;AAwBhC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iDAFU,aAAa,CA8HpB;6BA3N0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -0,0 +1,233 @@
+import { chunk_atomic_add_f32_storage } from "../../../shader/chunk/atomic/chunk_atomic_add_f32_storage.js";
+import { chunk_rgbe9995_decode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.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 { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { BRICK_TRACE_HIT, BRICK_TRACE_MISS } from "../brick/BRICK_CLIPMAP.js";
+import {
+    chunk_probe_clipmap,
+    chunk_probe_clipmap_guide,
+    chunk_probe_clipmap_guide_expected,
+    chunk_probe_clipmap_ray_layout,
+    chunk_probe_clipmap_ray_origin,
+    PROBE_CANDIDATES_READ_RESOURCE,
+    PROBE_DEPTH_HISTORY_RESOURCE,
+    PROBE_GUIDE_READ_RESOURCE,
+    PROBE_LEVELS_RESOURCE,
+    PROBE_ORIGINS_READ_RESOURCE,
+    PROBE_RAY_SUMS_READ_RESOURCE,
+    PROBE_RAYS_READ_RESOURCE,
+    PROBE_RECORDS_READ_RESOURCE,
+    PROBE_RESAMPLES_ADD_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_resample } from "./chunk_probe_clipmap_resample.js";
+import { PROBE_DEPTH_LIMIT, PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const PROBE_RESAMPLE_RAYS_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,
+    /** rays a uniform update casts, R, which decides whether an update is guided */
+    rays_per_probe: u32,
+    /** updates between a probe's uniform ones, `PROBE_UNIFORM_PERIOD` */
+    uniform_period: u32,
+}, "ProbeResampleRaysSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", PROBE_RESAMPLE_RAYS_SETTINGS);
+
+resources.createGroup()
+    .add(PROBE_TRACE_READ_RESOURCE)
+    .add(PROBE_ORIGINS_READ_RESOURCE)
+    .add(PROBE_CANDIDATES_READ_RESOURCE)
+    .add(PROBE_RAYS_READ_RESOURCE)
+    .add(PROBE_RAY_SUMS_READ_RESOURCE)
+    .add(PROBE_GUIDE_READ_RESOURCE)
+    .add(PROBE_RESAMPLES_ADD_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_DEPTH_SAMPLER_RESOURCE);
+
+/**
+ * Re-sample rays (Enshrouded's "share rays"): each listed probe B takes every ray its candidate A traced this
+ * frame (`shader_probe_clipmap_candidate`), each in the radiance texel of B's its hit is in, and traces nothing.
+ * Hits are diffuse only, so what a ray brings back is the same seen from B. A thread a radiance texel of each
+ * listed probe, through accumulate's launch, `PROBE_DISPATCH_TEXELS`; thread `i` of B takes A's rays
+ * `i, i + n_r², …`, so each is read once; the depth texels' threads do nothing. It adds each taken ray's radiance
+ * times its weight, and the weight, to B's texel's `probe_resamples` (`atomic_add_f32_storage`), over what the
+ * history re-sample pass wrote there, or over nothing, the buffer cleared. Accumulate pools them with the texel's
+ * own rays (`chunk_probe_clipmap_resampled`).
+ *
+ * - **A ray**: a front-face hit, or a miss. An unresolved ray and a back face are not taken.
+ *   - A hit at `p`, from A's ray origin along its direction: B sees it along `p − o_B`, and only if the surface
+ *     faces B, by the hit's normal.
+ *   - A miss sees the sky along its own direction from anywhere, at the depth limit.
+ * - **Its weight**:
+ *   - The weight A was drawn at, the draw's density divided out.
+ *   - B's visibility of it, `probe_resample_visibility` over B's depth moments that way, its distance in B's
+ *     spacings held to the depth limit, as the moments are: the hit at the distance B's own rays found there is
+ *     taken, an occluder between or a gap past it weighs it down. A sky ray or a far hit is at the limit, taken where
+ *     B's own rays went past it too.
+ *   - Where A's update was guided, its rays' density: `(R_A / n_r²) / expected`, `expected` the rays A's guide gave
+ *     the texel the ray left from (`probe_clipmap_guide_expected`), so that the brighter texels the guide favours
+ *     are not over-represented in B's. A uniform update's rays weigh one.
+ *
+ * Reads the depth atlas as the last publish left it, and the frame's rays after light has added to them.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_probe_clipmap_resample_rays = ComputeShader.from({
+    label: "Probe Clipmap Resample Rays",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@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 drawn = probe_candidates[k];
+    let candidate = drawn.listed;
+
+    if (candidate == PROBE_CLIPMAP_NONE) {
+        return;
+    }
+
+    let slot = probe_trace.elements[k];
+    let origin = probe_origins[k];
+    let spacing = origin.w;
+
+    let source = probe_trace.elements[candidate];
+    let source_origin = probe_origins[candidate];
+    let span = probe_clipmap_probe_rays(candidate);
+    let guided = probe_clipmap_guided(probe_states[source].x, settings.uniform_period, settings.rays_per_probe, texels);
+    let base = candidate * probe_clipmap_guide_words(n);
+
+    // every ray of the candidate once, n_r² threads apart
+    let rounds = (span.y + texels - 1u) / texels;
+
+    for (var round = 0u; round < rounds; round++) {
+        let r = i + round * texels;
+
+        if (r >= span.y) {
+            break;
+        }
+
+        let ray = probe_rays[span.x + r];
+        let kind = ray.flags & PROBE_RAY_KIND_MASK;
+
+        if ((kind != ${BRICK_TRACE_HIT}u && kind != ${BRICK_TRACE_MISS}u) || (ray.flags & PROBE_RAY_BACK_FACE) != 0u) {
+            continue;
+        }
+
+        let direction = uv_octahedral_unit_decode(unpack2x16unorm(ray.direction));
+
+        var seen = direction;
+        var distance = ${PROBE_DEPTH_LIMIT};
+
+        if (kind == ${BRICK_TRACE_HIT}u) {
+            let hit = probe_clipmap_ray_origin(source_origin, source, ray.direction) + ray.t * direction;
+            let to_hit = hit - origin.xyz;
+            let length_to_hit = length(to_hit);
+            let normal = uv_octahedral_unit_decode(unpack2x16unorm(ray.normal));
+
+            // B sees the surface's back, or stands on it
+            if (dot(normal, to_hit) >= 0.0 || length_to_hit <= 0.0) {
+                continue;
+            }
+
+            seen = to_hit / length_to_hit;
+            distance = min(length_to_hit / spacing, ${PROBE_DEPTH_LIMIT});
+        }
+
+        var weight = drawn.weight * probe_resample_visibility(probe_clipmap_depth_moments(slot, seen), distance);
+
+        if (guided) {
+            // the texel of A's the ray left from: its jitter keeps it inside
+            let left = min(vec2<u32>(uv_octahedral_unit_encode(direction) * f32(n)), vec2<u32>(n - 1u));
+            let expected = probe_clipmap_guide_expected(base, left.y * n + left.x, span.y, n);
+
+            if (expected <= 0.0) {
+                continue;
+            }
+
+            weight *= f32(span.y) / (f32(texels) * expected);
+        }
+
+        if (weight <= 0.0) {
+            continue;
+        }
+
+        let at = min(vec2<u32>(uv_octahedral_unit_encode(seen) * f32(n)), vec2<u32>(n - 1u));
+        let cell = 4u * (k * texels + at.y * n + at.x);
+        let radiance = rgbe9995_decode(ray.light) * weight;
+
+        atomic_add_f32_storage(&probe_resamples[cell], radiance.r);
+        atomic_add_f32_storage(&probe_resamples[cell + 1u], radiance.g);
+        atomic_add_f32_storage(&probe_resamples[cell + 2u], radiance.b);
+        atomic_add_f32_storage(&probe_resamples[cell + 3u], weight);
+    }
+}
+`, [
+            chunk_probe_clipmap,
+            chunk_probe_clipmap_ray_layout,
+            chunk_probe_clipmap_ray_origin,
+            chunk_probe_clipmap_guide,
+            chunk_probe_clipmap_guide_expected,
+            chunk_probe_clipmap_pick,
+            chunk_probe_clipmap_resample,
+            chunk_folded_workgroup_index,
+            chunk_uv_octahedral_unit_decode,
+            chunk_uv_octahedral_unit_encode,
+            chunk_rgbe9995_decode,
+            chunk_atomic_add_f32_storage,
+        ]),
+});

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_schedule.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_schedule.js"],"names":[],"mappings":"AAeA;;GAEG;AACH,sCAFU,YAAY,CAWM;AAa5B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4CAFU,aAAa,CA6DpB;6BAxH0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_schedule.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_schedule.js"],"names":[],"mappings":"AAgBA;;GAEG;AACH,sCAFU,YAAY,CAWM;AAa5B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4CAFU,aAAa,CA8DpB;6BAzH0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -1,4 +1,5 @@
 import { chunk_folded_dispatch } from "../../../gpu_primitive/indirect/chunk_folded_dispatch.js";
+import { chunk_divide_round_up_u32 } from "../../../shader/chunk/math/chunk_divide_round_up_u32.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -19,8 +20,8 @@ import {
 export const PROBE_SCHEDULE_SETTINGS = WebGPUStruct.from({
     /** slots, which no active list outgrows */
     capacity: u32,
-    /** keys over every cascade: what the wanted list holds at most */
-    key_count: u32,
+    /** what the wanted list holds at most: every key, or fewer where the wants cannot want more */
+    wanted_capacity: u32,
     /** probes a frame updates at most, U = ⌊ray_budget / rays_per_probe⌋ */
     trace_capacity: u32,
     /** slots kept free beyond the frame's wanted points, ⌈capacity · PROBE_FREE_SLACK⌉ */
@@ -76,10 +77,10 @@ fn main() {
     let traced = max(settings.trace_capacity, 1u);
 
     atomicStore(&probe_counters[PROBE_COUNTER_WAITING], 0u);
-    atomicStore(&probe_counters[PROBE_COUNTER_PERIOD], max((waiting + traced - 1u) / traced, 1u));
+    atomicStore(&probe_counters[PROBE_COUNTER_PERIOD], max(divide_round_up_u32(waiting, traced), 1u));
 
     // the slots short of the frame's wanted points and the slack
-    let wanted = min(probe_wanted.count, settings.key_count);
+    let wanted = min(probe_wanted.count, settings.wanted_capacity);
     let room = wanted + settings.slack;
     let free = atomicLoad(&probe_counters[PROBE_COUNTER_FREE]);
 
@@ -113,7 +114,7 @@ fn main() {
     atomicStore(&probe_counters[PROBE_COUNTER_EVICTED], 0u);
 
     let live = min(probe_active_write.count, settings.capacity);
-    let folded = folded_dispatch((live + PROBE_THREAD_WORKGROUP_SIZE - 1u) / PROBE_THREAD_WORKGROUP_SIZE);
+    let folded = folded_dispatch(divide_round_up_u32(live, PROBE_THREAD_WORKGROUP_SIZE));
 
     probe_dispatch[PROBE_DISPATCH_ACTIVE] = folded.x;
     probe_dispatch[PROBE_DISPATCH_ACTIVE + 1u] = folded.y;
@@ -121,6 +122,7 @@ fn main() {
 }
 `, [
             chunk_probe_clipmap,
+            chunk_divide_round_up_u32,
             chunk_folded_dispatch,
         ]),
 });

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