@woosh/meep-engine 3.61.2 → 3.61.3

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_batch.js

@@ -13,7 +13,7 @@ import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderR
 import { atomic_u32, u32 } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
-import { BRICK_CELL_WORKGROUP_SIZE, BRICK_OBJECT_CELLS_PER_AXIS } from "../BRICK_CLIPMAP.js";
+import { BRICK_CELL_WORKGROUP_SIZE } from "../BRICK_CLIPMAP.js";
 import { BRICK_RING_RESOURCE, BRICK_TAKE_RESOURCE, chunk_brick_clipmap } from "../chunk_brick_clipmap.js";
 import { chunk_brick_object } from "../chunk_brick_object.js";
 import { chunk_brick_provider } from "../chunk_brick_provider.js";
@@ -60,10 +60,6 @@ var<workgroup> instances: array<${MESH_BRICK_INSTANCE_STRUCT.wgsl_ref}, MESH_BRI
 /** the batch's rows, ascending */
 var<workgroup> batch_rows: array<u32, MESH_BRICK_BATCH>;
 
-/** per object cell: its nearest texel's key over the batch, and its lanes done */
-var<workgroup> object_best: array<atomic<u32>, ${BRICK_OBJECT_CELLS_PER_AXIS ** 3}>;
-var<workgroup> object_lanes: array<atomic<u32>, ${BRICK_OBJECT_CELLS_PER_AXIS ** 3}>;
-
 /** lane 0's: the batches, and this one's build slot and rows */
 var<workgroup> batch_header: vec3<u32>;
 
@@ -138,36 +134,15 @@ fn main(
     let z = lane / 8u;
     let accumulator = mesh_brick_accumulator(build);
 
-    var best = vec4<u32>(0u);
-
     for (var x = 0u; x < 8u; x++) {
         let texel = mesh_brick_texel(at.corner + vec3<f32>(f32(x), f32(y), f32(z)) * at.voxel, count, at.band);
         let byte = brick_encode(texel.distance, at.band);
+        let key = brick_object_key(byte, texel.row);
 
-        // the cell's least byte over its batches, as the most of 255 less each; +R raises nothing
+        // the texel's least byte over the cell's batches, and the row that gave it, as the largest key; +R
+        // raises nothing
         if (byte < 255u) {
-            atomicMax(&mesh_brick_accumulators[accumulator + x + 8u * (y + 8u * z)], 255u - byte);
-        }
-
-        let o = x / 2u;
-
-        best[o] = max(best[o], brick_object_key(byte, texel.row));
-    }
-
-    // per object cell, its four lanes fold in their texels, and the last bids the batch's nearest
-    for (var o = 0u; o < ${BRICK_OBJECT_CELLS_PER_AXIS}u; o++) {
-        let object = o + ${BRICK_OBJECT_CELLS_PER_AXIS}u * ((y / 2u) + ${BRICK_OBJECT_CELLS_PER_AXIS}u * (z / 2u));
-
-        atomicMax(&object_best[object], best[o]);
-
-        if (atomicAdd(&object_lanes[object], 1u) != 3u) {
-            continue;
-        }
-
-        let nearest = atomicLoad(&object_best[object]);
-
-        if (brick_object_key_byte(nearest) < 255u) {
-            atomicMax(&mesh_brick_accumulators[accumulator + MESH_BRICK_ACCUMULATOR_OBJECTS + object], nearest);
+            atomicMax(&mesh_brick_accumulators[accumulator + x + 8u * (y + 8u * z)], key);
         }
     }
 }
@@ -189,10 +164,10 @@ fn main(
  * Its up to {@link MESH_BRICK_BATCH} rows, sorted ascending (a bitonic network, a lane a pair), become
  * instances in workgroup memory, a lane each (`mesh_brick_instance`), and its cell's 512 texels are
  * sampled over them in that order, eight a lane
- * (`mesh_brick_texel`: the least distance and its row, the box test first). Each texel's byte goes into
- * the cell's accumulators by an atomic maximum of 255 less it, and each 2³ object cell's nearest texel
- * bids its key by another (`brick_object_key`): the least byte and the nearest row over every batch
- * of the cell, whatever order the batches ran in. The staging is the resolve's to write.
+ * (`mesh_brick_texel`: the least distance and its row, the box test first). Each texel's key, its byte
+ * and its row (`brick_object_key`), goes into the cell's accumulators by an atomic maximum: the least byte
+ * and the nearest row over every batch of the cell, whatever order the batches ran in. The staging is the
+ * resolve's to write.
  *
  * The order is what keeps a cell of up to {@link MESH_BRICK_BATCH} rows, one batch, the same however the walk
  * found its rows: the box test is exact only where an instance's field is not negative outside its box,

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_resolve.d.ts

@@ -1,18 +1,16 @@
 /**
  * The mesh provider's resolve (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7, as S9 built it): a workgroup
  * a cell the walks listed, dispatched by its command after the batches. It merges the cell's
- * accumulators into the staging as any provider merges (§7.6), and leaves its texel and object words
- * at 0 for the next frame. A taken cell no walk listed, most of them, had no batch and finished its
+ * accumulators into the staging as any provider merges (§7.6), and leaves its texel words at 0 for the
+ * next frame. A taken cell no walk listed, most of them, had no batch and finished its
  * walks: its staging stays as it is, and the resolve spends nothing on it.
  *
  * - A cell a walk of which did not finish sets its retry word (contract 7): free puts its key back on
  *   the ring, and the cell is built again.
  * - Contract 2, per texel of a cell a batch reached: the staged byte becomes the least of itself and
  *   the batches' byte.
- * - Contract 3, per 2³ object cell: the batches' nearest row replaces the staged object when its byte
- *   is below the staged cell minimum taken before the merge; ties keep the staged object. The cell's
- *   four lanes fold their staged texels in through workgroup atomics, and the last of them decides, so
- *   that no lane waits on another.
+ * - Contract 8, per texel: where the batches' byte is below the staged one, their row replaces the
+ *   texel's staged surface row; ties keep the staged row.
  *
  * Eight texels a lane: the staging's two words and the accumulators' eight.
  *

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_mesh_brick_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_resolve.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wCAFU,aAAa,CAgGpB;8BApI2B,qCAAqC"}
+{"version":3,"file":"shader_mesh_brick_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_resolve.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;GAiBG;AACH,wCAFU,aAAa,CA0EpB;8BA5G2B,qCAAqC"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_resolve.js

@@ -4,7 +4,7 @@ import { ComputeShader } from "../../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { atomic_u32 } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../../shader/type/WebGPUArray.js";
-import { BRICK_CELL_WORKGROUP_SIZE, BRICK_OBJECT_CELLS_PER_AXIS } from "../BRICK_CLIPMAP.js";
+import { BRICK_CELL_WORKGROUP_SIZE } from "../BRICK_CLIPMAP.js";
 import { BRICK_STAGING_RESOURCE, chunk_brick_clipmap } from "../chunk_brick_clipmap.js";
 import { chunk_brick_object } from "../chunk_brick_object.js";
 import { chunk_mesh_brick_walk } from "./chunk_mesh_brick_walk.js";
@@ -21,18 +21,16 @@ resources.createGroup()
 /**
  * The mesh provider's resolve (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7, as S9 built it): a workgroup
  * a cell the walks listed, dispatched by its command after the batches. It merges the cell's
- * accumulators into the staging as any provider merges (§7.6), and leaves its texel and object words
- * at 0 for the next frame. A taken cell no walk listed, most of them, had no batch and finished its
+ * accumulators into the staging as any provider merges (§7.6), and leaves its texel words at 0 for the
+ * next frame. A taken cell no walk listed, most of them, had no batch and finished its
  * walks: its staging stays as it is, and the resolve spends nothing on it.
  *
  * - A cell a walk of which did not finish sets its retry word (contract 7): free puts its key back on
  *   the ring, and the cell is built again.
  * - Contract 2, per texel of a cell a batch reached: the staged byte becomes the least of itself and
  *   the batches' byte.
- * - Contract 3, per 2³ object cell: the batches' nearest row replaces the staged object when its byte
- *   is below the staged cell minimum taken before the merge; ties keep the staged object. The cell's
- *   four lanes fold their staged texels in through workgroup atomics, and the last of them decides, so
- *   that no lane waits on another.
+ * - Contract 8, per texel: where the batches' byte is below the staged one, their row replaces the
+ *   texel's staged surface row; ties keep the staged row.
  *
  * Eight texels a lane: the staging's two words and the accumulators' eight.
  *
@@ -44,10 +42,6 @@ export const shader_mesh_brick_resolve = ComputeShader.from({
     body: CodeChunk.from(
         //language=WGSL
         `
-/** per object cell: its staged minimum before the merge (as 255 less the byte), and its lanes done */
-var<workgroup> object_staged: array<atomic<u32>, ${BRICK_OBJECT_CELLS_PER_AXIS ** 3}>;
-var<workgroup> object_lanes: array<atomic<u32>, ${BRICK_OBJECT_CELLS_PER_AXIS ** 3}>;
-
 @compute @workgroup_size(${BRICK_CELL_WORKGROUP_SIZE})
 fn main(
     @builtin(workgroup_id) workgroup_id: vec3<u32>,
@@ -71,7 +65,7 @@ fn main(
         atomicAdd(&mesh_brick_counters[${MESH_BRICK_STATISTIC_CELLS_RETRIED}u], 1u);
     }
 
-    // listed for its retry alone: no batch reached it, and its texel and object words are 0
+    // listed for its retry alone: no batch reached it, and its texel words are 0
     if ((flags & MESH_BRICK_FLAG_TOUCHED) == 0u) {
         return;
     }
@@ -81,50 +75,32 @@ fn main(
     let z = lane / 8u;
     let first = build * BRICK_STAGING_WORDS + 2u * lane;
 
-    var staged_min = vec4<u32>(255u);
-
     for (var w = 0u; w < 2u; w++) {
         var word = brick_staging[first + w];
 
         for (var b = 0u; b < 4u; b++) {
             let x = 4u * w + b;
-            let texel = accumulator + x + 8u * (y + 8u * z);
+            let t = x + 8u * (y + 8u * z);
+            let texel = accumulator + t;
             let shift = 8u * b;
             let staged = (word >> shift) & 0xffu;
-            let byte = 255u - mesh_brick_accumulators[texel];
+            let key = mesh_brick_accumulators[texel];
+            // a texel no batch reached bid nothing: +R
+            let byte = select(255u, brick_object_key_byte(key), key != 0u);
 
             mesh_brick_accumulators[texel] = 0u;
 
             // contract 2: the encoding is monotone, so the minimum of the bytes is the byte of the minimum
             word = (word & ~(0xffu << shift)) | (min(staged, byte) << shift);
 
-            let o = x / 2u;
-
-            staged_min[o] = min(staged_min[o], staged);
+            // contract 8: where the batches lowered the byte, their row is the texel's surface; ties keep the staged row
+            if (byte < staged) {
+                brick_staging[build * BRICK_STAGING_WORDS + BRICK_STAGING_SURFACE_WORDS + t] = brick_object_key_row(key);
+            }
         }
 
         brick_staging[first + w] = word;
     }
-
-    // contract 3, per object cell: its four lanes each fold in their staged texels, and the last decides
-    for (var o = 0u; o < ${BRICK_OBJECT_CELLS_PER_AXIS}u; o++) {
-        let object = o + ${BRICK_OBJECT_CELLS_PER_AXIS}u * ((y / 2u) + ${BRICK_OBJECT_CELLS_PER_AXIS}u * (z / 2u));
-
-        atomicMax(&object_staged[object], 255u - staged_min[o]);
-
-        if (atomicAdd(&object_lanes[object], 1u) != 3u) {
-            continue;
-        }
-
-        let key = mesh_brick_accumulators[accumulator + MESH_BRICK_ACCUMULATOR_OBJECTS + object];
-
-        mesh_brick_accumulators[accumulator + MESH_BRICK_ACCUMULATOR_OBJECTS + object] = 0u;
-
-        // a bid is never 0: only a byte below 255 bids. Ties keep the staged object
-        if (key != 0u && brick_object_key_byte(key) < 255u - atomicLoad(&object_staged[object])) {
-            brick_staging[build * BRICK_STAGING_WORDS + BRICK_STAGING_DISTANCE_WORDS + object] = brick_object_key_row(key);
-        }
-    }
 }
 `, [
             chunk_brick_clipmap,

package/src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_clear.d.ts

@@ -1,7 +1,7 @@
 /**
  * Clear (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.5): a thread a staging word of the frame's taken
  * cells, dispatched by take. A distance word becomes four bytes of 255, `+R`, the far side of every
- * provider's minimum; an object word becomes 0, no row.
+ * provider's minimum; every other word, the retry word and the surface rows, becomes 0.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_clear.js

@@ -14,7 +14,7 @@ resources.createGroup()
 /**
  * Clear (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.5): a thread a staging word of the frame's taken
  * cells, dispatched by take. A distance word becomes four bytes of 255, `+R`, the far side of every
- * provider's minimum; an object word becomes 0, no row.
+ * provider's minimum; every other word, the retry word and the surface rows, becomes 0.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_store.d.ts

@@ -9,8 +9,7 @@ export const BRICK_STORE_SETTINGS: WebGPUStruct;
  * A cell free marked pops a slot: lane 0 pops it and writes the entry, and the slot reaches the other
  * lanes through the workgroup. Take held the frame to the free slots, so the pop is never refused. A
  * cell that holds a slot, its own or the one just popped, has its 512 staged bytes written into the
- * slot's atlas tile and its 64 objects into the slot's object cells; a cell free made EMPTY writes
- * nothing.
+ * slot's atlas tile; a cell free made EMPTY writes nothing.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_brick_clipmap_store.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_store.js"],"names":[],"mappings":"AAoBA;;GAEG;AACH,mCAFU,YAAY,CASG;AAgBzB;;;;;;;;;;;GAWG;AACH,yCAFU,aAAa,CAsEpB;6BAtH0B,sCAAsC;8BAJrC,kCAAkC"}
+{"version":3,"file":"shader_brick_clipmap_store.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_store.js"],"names":[],"mappings":"AAoBA;;GAEG;AACH,mCAFU,YAAY,CASG;AAezB;;;;;;;;;;GAUG;AACH,yCAFU,aAAa,CAoEpB;6BAlH0B,sCAAsC;8BAJrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_store.js

@@ -26,7 +26,7 @@ export const BRICK_STORE_SETTINGS = WebGPUStruct.from({
     ring_capacity: u32,
     /** cells a cascade's window has a side */
     resolution: u32,
-    /** slots the atlas and the object cells hold: what bounds a pop */
+    /** slots the atlas holds: what bounds a pop */
     capacity: u32,
 }, "BrickStoreSettings");
 
@@ -40,7 +40,6 @@ resources.createGroup()
     .add(BRICK_RING_RESOURCE)
     .add(BRICK_FREE_RESOURCE)
     .add(BRICK_STAGING_RESOURCE)
-    .addStorageBuffer("brick_objects", WebGPUArray.u32, true)
     .addStorageTexture("brick_map", "r32uint", "3d", "read-write")
     .addStorageTexture("brick_atlas_store", "r8unorm", "3d", "write-only");
 
@@ -51,8 +50,7 @@ resources.createGroup()
  * A cell free marked pops a slot: lane 0 pops it and writes the entry, and the slot reaches the other
  * lanes through the workgroup. Take held the frame to the free slots, so the pop is never refused. A
  * cell that holds a slot, its own or the one just popped, has its 512 staged bytes written into the
- * slot's atlas tile and its 64 objects into the slot's object cells; a cell free made EMPTY writes
- * nothing.
+ * slot's atlas tile; a cell free made EMPTY writes nothing.
  *
  * @type {ComputeShader}
  */
@@ -115,8 +113,6 @@ fn main(
             textureStore(brick_atlas_store, row + vec3<u32>(4u * w + b, 0u, 0u), vec4<f32>(f32(byte) / 255.0, 0.0, 0.0, 0.0));
         }
     }
-
-    brick_objects[slot * BRICK_OBJECT_CELLS + lane] = brick_staging[build * BRICK_STAGING_WORDS + BRICK_STAGING_DISTANCE_WORDS + lane];
 }
 `, [
             chunk_brick_clipmap,

package/src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_take.d.ts

@@ -9,8 +9,8 @@ export const BRICK_TAKE_SETTINGS: WebGPUStruct;
  * host grows the capacity, as the mesh bake does (§6.4).
  *
  * Build slot `b` is taken key `b`, at ring position `taken_first + b`. Writes them, and the frame's
- * two dispatches, folded past the per-dimension limit, into `brick_take`: a workgroup a taken cell,
- * and a thread a staging word of the taken cells.
+ * three dispatches, folded past the per-dimension limit, into `brick_take`: a workgroup a taken cell,
+ * a thread a staging word of the taken cells, and a thread a texel of them.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_take.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_brick_clipmap_take.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_take.js"],"names":[],"mappings":"AAUA;;GAEG;AACH,kCAFU,YAAY,CAKE;AAUxB;;;;;;;;;;;GAWG;AACH,wCAFU,aAAa,CA4CpB;6BAzE0B,sCAAsC;8BAJrC,kCAAkC"}
+{"version":3,"file":"shader_brick_clipmap_take.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_take.js"],"names":[],"mappings":"AAYA;;GAEG;AACH,kCAFU,YAAY,CAKE;AAUxB;;;;;;;;;;;GAWG;AACH,wCAFU,aAAa,CA6CpB;6BA3E0B,sCAAsC;8BAJrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/shader_brick_clipmap_take.js

@@ -1,3 +1,4 @@
+import { MESH_SDF_BRICK_TEXELS } from "../../../geometry/sdf/MESH_SDF.js";
 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";
@@ -6,6 +7,7 @@ import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderReso
 import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { BRICK_THREAD_WORKGROUP_SIZE } from "./BRICK_CLIPMAP.js";
 import { BRICK_STATE_RESOURCE, chunk_brick_clipmap } from "./chunk_brick_clipmap.js";
 
 /**
@@ -31,8 +33,8 @@ resources.createGroup()
  * host grows the capacity, as the mesh bake does (§6.4).
  *
  * Build slot `b` is taken key `b`, at ring position `taken_first + b`. Writes them, and the frame's
- * two dispatches, folded past the per-dimension limit, into `brick_take`: a workgroup a taken cell,
- * and a thread a staging word of the taken cells.
+ * three dispatches, folded past the per-dimension limit, into `brick_take`: a workgroup a taken cell,
+ * a thread a staging word of the taken cells, and a thread a texel of them.
  *
  * @type {ComputeShader}
  */
@@ -72,6 +74,7 @@ fn main() {
 
     write_folded_dispatch(BRICK_TAKE_CELL_DISPATCH, taken);
     write_folded_dispatch(BRICK_TAKE_WORD_DISPATCH, divide_round_up_u32(taken * BRICK_STAGING_WORDS, BRICK_THREAD_WORKGROUP_SIZE));
+    write_folded_dispatch(BRICK_TAKE_TEXEL_DISPATCH, taken * ${MESH_SDF_BRICK_TEXELS ** 3 / BRICK_THREAD_WORKGROUP_SIZE}u);
 }
 `, [
             chunk_brick_clipmap,

package/src/shade/renderer/global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.d.ts

@@ -5,7 +5,11 @@ export type ProbeClipmapDebugView = number;
 export namespace ProbeClipmapDebugView {
     let None: number;
     let MeshSDF: number;
-    let MeshCards: number;
+    let MeshSurfaces: number;
     let BrickClipmap: number;
+    let IndirectDiffuse: number;
+    let IndirectSpecular: number;
+    let BrickMaterial: number;
+    let BrickMetalRough: number;
 }
 //# sourceMappingURL=ProbeClipmapDebugView.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.js

@@ -9,8 +9,22 @@ export const ProbeClipmapDebugView = {
     None: 0,
     /** the scene as its geometry caches have it: camera rays marched through every mesh's sparse field */
     MeshSDF: 1,
-    /** the same hits, each shown as its row's cards see it: diffuse albedo plus emissive */
-    MeshCards: 2,
+    /** the same hits, each shown as its row's Model Surface Cache holds it: diffuse albedo plus emissive */
+    MeshSurfaces: 2,
     /** the scene as the probe clipmap's rays see it: camera rays traced through the brick clipmap */
     BrickClipmap: 3,
+    /**
+     * the light the probe clipmap's indirect diffuse is made of: the probes' irradiance at the bent normal over π, what
+     * a white Lambertian surface would send back, before the surface's albedo, metalness and occlusion
+     */
+    IndirectDiffuse: 4,
+    /**
+     * the light the probe clipmap's indirect specular is made of: the probes' radiance along the surface's lobe, at
+     * its roughness, before its reflectance and occlusion
+     */
+    IndirectSpecular: 5,
+    /** the scene as the probes' rays read its material, the brick material: diffuse albedo plus emissive */
+    BrickMaterial: 6,
+    /** the same hits' metalness in red and roughness in green */
+    BrickMetalRough: 7,
 };

package/src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_material.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {GPUViewContext} options.view
+ * @param {number[]} options.resolution
+ * @param {GPUBrickClipmap} options.brick_clipmap built this frame, before this pass
+ * @param {{write_bindings: function(Object): Object}} options.material what binds the brick material's planes
+ * @param {ProbeClipmapDebugBrickMaterialChannel} options.channel
+ * @returns {number} graph handle of the `rgba8unorm` image
+ */
+export function graph_probe_clipmap_debug_brick_material({ graph, view, resolution, brick_clipmap, material, channel }: {
+    graph: FrameGraph;
+    view: GPUViewContext;
+    resolution: number[];
+    brick_clipmap: GPUBrickClipmap;
+    material: {
+        write_bindings: (arg0: any) => any;
+    };
+    channel: ProbeClipmapDebugBrickMaterialChannel;
+}): number;
+/**
+ * What {@link graph_probe_clipmap_debug_brick_material } shows of each hit.
+ */
+export type ProbeClipmapDebugBrickMaterialChannel = number;
+export namespace ProbeClipmapDebugBrickMaterialChannel {
+    let Albedo: number;
+    let MetalRough: number;
+}
+/**
+ * The view's scene as the probes' rays read its material: each pixel's camera ray traced through the
+ * brick clipmap as {@link ProbeClipmapDebugView.BrickClipmap} traces it, and the hit's material read as
+ * the shade reads a probe ray's (`probe_clipmap_hit_material`), from the brick material: its diffuse
+ * albedo plus emissive, or its metalness and roughness.
+ *
+ * Dark red is a hit whose source does not know its surface, black to the probes; dark blue a back
+ * face, which they count and do not shade; magenta a ray whose steps ran out.
+ *
+ * @type {ImageShader}
+ */
+export const shader_probe_clipmap_debug_brick_material: ImageShader;
+export type FrameGraph = import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+export type GPUViewContext = import("../../../view/GPUViewContext.js").GPUViewContext;
+export type GPUBrickClipmap = import("../brick/GPUBrickClipmap.js").GPUBrickClipmap;
+import { ImageShader } from "../../../shader/ImageShader.js";
+//# sourceMappingURL=graph_probe_clipmap_debug_brick_material.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_material.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph_probe_clipmap_debug_brick_material.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_material.js"],"names":[],"mappings":"AAsJA;;;;;;;;;GASG;AACH;IAR+B,KAAK,EAAzB,UAAU;IACc,IAAI,EAA5B,cAAc;IACI,UAAU,EAA5B,MAAM,EAAE;IACiB,aAAa,EAAtC,eAAe;IACqC,QAAQ,EAA5D;QAAC,cAAc,qBAA0B;KAAC;IACK,OAAO,EAAtD,qCAAqC;IACnC,MAAM,CAiDlB;;;;oDAtKS,MAAM;;;;;AAuFhB;;;;;;;;;;GAUG;AACH,wDAFU,WAAW,CAWlB;yBA1HU,OAAO,iEAAiE,EAAE,UAAU;6BACpF,OAAO,iCAAiC,EAAE,cAAc;8BACxD,OAAO,6BAA6B,EAAE,eAAe;4BAvBtC,gCAAgC"}

package/src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_material.js

@@ -0,0 +1,208 @@
+import { assert } from "../../../../../core/assert.js";
+import { TextureResourceDescriptor } from "../../../../device/graph/TextureResourceDescriptor.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_camera_ray_from_uv } from "../../../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import {
+    BRICK_ATLAS_TEXTURE_RESOURCE,
+    BRICK_LEVELS_RESOURCE,
+    BRICK_MAP_TEXTURE_RESOURCE,
+    BRICK_OCCUPANCY_TEXTURE_RESOURCE,
+    BRICK_SAMPLER_RESOURCE,
+    chunk_brick_clipmap_trace
+} from "../brick/chunk_brick_clipmap_trace.js";
+import {
+    BRICK_MATERIAL_ALBEDO_RESOURCE,
+    BRICK_MATERIAL_EMISSIVE_RESOURCE,
+    BRICK_MATERIAL_METAL_ROUGH_RESOURCE
+} from "../material/chunk_brick_material.js";
+import { chunk_probe_clipmap_hit_material, chunk_probe_clipmap_hit_metal_rough } from "../probe/chunk_probe_clipmap_hit_material.js";
+
+/**
+ * @typedef {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("../../../view/GPUViewContext.js").GPUViewContext} GPUViewContext
+ * @typedef {import("../brick/GPUBrickClipmap.js").GPUBrickClipmap} GPUBrickClipmap
+ */
+
+/**
+ * As far as a camera ray is traced: past every cascade, where the trace has already missed.
+ * @type {number}
+ */
+const FAR = 1e4;
+
+/**
+ * What {@link graph_probe_clipmap_debug_brick_material} shows of each hit.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const ProbeClipmapDebugBrickMaterialChannel = {
+    /** diffuse albedo plus emissive */
+    Albedo: 0,
+    /** metalness in red, roughness in green */
+    MetalRough: 1,
+};
+
+/**
+ * @type {WebGPUStruct}
+ */
+const DEBUG_BRICK_MATERIAL_SETTINGS = WebGPUStruct.from({
+    cascade_count: u32,
+    /** a {@link ProbeClipmapDebugBrickMaterialChannel} */
+    channel: u32,
+}, "ProbeClipmapDebugBrickMaterialSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", DEBUG_BRICK_MATERIAL_SETTINGS);
+
+resources.createGroup()
+    .add(BRICK_LEVELS_RESOURCE)
+    .add(BRICK_MAP_TEXTURE_RESOURCE)
+    .add(BRICK_OCCUPANCY_TEXTURE_RESOURCE)
+    .add(BRICK_ATLAS_TEXTURE_RESOURCE)
+    .add(BRICK_SAMPLER_RESOURCE);
+
+resources.createGroup()
+    .add(BRICK_MATERIAL_ALBEDO_RESOURCE)
+    .add(BRICK_MATERIAL_METAL_ROUGH_RESOURCE)
+    .add(BRICK_MATERIAL_EMISSIVE_RESOURCE)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+  @builtin(position) coord: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+) -> @location(0) vec4<f32> {
+    let ray = camera_ray_from_uv(uv, camera);
+
+    let hit = brick_clipmap_trace(ray.origin, ray.direction, 0.0, ${FAR.toFixed(1)}, settings.cascade_count);
+
+    if (hit.kind == BRICK_TRACE_MISS) {
+        return vec4<f32>(0.08, 0.08, 0.1, 1.0);
+    }
+
+    if (hit.kind == BRICK_TRACE_UNRESOLVED) {
+        // the march ran out of steps
+        return vec4<f32>(1.0, 0.0, 1.0, 1.0);
+    }
+
+    if (dot(hit.normal, ray.direction) > 0.0) {
+        // a back face: the probes count it and shade nothing (§8.4)
+        return vec4<f32>(0.1, 0.1, 0.4, 1.0);
+    }
+
+    if (settings.channel == ${ProbeClipmapDebugBrickMaterialChannel.Albedo}u) {
+        let material = probe_clipmap_hit_material(hit.position, hit.normal, hit.cascade);
+
+        if (!material.found) {
+            // the source does not know the surface: the hit is black to the probes
+            return vec4<f32>(0.3, 0.0, 0.0, 1.0);
+        }
+
+        return vec4<f32>(material.albedo + material.emissive, 1.0);
+    }
+
+    let metal_rough = probe_clipmap_hit_metal_rough(hit.position, hit.normal, hit.cascade);
+
+    if (metal_rough.z == 0.0) {
+        return vec4<f32>(0.3, 0.0, 0.0, 1.0);
+    }
+
+    return vec4<f32>(metal_rough.xy, 0.0, 1.0);
+}
+`, [
+        chunk_camera_ray_from_uv,
+        chunk_brick_clipmap_trace,
+        chunk_probe_clipmap_hit_material,
+        chunk_probe_clipmap_hit_metal_rough,
+    ]);
+
+/**
+ * The view's scene as the probes' rays read its material: each pixel's camera ray traced through the
+ * brick clipmap as {@link ProbeClipmapDebugView.BrickClipmap} traces it, and the hit's material read as
+ * the shade reads a probe ray's (`probe_clipmap_hit_material`), from the brick material: its diffuse
+ * albedo plus emissive, or its metalness and roughness.
+ *
+ * Dark red is a hit whose source does not know its surface, black to the probes; dark blue a back
+ * face, which they count and do not shade; magenta a ray whose steps ran out.
+ *
+ * @type {ImageShader}
+ */
+export const shader_probe_clipmap_debug_brick_material = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Probe Clipmap Debug / Brick Material",
+        resources,
+        body,
+    }),
+    targets: [{
+        format: "rgba8unorm"
+    }]
+});
+
+/**
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {GPUViewContext} options.view
+ * @param {number[]} options.resolution
+ * @param {GPUBrickClipmap} options.brick_clipmap built this frame, before this pass
+ * @param {{write_bindings: function(Object): Object}} options.material what binds the brick material's planes
+ * @param {ProbeClipmapDebugBrickMaterialChannel} options.channel
+ * @returns {number} graph handle of the `rgba8unorm` image
+ */
+export function graph_probe_clipmap_debug_brick_material({
+    graph,
+    view,
+    resolution,
+    brick_clipmap,
+    material,
+    channel
+}) {
+    assert.defined(graph, 'graph');
+    assert.defined(view, 'view');
+    assert.isArrayLike(resolution, 'resolution');
+    assert.defined(brick_clipmap, 'brick_clipmap');
+    assert.isFunction(material?.write_bindings, 'material.write_bindings');
+    assert.enum(channel, ProbeClipmapDebugBrickMaterialChannel, 'channel');
+
+    const data = {};
+    const settings = { cascade_count: brick_clipmap.cascade_count, channel };
+
+    const pass = graph.add("Probe Clipmap Debug / Brick Material", data, (data, resources, context) => {
+        const output = resources.get(data.output);
+        const bindings = {
+            settings,
+            camera: view.camera.buffer,
+        };
+
+        brick_clipmap.write_bindings(bindings);
+        material.write_bindings(bindings);
+
+        shader_probe_clipmap_debug_brick_material.draw({
+            encoder: context.encoder,
+            bindings,
+            colorAttachments: [{
+                loadOp: "clear",
+                storeOp: "store",
+                clearValue: [0, 0, 0, 1],
+                view: output.obtainView(),
+            }],
+        });
+    });
+
+    data.output = pass.create("probe_clipmap_debug", TextureResourceDescriptor.from({
+        format: "rgba8unorm",
+        resolution,
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
+    }));
+
+    return data.output;
+}