@woosh/meep-engine 3.58.0 → 3.59.0

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

@@ -1,8 +1,5 @@
 import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_collection_u32_append } from "../../../gpu_primitive/chunk_collection_u32_append.js";
 import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
-import { chunk_clipmap_contains } from "../../../shader/chunk/clipmap/chunk_clipmap_contains.js";
-import { chunk_clipmap_select_finest } from "../../../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
 import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_background.js";
 import { chunk_mat4_extract_position } from "../../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
@@ -19,20 +16,8 @@ import {
     PROBE_WANTED_BITS_RESOURCE,
     PROBE_WANTED_WRITE_RESOURCE
 } from "./chunk_probe_clipmap.js";
-import { PROBE_RECEIVER_BIAS, PROBE_RECEIVER_BIAS_VIEW, PROBE_WANT_TILE, PROBE_WANT_WORKGROUP_TILES } from "./PROBE_CLIPMAP.js";
-
-/**
- * Slots of a workgroup's claim table: twice the claims its lanes make at most, a cage in each of two
- * cascades a lane, so a probe finds a slot within a few.
- * @type {number}
- */
-const WANT_CLAIM_SLOTS = 2 * 2 * PROBE_WANT_WORKGROUP_TILES ** 2;
-
-/**
- * Slots a claim tries before it wants its cage anyway: a bound, which a half-full table does not reach.
- * @type {number}
- */
-const WANT_CLAIM_PROBES = 16;
+import { chunk_probe_clipmap_want } from "./chunk_probe_clipmap_want.js";
+import { PROBE_RECEIVER_BIAS_VIEW, PROBE_WANT_TILE, PROBE_WANT_WORKGROUP_TILES } from "./PROBE_CLIPMAP.js";
 
 /**
  * @type {WebGPUStruct}
@@ -64,18 +49,14 @@ resources.createGroup()
  * Want (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): a thread a tile of {@link PROBE_WANT_TILE}² pixels,
  * the launch the screen's tiles.
  *
- * Each frame a tile wants the probes of one of its pixels, picked by STBN at (tile, frame), the cages
- * that pixel's pick reads (§9.1): the finest cascade whose cage window holds the point, the cage of
- * the point biased `0.1` of that cascade's spacing along `mix(n, v, 0.2)`, and in the cascade's blend
- * skirt the next cascade's cage too, biased by its own spacing. A sky pixel wants nothing; neither does
- * a cage a bias moved out of its window. Each cage point's bit is set, and a point whose bit was clear
- * goes on the wanted list, so the list holds every point wanted this frame once.
+ * Each frame a tile wants the probes of one of its pixels, picked by STBN at (tile, frame): the cages
+ * that pixel's pick reads (§9.1), biased along `mix(n, v, 0.2)`, through `probe_clipmap_want`. A sky
+ * pixel wants nothing. Its points go on the wanted list as the screen's, `PROBE_WANTED_SCREEN`; want runs
+ * before the hits' wants, so a point both want is the screen's.
  *
  * At a cascade's outer edge a lattice cell is 58 pixels on a 1080p screen at a 60° field of view, and
  * 19 at 120°, so a tile of 8 samples every cell several times a frame, and a workgroup's 64 tiles want
- * a few cages between them. So the first lane of a workgroup to want a cage claims it in the
- * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at
- * 1280×720 on Sponza, the bits' atomics were 140 of want's 345 µs and the appends 90.
+ * a few cages between them, which its claims keep to one want each.
  *
  * @type {ComputeShader}
  */
@@ -85,47 +66,6 @@ export const shader_probe_clipmap_want = ComputeShader.from({
     body: CodeChunk.from(
         //language=WGSL
         `
-// the cages the workgroup's lanes have claimed, by their key plus one; zero at the workgroup's start
-var<workgroup> probe_want_claims: array<atomic<u32>, ${WANT_CLAIM_SLOTS}>;
-
-// the cell whose corners are the cascade's cage around a point biased by its spacing, and whether the
-// cascade's cage window holds it
-fn probe_want_cage(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>, cage: ptr<function, vec3<i32>>) -> bool {
-    let level = probe_levels[cascade];
-    let biased = position + bias_direction * (${PROBE_RECEIVER_BIAS} * level.cell_size);
-
-    *cage = vec3<i32>(floor(biased / level.cell_size));
-
-    return clipmap_contains(*cage, level.corner, level.size);
-}
-
-// whether this lane is the first of its workgroup to want the cage whose least point has \`key\`; a lane
-// that finds no room in its probes wants it as well, which the bits make harmless
-fn probe_want_claim(key: u32) -> bool {
-    let tag = key + 1u;
-
-    var at = (tag * 2654435761u) >> ${32 - Math.log2(WANT_CLAIM_SLOTS)}u;
-
-    for (var probe = 0u; probe < ${WANT_CLAIM_PROBES}u; probe++) {
-        let seen = atomicCompareExchangeWeak(&probe_want_claims[at], 0u, tag);
-
-        if (seen.exchanged) {
-            return true;
-        }
-
-        if (seen.old_value == tag) {
-            return false;
-        }
-
-        // another cage's slot: the next one; an empty slot that failed spuriously is tried again
-        if (seen.old_value != 0u) {
-            at = (at + 1u) & ${WANT_CLAIM_SLOTS - 1}u;
-        }
-    }
-
-    return true;
-}
-
 @compute @workgroup_size(${PROBE_WANT_WORKGROUP_TILES}, ${PROBE_WANT_WORKGROUP_TILES})
 fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let size = textureDimensions(gBufferDepth);
@@ -144,46 +84,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let view_direction = normalize(mat4_extract_position(camera.transform) - position);
     let bias_direction = mix(normal, view_direction, ${PROBE_RECEIVER_BIAS_VIEW});
 
-    let selection = clipmap_select_finest(&probe_levels, settings.cascade_count, position, PROBE_BLEND_SKIRT);
-
-    let surface = on_screen && !is_background(depth) && selection.level != CLIPMAP_LEVEL_NONE;
-    let finest = select(0u, selection.level, surface);
-    let next = min(finest + 1u, settings.cascade_count - 1u);
-
-    var cage_finest: vec3<i32>;
-    var cage_next: vec3<i32>;
-
-    let resolution = settings.resolution;
-
-    // storage wraps by the window's side, a power of two: the low bits of a point, negative ones too
-    let wrap = vec3<u32>(resolution - 1u);
-
-    let wants_finest = surface && probe_want_cage(finest, position, bias_direction, &cage_finest)
-        && probe_want_claim(probe_clipmap_key(finest, vec3<u32>(cage_finest) & wrap, resolution));
-    let wants_next = surface && selection.edge_weight > 0.0 && finest + 1u < settings.cascade_count
-        && probe_want_cage(next, position, bias_direction, &cage_next)
-        && probe_want_claim(probe_clipmap_key(next, vec3<u32>(cage_next) & wrap, resolution));
-
-    // every lane through all sixteen corners, so that the appends stay in uniform control flow
-    for (var k = 0u; k < 16u; k++) {
-        let coarse = k >= 8u;
-        let cascade = select(finest, next, coarse);
-        let wants = select(wants_finest, wants_next, coarse);
-        let corner = vec3<i32>(vec3<u32>(k & 1u, (k >> 1u) & 1u, (k >> 2u) & 1u));
-        let point = select(cage_finest, cage_next, coarse) + corner;
-
-        let storage = vec3<u32>(point) & wrap;
-        let key = probe_clipmap_key(cascade, storage, resolution);
-        let bit = 1u << (key & 31u);
-
-        var first = false;
-
-        if (wants) {
-            first = (atomicOr(&probe_wanted_bits[key >> 5u], bit) & bit) == 0u;
-        }
-
-        collection_u32_append(&probe_wanted, first, key, settings.key_count);
-    }
+    probe_clipmap_want(on_screen && !is_background(depth), position, bias_direction, settings.cascade_count, settings.resolution, settings.key_count, PROBE_WANTED_SCREEN);
 }
 `, [
             chunk_probe_clipmap,
@@ -192,8 +93,6 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
             chunk_decode_g_buffer_normal,
             chunk_mat4_extract_position,
             chunk_is_background,
-            chunk_clipmap_select_finest,
-            chunk_clipmap_contains,
-            chunk_collection_u32_append,
+            chunk_probe_clipmap_want,
         ]),
 });

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

@@ -0,0 +1,27 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const PROBE_WANT_HITS_SETTINGS: WebGPUStruct;
+/**
+ * The hits' wants (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §8.7, D31): a thread a ray of the last
+ * frame's updates, after want and before admit, through the launch those rays had,
+ * `PROBE_DISPATCH_RAYS`, before the frame's trace command writes it over.
+ *
+ * A front-face hit that bounces anything wants the cages its pick reads, as a pixel does: the light pass
+ * takes the hit's next bounce from those probes. So a probe a hit needs is admitted where nothing on
+ * screen wanted one, and kept while hits read it. Until its first update a NEW probe weighs nothing and
+ * the hit takes no bounce: light is lost for a frame or two, never invented.
+ *
+ * Only a probe a pixel wanted in the frame of its update has hits that want, so the probes hits wanted
+ * want nothing in turn: the chain stops after one step, as Enshrouded's world-cache probes do. Unstopped,
+ * hits would want a probe at every surface the windows hold, the dense lattice D31 turned down.
+ *
+ * It binds the last frame's trace list, origins and rays, which the frame's trace writes over later, and
+ * is told that frame's U and R.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_probe_clipmap_want_hits: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_probe_clipmap_want_hits.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_probe_clipmap_want_hits.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want_hits.js"],"names":[],"mappings":"AAoBA;;GAEG;AACH,uCAFU,YAAY,CAYM;AAe5B;;;;;;;;;;;;;;;;;;GAkBG;AACH,6CAFU,aAAa,CA4CpB;6BAvG0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -0,0 +1,110 @@
+import { chunk_uv_octahedral_unit_decode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { 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 {
+    chunk_probe_clipmap,
+    PROBE_LEVELS_RESOURCE,
+    PROBE_ORIGINS_READ_RESOURCE,
+    PROBE_RAYS_READ_RESOURCE,
+    PROBE_RECORDS_READ_RESOURCE,
+    PROBE_TRACE_READ_RESOURCE,
+    PROBE_WANTED_BITS_RESOURCE,
+    PROBE_WANTED_WRITE_RESOURCE
+} from "./chunk_probe_clipmap.js";
+import { chunk_probe_clipmap_want } from "./chunk_probe_clipmap_want.js";
+import { PROBE_RECEIVER_BIAS_VIEW, PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const PROBE_WANT_HITS_SETTINGS = WebGPUStruct.from({
+    cascade_count: u32,
+    /** lattice points a cascade's window has a side */
+    resolution: u32,
+    /** keys over every cascade: what the wanted list holds at most */
+    key_count: u32,
+    /** the trace list's bound in the rays' frame, its U */
+    trace_capacity: u32,
+    /** rays an update in the rays' frame, its R */
+    rays_per_probe: u32,
+}, "ProbeWantHitsSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", PROBE_WANT_HITS_SETTINGS);
+
+resources.createGroup()
+    .add(PROBE_TRACE_READ_RESOURCE)
+    .add(PROBE_ORIGINS_READ_RESOURCE)
+    .add(PROBE_RAYS_READ_RESOURCE)
+    .add(PROBE_RECORDS_READ_RESOURCE)
+    .add(PROBE_LEVELS_RESOURCE)
+    .add(PROBE_WANTED_BITS_RESOURCE)
+    .add(PROBE_WANTED_WRITE_RESOURCE);
+
+/**
+ * The hits' wants (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §8.7, D31): a thread a ray of the last
+ * frame's updates, after want and before admit, through the launch those rays had,
+ * `PROBE_DISPATCH_RAYS`, before the frame's trace command writes it over.
+ *
+ * A front-face hit that bounces anything wants the cages its pick reads, as a pixel does: the light pass
+ * takes the hit's next bounce from those probes. So a probe a hit needs is admitted where nothing on
+ * screen wanted one, and kept while hits read it. Until its first update a NEW probe weighs nothing and
+ * the hit takes no bounce: light is lost for a frame or two, never invented.
+ *
+ * Only a probe a pixel wanted in the frame of its update has hits that want, so the probes hits wanted
+ * want nothing in turn: the chain stops after one step, as Enshrouded's world-cache probes do. Unstopped,
+ * hits would want a probe at every surface the windows hold, the dense lattice D31 turned down.
+ *
+ * It binds the last frame's trace list, origins and rays, which the frame's trace writes over later, and
+ * is told that frame's U and R.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_probe_clipmap_want_hits = ComputeShader.from({
+    label: "Probe Clipmap Want Hits",
+    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 ray = folded_workgroup_index(workgroup_id) * PROBE_THREAD_WORKGROUP_SIZE + lane;
+    let rays = settings.rays_per_probe;
+
+    var wants = false;
+    var position = vec3<f32>(0.0);
+    var bias_direction = vec3<f32>(0.0);
+
+    if (ray < min(probe_trace.count, settings.trace_capacity) * rays) {
+        let record = probe_rays[ray];
+        let slot = probe_trace.elements[ray / rays];
+
+        // shade left a front-face hit's albedo in its row and zero in any other ray's: a ray that takes no
+        // bounce, a black hit's among them, wants nothing
+        wants = record.row != 0u && probe_records[slot].screen != 0u;
+
+        let direction = uv_octahedral_unit_decode(unpack2x16unorm(record.direction));
+        let normal = uv_octahedral_unit_decode(unpack2x16unorm(record.normal));
+
+        position = probe_origins[ray / rays].xyz + record.t * direction;
+        // the view back along the ray, as the light pass's pick takes it
+        bias_direction = mix(normal, -direction, ${PROBE_RECEIVER_BIAS_VIEW});
+    }
+
+    probe_clipmap_want(wants, position, bias_direction, settings.cascade_count, settings.resolution, settings.key_count, 0u);
+}
+`, [
+            chunk_probe_clipmap,
+            chunk_folded_workgroup_index,
+            chunk_uv_octahedral_unit_decode,
+            chunk_probe_clipmap_want,
+        ]),
+});

package/src/shade/renderer/light/world_cluster/chunk_world_light_cluster_lookup.d.ts

@@ -7,6 +7,19 @@ export const WORLD_CLUSTER_DATA_RESOURCE: ShaderResourceDescriptor;
  * @type {CodeChunk}
  */
 export const chunk_world_light_cluster_lookup: CodeChunk;
+/**
+ * The world-space light cluster cell holding a world position, in cascade `cascade` of the clipmap the
+ * clusters were built over: `level` is that cascade's window, `border` the build's.
+ *
+ * ```wgsl
+ * fn world_light_cluster_metadata_at(cascade: u32, level: ClipmapLevel, border: f32, position: vec3<f32>) -> LightClusterMetadata
+ * ```
+ *
+ * A position past the cascade's cells takes the nearest one.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_world_light_cluster_lookup_at: CodeChunk;
 import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_world_light_cluster_lookup.d.ts.map

package/src/shade/renderer/light/world_cluster/chunk_world_light_cluster_lookup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_world_light_cluster_lookup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/chunk_world_light_cluster_lookup.js"],"names":[],"mappings":"AAQA,qEAIE;AAEF,mEAIE;AAEF;;;;;GAKG;AACH,+CAFU,SAAS,CA6BjB;yCAnDuC,mDAAmD;0BADlE,oCAAoC"}
+{"version":3,"file":"chunk_world_light_cluster_lookup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/chunk_world_light_cluster_lookup.js"],"names":[],"mappings":"AASA,qEAIE;AAEF,mEAIE;AAEF;;;;;GAKG;AACH,+CAFU,SAAS,CA6BjB;AAIF;;;;;;;;;;;GAWG;AACH,kDAFU,SAAS,CAyBjB;yCA1FuC,mDAAmD;0BADlE,oCAAoC"}

package/src/shade/renderer/light/world_cluster/chunk_world_light_cluster_lookup.js

@@ -1,3 +1,4 @@
+import { CLIPMAP_LEVEL_STRUCT } from "../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
@@ -54,3 +55,42 @@ fn world_light_cluster_metadata_by_texel(
 );
 
 chunk_world_light_cluster_lookup.requireResource(WORLD_CLUSTER_LOOKUP_RESOURCE);
+
+/**
+ * The world-space light cluster cell holding a world position, in cascade `cascade` of the clipmap the
+ * clusters were built over: `level` is that cascade's window, `border` the build's.
+ *
+ * ```wgsl
+ * fn world_light_cluster_metadata_at(cascade: u32, level: ClipmapLevel, border: f32, position: vec3<f32>) -> LightClusterMetadata
+ * ```
+ *
+ * A position past the cascade's cells takes the nearest one.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_world_light_cluster_lookup_at = CodeChunk.from(
+    //language=WGSL
+    `
+fn world_light_cluster_metadata_at(
+    cascade: u32,
+    level: ${CLIPMAP_LEVEL_STRUCT.wgsl_ref},
+    border: f32,
+    position: vec3<f32>,
+) -> ${LIGHT_CLUSTER_METADATA.wgsl_ref} {
+    let box_min = (vec3<f32>(level.corner) - vec3<f32>(border)) * level.cell_size;
+    let cluster_cell_size = (vec3<f32>(level.size) + vec3<f32>(2.0 * border)) * (level.cell_size / ${WORLD_LIGHT_CLUSTER_GRID_SIZE}.0);
+    let cell = vec3<u32>(clamp(floor((position - box_min) / cluster_cell_size), vec3<f32>(0.0), vec3<f32>(${WORLD_LIGHT_CLUSTER_GRID_SIZE - 1}.0)));
+
+    return world_cluster_lookup[grid3d_to_index(
+        vec3<u32>(cell.xy, cascade * ${WORLD_LIGHT_CLUSTER_GRID_SIZE}u + cell.z),
+        vec2<u32>(${WORLD_LIGHT_CLUSTER_GRID_SIZE}u)
+    )];
+}
+`, [
+        CLIPMAP_LEVEL_STRUCT.declaration_chunk,
+        LIGHT_CLUSTER_METADATA.declaration_chunk,
+        chunk_grid3d_to_index,
+    ]
+);
+
+chunk_world_light_cluster_lookup_at.requireResource(WORLD_CLUSTER_LOOKUP_RESOURCE);

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.d.ts

@@ -5,22 +5,27 @@
  */
 export function enquire_build_world_light_clusters_pipelines(enquiry: PipelineEnquiry): void;
 /**
- * Builds the world-space light cluster clipmap over the cascades of the irradiance clipmap.
+ * Builds the world-space light cluster clipmap over the cascades of a clipmap: the irradiance
+ * clipmap's, or the probe clipmap's bricks.
  *
  * @param {object} options
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
  * @param {import("../GPULightCollection.js").GPULightCollection} options.lights
- * @param {number} options.irradiance_clipmap_uniform graph handle of the `IRRADIANCE_CLIPMAP_STRUCT` uniform
+ * @param {number} options.levels graph handle of a uniform that starts with the clipmap's cascade windows,
+ *   a `CLIPMAP_LEVEL_ARRAY`
  * @param {number} options.cascade_count active cascade count
- * @param {ArrayLike<number>} options.coarsest_min `[x, y, z]` world min of coarsest cascade (including skirt)
- * @param {ArrayLike<number>} options.coarsest_max `[x, y, z]` world max of coarsest cascade (including skirt)
+ * @param {number} options.border cells of its own past each face of a cascade's window that its cluster
+ *   cells cover too
+ * @param {ArrayLike<number>} options.coarsest_min `[x, y, z]` world min of coarsest cascade (including the border)
+ * @param {ArrayLike<number>} options.coarsest_max `[x, y, z]` world max of coarsest cascade (including the border)
  * @returns {{lookup: number, data: number}}
  */
-export function graph_build_world_light_clusters({ graph, lights, irradiance_clipmap_uniform, cascade_count, coarsest_min, coarsest_max, }: {
+export function graph_build_world_light_clusters({ graph, lights, levels, cascade_count, border, coarsest_min, coarsest_max, }: {
     graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     lights: import("../GPULightCollection.js").GPULightCollection;
-    irradiance_clipmap_uniform: number;
+    levels: number;
     cascade_count: number;
+    border: number;
     coarsest_min: ArrayLike<number>;
     coarsest_max: ArrayLike<number>;
 }): {

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_build_world_light_clusters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.js"],"names":[],"mappings":"AAoDA;;;;GAIG;AACH,sEAFW,eAAe,QAMzB;AAED;;;;;;;;;;;GAWG;AACH;IARsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IAClB,MAAM,EAArE,OAAO,0BAA0B,EAAE,kBAAkB;IACrC,0BAA0B,EAA1C,MAAM;IACU,aAAa,EAA7B,MAAM;IACqB,YAAY,EAAvC,UAAU,MAAM,CAAC;IACU,YAAY,EAAvC,UAAU,MAAM,CAAC;IACf;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CA0H1C;8BA3KY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"graph_build_world_light_clusters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.js"],"names":[],"mappings":"AAoDA;;;;GAIG;AACH,sEAFW,eAAe,QAMzB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAXsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IAClB,MAAM,EAArE,OAAO,0BAA0B,EAAE,kBAAkB;IACrC,MAAM,EAAtB,MAAM;IAEU,aAAa,EAA7B,MAAM;IACU,MAAM,EAAtB,MAAM;IAEqB,YAAY,EAAvC,UAAU,MAAM,CAAC;IACU,YAAY,EAAvC,UAAU,MAAM,CAAC;IACf;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CA6H1C;8BAlLY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.js

@@ -62,22 +62,27 @@ export function enquire_build_world_light_clusters_pipelines(enquiry) {
 }
 
 /**
- * Builds the world-space light cluster clipmap over the cascades of the irradiance clipmap.
+ * Builds the world-space light cluster clipmap over the cascades of a clipmap: the irradiance
+ * clipmap's, or the probe clipmap's bricks.
  *
  * @param {object} options
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
  * @param {import("../GPULightCollection.js").GPULightCollection} options.lights
- * @param {number} options.irradiance_clipmap_uniform graph handle of the `IRRADIANCE_CLIPMAP_STRUCT` uniform
+ * @param {number} options.levels graph handle of a uniform that starts with the clipmap's cascade windows,
+ *   a `CLIPMAP_LEVEL_ARRAY`
  * @param {number} options.cascade_count active cascade count
- * @param {ArrayLike<number>} options.coarsest_min `[x, y, z]` world min of coarsest cascade (including skirt)
- * @param {ArrayLike<number>} options.coarsest_max `[x, y, z]` world max of coarsest cascade (including skirt)
+ * @param {number} options.border cells of its own past each face of a cascade's window that its cluster
+ *   cells cover too
+ * @param {ArrayLike<number>} options.coarsest_min `[x, y, z]` world min of coarsest cascade (including the border)
+ * @param {ArrayLike<number>} options.coarsest_max `[x, y, z]` world max of coarsest cascade (including the border)
  * @returns {{lookup: number, data: number}}
  */
 export function graph_build_world_light_clusters({
     graph,
     lights,
-    irradiance_clipmap_uniform,
+    levels,
     cascade_count,
+    border,
     coarsest_min,
     coarsest_max,
 }) {
@@ -151,7 +156,8 @@ export function graph_build_world_light_clusters({
 
     const assign_data = {
         cascade_count,
-        irradiance_clipmap: -1,
+        settings: { cascade_count, border },
+        levels: -1,
         culled_lights: -1,
         proxies: -1,
         lookup: -1,
@@ -174,7 +180,8 @@ export function graph_build_world_light_clusters({
             group_count_y: groups_xy,
             group_count_z: groups_z,
             bindings: {
-                irradiance_clipmap: resources.get(data.irradiance_clipmap),
+                settings: data.settings,
+                levels: resources.get(data.levels),
                 culled_lights: resources.get(data.culled_lights),
                 proxies: resources.get(data.proxies),
                 world_cluster_lookup: resources.get(data.lookup),
@@ -183,7 +190,7 @@ export function graph_build_world_light_clusters({
         });
     });
 
-    assign_data.irradiance_clipmap = assign_pass.read(irradiance_clipmap_uniform);
+    assign_data.levels = assign_pass.read(levels);
     assign_data.culled_lights = assign_pass.read(cull_data.culled_lights);
     assign_data.proxies = assign_pass.read(cull_data.proxies);
     assign_data.lookup = assign_pass.create("World cluster / lookup", LOOKUP_DESCRIPTOR);

package/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.d.ts

@@ -1,10 +1,17 @@
 export const WORLD_CLUSTER_ASSIGN_WORKGROUP_SIZE: readonly number[];
 /**
- * Assigns world-space culled point and spot lights to the `8 × 8 × 8` cluster cells of each
- * cascade of the world-space irradiance clipmap.
+ * @type {WebGPUStruct}
+ */
+export const WORLD_CLUSTER_ASSIGN_SETTINGS: WebGPUStruct;
+/**
+ * Assigns world-space culled point and spot lights to the `8 × 8 × 8` cluster cells of each cascade of
+ * a clipmap: `levels[c]`'s window, grown by `settings.border` of its cells past each face, then by half
+ * a cell more. The irradiance clipmap's cascades take its tile skirt as the border; the probe clipmap's
+ * bricks none.
  *
  * @type {ComputeShader}
  */
 export const shader_world_cluster_assign_lights: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 //# sourceMappingURL=shader_world_cluster_assign_lights.d.ts.map

package/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_world_cluster_assign_lights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js"],"names":[],"mappings":"AAoBA,oEAA4E;AAoI5E;;;;;GAKG;AACH,iDAFU,aAAa,CAMpB;8BA9J2B,+BAA+B"}
+{"version":3,"file":"shader_world_cluster_assign_lights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js"],"names":[],"mappings":"AAqBA,oEAA4E;AAI5E;;GAEG;AACH,4CAFU,YAAY,CAOW;AAmIjC;;;;;;;GAOG;AACH,iDAFU,aAAa,CAMpB;6BAvK0B,mCAAmC;8BAJlC,+BAA+B"}

package/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js

@@ -1,12 +1,13 @@
 import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
 import { COLLECTION_U32_STRUCT_WRITE } from "../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
+import { CLIPMAP_LEVEL_ARRAY, CLIPMAP_LEVEL_STRUCT } from "../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.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 { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { IRRADIANCE_CLIPMAP_TILE_BORDER } from "../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js";
-import { IRRADIANCE_CLIPMAP_STRUCT } from "../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP_STRUCT.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { chunk_light_cluster_counts } from "../cluster/chunk_light_cluster_counts.js";
 import { CLUSTER_LIGHT_PROXY } from "../cluster/CLUSTER_LIGHT_PROXY.js";
 import { chunk_cluster_light_tuple } from "../cluster/CLUSTER_LIGHT_TYPE.js";
@@ -22,10 +23,22 @@ export const WORLD_CLUSTER_ASSIGN_WORKGROUP_SIZE = Object.freeze([4, 4, 4]);
 const BATCH_SIZE = 64;
 const MAX_PER_TYPE = WORLD_LIGHT_CLUSTER_MAX_LIGHTS_PER_CELL >>> 1;
 
+/**
+ * @type {WebGPUStruct}
+ */
+export const WORLD_CLUSTER_ASSIGN_SETTINGS = WebGPUStruct.from({
+    /** the clipmap's cascades, each `levels[c]` */
+    cascade_count: u32,
+    /** cells of its own past each face of a cascade's window that its cluster cells cover too: a reader's skirt */
+    border: f32,
+}, "WorldClusterAssignSettings");
+
 const resources = new ShaderResourceSetDescriptor();
 
+resources.setImmediate("settings", WORLD_CLUSTER_ASSIGN_SETTINGS);
+
 resources.createGroup()
-    .addUniform("irradiance_clipmap", IRRADIANCE_CLIPMAP_STRUCT)
+    .addUniform("levels", CLIPMAP_LEVEL_ARRAY)
     .addStorageBuffer("culled_lights", COLLECTION_U32_STRUCT_READ, false)
     .addStorageBuffer("proxies", WebGPUArray.from(CLUSTER_LIGHT_PROXY), false)
     .addStorageBuffer("world_cluster_lookup", LIGHT_CLUSTER_LOOKUP_STRUCT, true)
@@ -37,7 +50,6 @@ const body = CodeChunk.from(
 const GRID_SIZE: u32 = ${WORLD_LIGHT_CLUSTER_GRID_SIZE}u;
 const BATCH_SIZE: u32 = ${BATCH_SIZE}u;
 const MAX_PER_TYPE: u32 = ${MAX_PER_TYPE}u;
-const BORDER: f32 = ${IRRADIANCE_CLIPMAP_TILE_BORDER}.0;
 
 var<workgroup> shared_tuples: array<u32, ${BATCH_SIZE}>;
 var<workgroup> shared_proxies: array<${CLUSTER_LIGHT_PROXY.wgsl_ref}, ${BATCH_SIZE}>;
@@ -49,15 +61,15 @@ fn main(
 ) {
     let cascade = global_id.z / GRID_SIZE;
     let cell = vec3<u32>(global_id.x, global_id.y, global_id.z % GRID_SIZE);
-    let valid_cell = cascade < irradiance_clipmap.cascade_count && all(cell < vec3<u32>(GRID_SIZE));
+    let valid_cell = cascade < settings.cascade_count && all(cell < vec3<u32>(GRID_SIZE));
 
     var cell_lo = vec3<f32>(0.0);
     var cell_hi = vec3<f32>(0.0);
 
     if (valid_cell) {
-        let level = irradiance_clipmap.levels[cascade];
-        let box_min = (vec3<f32>(level.corner) - vec3<f32>(BORDER)) * level.cell_size;
-        let cluster_cell_size = (vec3<f32>(level.size) + vec3<f32>(2.0 * BORDER)) * (level.cell_size / f32(GRID_SIZE));
+        let level = levels[cascade];
+        let box_min = (vec3<f32>(level.corner) - vec3<f32>(settings.border)) * level.cell_size;
+        let cluster_cell_size = (vec3<f32>(level.size) + vec3<f32>(2.0 * settings.border)) * (level.cell_size / f32(GRID_SIZE));
         let base_lo = box_min + vec3<f32>(cell) * cluster_cell_size;
         let half_voxel = vec3<f32>(0.5 * level.cell_size);
         cell_lo = base_lo - half_voxel;
@@ -140,7 +152,7 @@ fn main(
     })};
 }
 `, [
-        IRRADIANCE_CLIPMAP_STRUCT.declaration_chunk,
+        CLIPMAP_LEVEL_STRUCT.declaration_chunk,
         CLUSTER_LIGHT_PROXY.declaration_chunk,
         LIGHT_CLUSTER_METADATA.declaration_chunk,
         chunk_grid3d_to_index,
@@ -151,8 +163,10 @@ fn main(
 );
 
 /**
- * Assigns world-space culled point and spot lights to the `8 × 8 × 8` cluster cells of each
- * cascade of the world-space irradiance clipmap.
+ * Assigns world-space culled point and spot lights to the `8 × 8 × 8` cluster cells of each cascade of
+ * a clipmap: `levels[c]`'s window, grown by `settings.border` of its cells past each face, then by half
+ * a cell more. The irradiance clipmap's cascades take its tile skirt as the border; the probe clipmap's
+ * bricks none.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#298@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#300@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]