@woosh/meep-engine 3.61.2 → 3.62.0

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

@@ -26,7 +26,6 @@ import {
 import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
 import { GPUTileAtlas3D } from "../../../texture/atlas/GPUTileAtlas3D.js";
 import {
-    BRICK_OBJECT_CELLS,
     BRICK_OCCUPANCY_BLOCK,
     BRICK_STAGING_WORDS,
     BRICK_STATE_FREE,
@@ -80,6 +79,12 @@ const BRICK_CASCADE_NEST_MARGIN = 1;
  */
 const BRICK_ATLAS_SLOTS_XY = 16;
 
+/**
+ * A build with no payload written after its store.
+ * @type {ReadonlyArray<BrickMaterialWriter>}
+ */
+const NO_MATERIAL_WRITERS = Object.freeze([]);
+
 /**
  * Boxes a moved window exposes at most: one an axis.
  * @type {number}
@@ -94,9 +99,9 @@ const SCROLL_BOXES_PER_CASCADE = 3;
  * @typedef {Object} BrickProviderContext
  * @property {FrameGraph} graph
  * @property {number} state `brick_state`'s handle: the ring's head and tail, and the free slots
- * @property {number} take `brick_take`'s handle: the taken keys' first and count, and the cell dispatch
- *   at {@link BRICK_TAKE_CELL_DISPATCH}, a workgroup a taken cell. Bind it read-only and dispatch
- *   through it.
+ * @property {number} take `brick_take`'s handle: the taken keys' first and count, the cell dispatch
+ *   at {@link BRICK_TAKE_CELL_DISPATCH}, a workgroup a taken cell, and the texel dispatch at
+ *   `BRICK_TAKE_TEXEL_DISPATCH`, a thread a texel of them. Bind it read-only and dispatch through it.
  * @property {number} staging `brick_staging`'s handle, `BRICK_STAGING_WORDS` words a build slot. A provider
  *   that could not finish a cell sets its `BRICK_STAGING_RETRY_WORD`, and the cell is built again (§7.6, contract 7)
  * @property {number} staging_capacity build slots the staging holds: at least the frame's taken cells
@@ -108,6 +113,9 @@ const SCROLL_BOXES_PER_CASCADE = 3;
  *   cell one brick of 7 voxels
  * @property {GPUSceneContext} scene the view's scene: its database, its TLAS over the mesh rows, and
  *   its geometry caches
+ * @property {GPUBrickClipmap} clipmap the clipmap being built, whose {@link GPUBrickClipmap#write_bindings}
+ *   a material writer binds the stored bricks through; a provider, which runs before the store, reads
+ *   none of it
  */
 
 /**
@@ -115,6 +123,16 @@ const SCROLL_BOXES_PER_CASCADE = 3;
  * @property {function(FrameGraph, BrickProviderContext): void} graph_write_bricks
  */
 
+/**
+ * What writes per-slot payloads of its own over the frame's taken cells once the store has put their
+ * bricks in their slots, such as their surface material (§7.6). The context's `state` is then the
+ * store's handle; a writer that records a pass replaces it with its own, so the next writer and the
+ * bricks' readers come after it. `take` holds the texel dispatch at `BRICK_TAKE_TEXEL_DISPATCH` too.
+ *
+ * @typedef {Object} BrickMaterialWriter
+ * @property {function(FrameGraph, BrickProviderContext): void} graph_write_material
+ */
+
 /**
  * The world as the probe clipmap's rays see it (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7):
  * {@link cascade_count} cascades of {@link resolution}³ cells around an anchor, a cell one brick of
@@ -126,20 +144,19 @@ const SCROLL_BOXES_PER_CASCADE = 3;
  * - {@link occupancy}, `r32uint`, a texel a {@link BRICK_OCCUPANCY_BLOCK}³-cell block of storage: how many
  *   of its cells a ray must read;
  * - {@link atlas}, `r8unorm` bricks of 8³ texels, the mesh caches' lattice and encoding, its slots
- *   handed out by a free list on the device;
- * - {@link objects}, 64 words a slot: the `meshes` row nearest in each 2³-texel cell of the brick.
+ *   handed out by a free list on the device.
  *
  * **A frame** ({@link graph_update}): the windows are placed around the anchor, coarsest first,
  * each child a parent cell inside its parent (`ClipmapCascadePlacement`), and what a move exposed is
  * queued (scroll). Then the frame takes up to its budget of queued cells, clears their staging, has
- * each provider merge its distances and objects into it, frees what needs no brick, stores what does,
+ * each provider merge its distances into it, frees what needs no brick, stores what does,
  * and counts the occupancy of the blocks it built. Every pass after scroll is sized by take's count
  * on the device, and scroll by the cells the moves exposed: nothing by the clipmap's size.
  *
  * **Capacity** (§7.10) starts at `2·N²·C` slots, a ground plane two cells thick through every
  * cascade. A take the free slots held back is counted on the device and read back, and the next
- * frame doubles the capacity: the atlas reserves more layers, and the objects and the free list grow
- * with a copy, the new slots pushed. Nothing shrinks.
+ * frame doubles the capacity: the atlas reserves more layers, and the free list grows with a copy,
+ * the new slots pushed. Nothing shrinks.
  */
 export class GPUBrickClipmap {
     /**
@@ -183,9 +200,6 @@ export class GPUBrickClipmap {
     /** @type {GPUTileAtlas3D} */
     #atlas;
 
-    /** @type {GPUBuffer} */
-    #objects;
-
     /** @type {GPUBuffer} */
     #free;
 
@@ -229,7 +243,7 @@ export class GPUBrickClipmap {
     /** @type {GPUBuffer} */
     #levels;
 
-    /** Slots of the atlas and the object cells. */
+    /** Slots of the atlas. */
     #capacity = 0;
 
     #ring_capacity = 0;
@@ -246,6 +260,15 @@ export class GPUBrickClipmap {
     #starved = 0;
     #grow_pending = false;
 
+    /** Frames recorded. */
+    #frame = 0;
+
+    /**
+     * The frame the capacity last grew in. A reading recorded before it asked for what that growth gave, so
+     * only a count that moved in a frame at or after it grows the capacity again.
+     */
+    #grown_frame = -1;
+
     #destroyed = false;
 
     /** The frame's scroll boxes: the smallest cell and the cascade, then the size and the first thread. */
@@ -294,6 +317,7 @@ export class GPUBrickClipmap {
         cascade_count: 0,
         levels: null,
         scene: null,
+        clipmap: null,
     };
 
     /**
@@ -367,7 +391,6 @@ export class GPUBrickClipmap {
 
         this.#atlas.reserve(capacity);
 
-        this.#objects = this.#create_buffer('brick objects', 4 * BRICK_OBJECT_CELLS * capacity, GPUBufferUsage.COPY_SRC);
         this.#free = this.#create_buffer('brick free list', 4 * capacity, GPUBufferUsage.COPY_SRC);
 
         const keys = resolution ** 3 * cascade_count;
@@ -423,13 +446,6 @@ export class GPUBrickClipmap {
         return this.#atlas;
     }
 
-    /**
-     * @returns {GPUBuffer}
-     */
-    get objects() {
-        return this.#objects;
-    }
-
     /**
      * The cascades' windows, a {@link CLIPMAP_LEVEL_ARRAY} as a uniform, finest first: as placed by the
      * last {@link graph_update}.
@@ -441,9 +457,8 @@ export class GPUBrickClipmap {
 
     /**
      * Put what the tracer's chunks read (`chunk_brick_clipmap_trace.js`) into a reader's bindings,
-     * under the names they take: the levels, the map, the occupancy, the atlas, its sampler and the
-     * object cells. The atlas and the objects are replaced when the capacity grows: take them each
-     * frame.
+     * under the names they take: the levels, the map, the occupancy, the atlas and its sampler. The atlas
+     * is replaced when the capacity grows: take it each frame.
      *
      * @param {Object} bindings
      * @returns {Object} bindings
@@ -454,13 +469,12 @@ export class GPUBrickClipmap {
         bindings.brick_occupancy = this.#occupancy_view;
         bindings.brick_atlas = this.#atlas.texture.obtainView();
         bindings.brick_sampler = MESH_SDF_SAMPLER;
-        bindings.brick_objects = this.#objects;
 
         return bindings;
     }
 
     /**
-     * Slots of the atlas and the object cells.
+     * Slots of the atlas.
      * @returns {number}
      */
     get capacity() {
@@ -520,8 +534,9 @@ export class GPUBrickClipmap {
 
     /**
      * Record the frame's build: place the windows around the anchor and queue what they exposed, then
-     * take up to `budget` queued cells, stage them through `providers` in order, and store what they
-     * need. Allocates nothing per frame once the staging holds the budget.
+     * take up to `budget` queued cells, stage them through `providers` in order, store what they
+     * need, and have `material_writers` write their payloads over the stored cells in order.
+     * Allocates nothing per frame once the staging holds the budget.
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
@@ -530,13 +545,14 @@ export class GPUBrickClipmap {
      * @param {number} options.z
      * @param {number} options.budget cells built a frame at most, `brick_build_budget`
      * @param {ArrayLike<BrickProvider>} options.providers merged into the staging in this order
+     * @param {ArrayLike<BrickMaterialWriter>} [options.material_writers] run after the store in this order
      * @param {GPUSceneContext|null} options.scene what the providers read: the view's scene
      * @param {number} [options.movers] the graph handle of the scene's mover list for the frame,
      *   `GPUSceneContext.graph_movers`; none queues nothing but the invalidated rows
      * @returns {number} the graph handle of the build's last write, which a pass reading the bricks reads
      *   to come after it
      */
-    graph_update({ graph, x, y, z, budget, providers, scene, movers = -1 }) {
+    graph_update({ graph, x, y, z, budget, providers, material_writers = NO_MATERIAL_WRITERS, scene, movers = -1 }) {
         assert.defined(graph, 'graph');
         assert.isPositiveInteger(budget, 'budget');
         assert.notOk(this.#destroyed, 'destroyed');
@@ -544,6 +560,7 @@ export class GPUBrickClipmap {
         if (this.#grow_pending) {
             this.#grow_pending = false;
             this.#grow();
+            this.#grown_frame = this.#frame;
         }
 
         this.#place(x, y, z);
@@ -598,6 +615,7 @@ export class GPUBrickClipmap {
         context.cascade_count = this.cascade_count;
         context.levels = this.#levels;
         context.scene = scene;
+        context.clipmap = this;
 
         for (let i = 0; i < providers.length; i++) {
             providers[i].graph_write_bricks(graph, context);
@@ -613,6 +631,8 @@ export class GPUBrickClipmap {
         store.make_side_effect();
 
         // a starved take grows the capacity, from a later frame
+        const read_frame = this.#frame;
+
         graph_read_buffer({ graph, buffer: store_data.state, offset: 4 * BRICK_STATE_STARVED, size: 4 })
             .then(reference => {
                 try {
@@ -620,7 +640,7 @@ export class GPUBrickClipmap {
 
                     if (!this.#destroyed && starved !== this.#starved) {
                         this.#starved = starved;
-                        this.#grow_pending = true;
+                        this.#grow_pending ||= read_frame >= this.#grown_frame;
                     }
                 } finally {
                     reference.release();
@@ -630,9 +650,18 @@ export class GPUBrickClipmap {
                 // a reading lost to a timeout or a lost device: the count runs on, and a later reading carries it
             });
 
+        // the payloads written over the stored bricks, each writer after the one before it
+        context.state = store_data.state;
+        context.take = store_data.take;
+
+        for (let i = 0; i < material_writers.length; i++) {
+            material_writers[i].graph_write_material(graph, context);
+        }
+
         this.#fresh = false;
+        this.#frame++;
 
-        return store_data.state;
+        return context.state;
     }
 
     /**
@@ -720,8 +749,8 @@ export class GPUBrickClipmap {
     }
 
     /**
-     * Double the capacity: the atlas reserves the slots, the objects and the free list grow with a
-     * copy, and the new slots are pushed by the next frame.
+     * Double the capacity: the atlas reserves the slots, the free list grows with a copy, and the new
+     * slots are pushed by the next frame.
      */
     #grow() {
         const old_capacity = this.#capacity;
@@ -733,7 +762,6 @@ export class GPUBrickClipmap {
 
         this.#atlas.reserve(capacity);
 
-        this.#objects = this.#regrow(this.#objects, 'brick objects', 4 * BRICK_OBJECT_CELLS * capacity);
         this.#free = this.#regrow(this.#free, 'brick free list', 4 * capacity);
         this.#capacity = capacity;
         this.#pushes.push(old_capacity, capacity - old_capacity);
@@ -785,7 +813,6 @@ export class GPUBrickClipmap {
         b.brick_pending = this.#pending;
         b.brick_free = this.#free;
         b.brick_staging = resources.get(data.staging);
-        b.brick_objects = this.#objects;
         b.brick_map = this.#brick_map_view;
         b.brick_occupancy = this.#occupancy_view;
         b.brick_atlas_store = this.#atlas.texture;
@@ -902,7 +929,6 @@ export class GPUBrickClipmap {
         b.brick_pending = this.#pending;
         b.brick_free = this.#free;
         b.brick_staging = resources.get(data.staging);
-        b.brick_objects = this.#objects;
         b.brick_map = this.#brick_map_view;
         b.brick_occupancy = this.#occupancy_view;
         b.brick_atlas_store = this.#atlas.texture;
@@ -999,7 +1025,7 @@ export class GPUBrickClipmap {
         this.#occupancy.destroy();
         this.#atlas.destroy();
 
-        for (const buffer of [this.#objects, this.#free, this.#ring, this.#pending, this.#state, this.#take, this.#movers, this.#invalidated, this.#no_movers, this.#staging, this.#runs, this.#levels]) {
+        for (const buffer of [this.#free, this.#ring, this.#pending, this.#state, this.#take, this.#movers, this.#invalidated, this.#no_movers, this.#staging, this.#runs, this.#levels]) {
             buffer?.destroy();
         }
     }

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

@@ -23,14 +23,15 @@ export const BRICK_RING_RESOURCE: ShaderResourceDescriptor;
  */
 export const BRICK_PENDING_RESOURCE: ShaderResourceDescriptor;
 /**
- * The free slots of the atlas and the object cells, as a slot stack whose count is
+ * The free slots of the atlas, as a slot stack whose count is
  * `brick_state[BRICK_STATE_FREE]`.
  * @type {ShaderResourceDescriptor}
  */
 export const BRICK_FREE_RESOURCE: ShaderResourceDescriptor;
 /**
  * The taken cells' staging, a build slot each of `BRICK_STAGING_WORDS` words: 512 distance bytes, four
- * a word, then 64 objects. Providers merge into it, and free and store read it.
+ * a word, the retry word, then each texel's surface row. Providers merge into it, free and
+ * store read it, and the material writers read its surfaces.
  * @type {ShaderResourceDescriptor}
  */
 export const BRICK_STAGING_RESOURCE: ShaderResourceDescriptor;

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap.js"],"names":[],"mappings":"AA4BA;;;GAGG;AACH,mCAFU,wBAAwB,CAE4F;AAE9H;;;;;GAKG;AACH,kCAFU,wBAAwB,CAEuE;AAEzG;;;;GAIG;AACH,kCAFU,wBAAwB,CAE6E;AAE/G;;;;GAIG;AACH,qCAFU,wBAAwB,CAEgG;AAElI;;;;GAIG;AACH,kCAFU,wBAAwB,CAE6E;AAE/G;;;;GAIG;AACH,qCAFU,wBAAwB,CAEmF;AAErH;;;;;;;;;;;;;;;;GAgBG;AACH,kCAFU,SAAS,CAwDhB;AAEH;;;;;;;;;;GAUG;AACH,0CAFU,SAAS,CAmBhB;AAMH;;;;;;;;;;GAUG;AACH,kDAFU,SAAS,CAYhB;yCAnMsC,sDAAsD;0BADrE,uCAAuC"}
+{"version":3,"file":"chunk_brick_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap.js"],"names":[],"mappings":"AA4BA;;;GAGG;AACH,mCAFU,wBAAwB,CAE4F;AAE9H;;;;;GAKG;AACH,kCAFU,wBAAwB,CAEuE;AAEzG;;;;GAIG;AACH,kCAFU,wBAAwB,CAE6E;AAE/G;;;;GAIG;AACH,qCAFU,wBAAwB,CAEgG;AAElI;;;;GAIG;AACH,kCAFU,wBAAwB,CAE6E;AAE/G;;;;;GAKG;AACH,qCAFU,wBAAwB,CAEmF;AAErH;;;;;;;;;;;;;;;;GAgBG;AACH,kCAFU,SAAS,CAwDhB;AAEH;;;;;;;;;;GAUG;AACH,0CAFU,SAAS,CAmBhB;AAMH;;;;;;;;;;GAUG;AACH,kDAFU,SAAS,CAYhB;yCApMsC,sDAAsD;0BADrE,uCAAuC"}

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

@@ -10,10 +10,9 @@ import {
     BRICK_CLIPMAP_EMPTY_INSIDE,
     BRICK_CLIPMAP_STORE_PENDING,
     BRICK_CLIPMAP_UNKNOWN,
-    BRICK_OBJECT_CELLS,
-    BRICK_OBJECT_CELLS_PER_AXIS,
     BRICK_STAGING_DISTANCE_WORDS,
     BRICK_STAGING_RETRY_WORD,
+    BRICK_STAGING_SURFACE_WORDS,
     BRICK_STAGING_WORDS,
     BRICK_STATE_FREE,
     BRICK_STATE_HEAD,
@@ -22,6 +21,7 @@ import {
     BRICK_TAKE_CELL_DISPATCH,
     BRICK_TAKE_COUNT,
     BRICK_TAKE_FIRST,
+    BRICK_TAKE_TEXEL_DISPATCH,
     BRICK_TAKE_WORD_DISPATCH,
     BRICK_THREAD_WORKGROUP_SIZE
 } from "./BRICK_CLIPMAP.js";
@@ -55,7 +55,7 @@ export const BRICK_RING_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick
 export const BRICK_PENDING_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick_pending", WebGPUArray.from(atomic_u32), true);
 
 /**
- * The free slots of the atlas and the object cells, as a slot stack whose count is
+ * The free slots of the atlas, as a slot stack whose count is
  * `brick_state[BRICK_STATE_FREE]`.
  * @type {ShaderResourceDescriptor}
  */
@@ -63,7 +63,8 @@ export const BRICK_FREE_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick
 
 /**
  * The taken cells' staging, a build slot each of `BRICK_STAGING_WORDS` words: 512 distance bytes, four
- * a word, then 64 objects. Providers merge into it, and free and store read it.
+ * a word, the retry word, then each texel's surface row. Providers merge into it, free and
+ * store read it, and the material writers read its surfaces.
  * @type {ShaderResourceDescriptor}
  */
 export const BRICK_STAGING_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick_staging", WebGPUArray.u32, true);
@@ -94,10 +95,9 @@ const BRICK_CLIPMAP_EMPTY_INSIDE = ${BRICK_CLIPMAP_EMPTY_INSIDE}u;
 const BRICK_CLIPMAP_STORE_PENDING = ${BRICK_CLIPMAP_STORE_PENDING}u;
 const BRICK_CLIPMAP_BAND_VOXELS = ${MESH_SDF_BAND_VOXELS}.0;
 
-const BRICK_OBJECT_CELLS = ${BRICK_OBJECT_CELLS}u;
-const BRICK_OBJECT_CELLS_PER_AXIS = ${BRICK_OBJECT_CELLS_PER_AXIS}u;
 const BRICK_STAGING_DISTANCE_WORDS = ${BRICK_STAGING_DISTANCE_WORDS}u;
 const BRICK_STAGING_RETRY_WORD = ${BRICK_STAGING_RETRY_WORD}u;
+const BRICK_STAGING_SURFACE_WORDS = ${BRICK_STAGING_SURFACE_WORDS}u;
 const BRICK_STAGING_WORDS = ${BRICK_STAGING_WORDS}u;
 const BRICK_CELL_WORKGROUP_SIZE = ${BRICK_CELL_WORKGROUP_SIZE}u;
 const BRICK_THREAD_WORKGROUP_SIZE = ${BRICK_THREAD_WORKGROUP_SIZE}u;
@@ -109,6 +109,7 @@ const BRICK_STATE_STARVED = ${BRICK_STATE_STARVED}u;
 
 const BRICK_TAKE_CELL_DISPATCH = ${BRICK_TAKE_CELL_DISPATCH}u;
 const BRICK_TAKE_WORD_DISPATCH = ${BRICK_TAKE_WORD_DISPATCH}u;
+const BRICK_TAKE_TEXEL_DISPATCH = ${BRICK_TAKE_TEXEL_DISPATCH}u;
 const BRICK_TAKE_FIRST = ${BRICK_TAKE_FIRST}u;
 const BRICK_TAKE_COUNT = ${BRICK_TAKE_COUNT}u;
 

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

@@ -10,6 +10,12 @@ export const BRICK_TRACE_STEPS: number;
  * @type {number}
  */
 export const BRICK_TRACE_NUDGE: number;
+/**
+ * The distance under which the march stands on a surface, in voxels of its cascade: UE's half voxel
+ * (§7.9). A hit is reported from anywhere between the surface and this far out.
+ * @type {number}
+ */
+export const BRICK_TRACE_HIT_VOXELS: number;
 /**
  * The brick map as the tracer reads it: an entry a cell, the cascades stacked along z.
  * @type {ShaderResourceDescriptor}
@@ -36,15 +42,11 @@ export const BRICK_SAMPLER_RESOURCE: ShaderResourceDescriptor;
  */
 export const BRICK_LEVELS_RESOURCE: ShaderResourceDescriptor;
 /**
- * The object cells: {@link BRICK_OBJECT_CELLS} `meshes` rows a slot, 0 for none.
- * @type {ShaderResourceDescriptor}
- */
-export const BRICK_OBJECTS_RESOURCE: ShaderResourceDescriptor;
-/**
- * A brick's distance at a point of its cell, and the field's gradient there.
+ * A brick's distance at a point of its cell, where its slot sits in the atlas, and the field's gradient.
  *
  * ```wgsl
  * fn brick_clipmap_sample(slot: u32, local: vec3<f32>, voxel: f32) -> f32 // local in voxels from the cell's corner
+ * fn brick_clipmap_slot_texel(slot: u32) -> vec3<u32>                      // the slot's texel 0 in the atlas
  * fn brick_clipmap_normal(slot: u32, local: vec3<f32>) -> vec3<f32>       // out of the solid, unit length
  * ```
  *
@@ -142,22 +144,6 @@ export const chunk_brick_clipmap_distance: CodeChunk;
  * @type {CodeChunk}
  */
 export const chunk_brick_clipmap_gradient: CodeChunk;
-/**
- * The `meshes` row whose surface a hit is on (§7.9), 0 for none.
- *
- * ```wgsl
- * fn brick_clipmap_object(hit: BrickClipmapHit) -> u32
- * ```
- *
- * The object cell of the texel nearest the hit moved half a voxel along the normal, onto the ray's
- * side: of a wall thinner than a voxel, whose two faces are in neighbouring object cells, it picks
- * the face the ray hit, as UE's object lookup does. A front face's normal is against the ray, and a
- * back face is counted, never shaded (§8.4), so the move is along the normal. A hit inside a solid
- * has no face: none.
- *
- * @type {CodeChunk}
- */
-export const chunk_brick_clipmap_object: CodeChunk;
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_brick_clipmap_trace.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap_trace.js"],"names":[],"mappings":"AAsBA;;;;GAIG;AACH,gCAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,gCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,yCAFU,wBAAwB,CAEoE;AAEtG;;;GAGG;AACH,+CAFU,wBAAwB,CAEgF;AAElH;;;GAGG;AACH,2CAFU,wBAAwB,CAEyE;AAE3G;;;GAGG;AACH,qCAFU,wBAAwB,CAEqF;AAEvH;;;GAGG;AACH,oCAFU,wBAAwB,CAEyE;AAE3G;;;GAGG;AACH,qCAFU,wBAAwB,CAE6E;AAE/G;;;;;;;;;;;;;GAaG;AACH,yCAFU,SAAS,CAsCZ;AAKP;;;;;;;;;;;;GAYG;AACH,yCAFU,SAAS,CAyBZ;AAIP;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wCAFU,SAAS,CAgFZ;AAKP;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCAFU,SAAS,CAoGZ;AAEP;;;;;;;;;;;;GAYG;AACH,2CAFU,SAAS,CAsCZ;AAIP;;;;;;;;;;;;;;GAcG;AACH,2CAFU,SAAS,CA0BZ;AAEP;;;;;;;;;;;;;;GAcG;AACH,yCAFU,SAAS,CAqBZ;yCA9fkC,sDAAsD;0BADrE,uCAAuC"}
+{"version":3,"file":"chunk_brick_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap_trace.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,gCAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,gCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,qCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,yCAFU,wBAAwB,CAEoE;AAEtG;;;GAGG;AACH,+CAFU,wBAAwB,CAEgF;AAElH;;;GAGG;AACH,2CAFU,wBAAwB,CAEyE;AAE3G;;;GAGG;AACH,qCAFU,wBAAwB,CAEqF;AAEvH;;;GAGG;AACH,oCAFU,wBAAwB,CAEyE;AAE3G;;;;;;;;;;;;;;GAcG;AACH,yCAFU,SAAS,CAyCZ;AAKP;;;;;;;;;;;;GAYG;AACH,yCAFU,SAAS,CAyBZ;AAIP;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wCAFU,SAAS,CAgFZ;AAKP;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCAFU,SAAS,CAoGZ;AAEP;;;;;;;;;;;;GAYG;AACH,2CAFU,SAAS,CAsCZ;AAIP;;;;;;;;;;;;;;GAcG;AACH,2CAFU,SAAS,CA0BZ;yCA7dkC,sDAAsD;0BADrE,uCAAuC"}

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

@@ -11,8 +11,6 @@ import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourc
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { chunk_tile_atlas_slot_origin } from "../../../texture/atlas/chunk_tile_atlas_slot_origin.js";
 import {
-    BRICK_OBJECT_CELLS,
-    BRICK_OBJECT_CELLS_PER_AXIS,
     BRICK_OCCUPANCY_BLOCK,
     BRICK_TRACE_HIT,
     BRICK_TRACE_MISS,
@@ -34,6 +32,13 @@ export const BRICK_TRACE_STEPS = 64;
  */
 export const BRICK_TRACE_NUDGE = 1 / 64;
 
+/**
+ * The distance under which the march stands on a surface, in voxels of its cascade: UE's half voxel
+ * (§7.9). A hit is reported from anywhere between the surface and this far out.
+ * @type {number}
+ */
+export const BRICK_TRACE_HIT_VOXELS = 0.5;
+
 /**
  * The brick map as the tracer reads it: an entry a cell, the cascades stacked along z.
  * @type {ShaderResourceDescriptor}
@@ -65,16 +70,11 @@ export const BRICK_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler("brick_sa
 export const BRICK_LEVELS_RESOURCE = ShaderResourceDescriptor.uniform("brick_levels", CLIPMAP_LEVEL_ARRAY);
 
 /**
- * The object cells: {@link BRICK_OBJECT_CELLS} `meshes` rows a slot, 0 for none.
- * @type {ShaderResourceDescriptor}
- */
-export const BRICK_OBJECTS_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick_objects", WebGPUArray.u32);
-
-/**
- * A brick's distance at a point of its cell, and the field's gradient there.
+ * A brick's distance at a point of its cell, where its slot sits in the atlas, and the field's gradient.
  *
  * ```wgsl
  * fn brick_clipmap_sample(slot: u32, local: vec3<f32>, voxel: f32) -> f32 // local in voxels from the cell's corner
+ * fn brick_clipmap_slot_texel(slot: u32) -> vec3<u32>                      // the slot's texel 0 in the atlas
  * fn brick_clipmap_normal(slot: u32, local: vec3<f32>) -> vec3<f32>       // out of the solid, unit length
  * ```
  *
@@ -87,10 +87,13 @@ export const BRICK_OBJECTS_RESOURCE = ShaderResourceDescriptor.storageBuffer("br
 export const chunk_brick_clipmap_sample = CodeChunk.from(
     //language=WGSL
     `
+fn brick_clipmap_slot_texel(slot: u32) -> vec3<u32> {
+    return tile_atlas_slot_origin(slot, textureDimensions(brick_atlas, 0).xy / ${MESH_SDF_BRICK_TEXELS}u, vec3<u32>(${MESH_SDF_BRICK_TEXELS}u));
+}
+
 fn brick_clipmap_tap(slot: u32, local: vec3<f32>) -> f32 {
     let atlas_size = textureDimensions(brick_atlas, 0);
-    let corner = tile_atlas_slot_origin(slot, atlas_size.xy / ${MESH_SDF_BRICK_TEXELS}u, vec3<u32>(${MESH_SDF_BRICK_TEXELS}u));
-    let uvw = (vec3<f32>(corner) + 0.5 + clamp(local, vec3<f32>(0.0), vec3<f32>(${MESH_SDF_BRICK_VOXELS}.0))) / vec3<f32>(atlas_size);
+    let uvw = (vec3<f32>(brick_clipmap_slot_texel(slot)) + 0.5 + clamp(local, vec3<f32>(0.0), vec3<f32>(${MESH_SDF_BRICK_VOXELS}.0))) / vec3<f32>(atlas_size);
 
     return textureSampleLevel(brick_atlas, brick_sampler, uvw, 0.0).r;
 }
@@ -360,7 +363,7 @@ fn brick_clipmap_trace(origin: vec3<f32>, direction: vec3<f32>, t_min: f32, t_ma
         let local = (march.position - march.cell_min) / march.voxel;
         let distance = brick_clipmap_sample(march.entry, local, march.voxel);
 
-        if (distance < 0.5 * march.voxel) {
+        if (distance < ${BRICK_TRACE_HIT_VOXELS} * march.voxel) {
             hit.kind = BRICK_TRACE_HIT;
             hit.t = march.t;
             hit.cascade = march.cascade;
@@ -482,42 +485,3 @@ fn brick_clipmap_gradient(position: vec3<f32>, cascade_count: u32) -> vec3<f32>
         chunk_brick_clipmap_window,
         chunk_brick_clipmap_distance,
     ]);
-
-/**
- * The `meshes` row whose surface a hit is on (§7.9), 0 for none.
- *
- * ```wgsl
- * fn brick_clipmap_object(hit: BrickClipmapHit) -> u32
- * ```
- *
- * The object cell of the texel nearest the hit moved half a voxel along the normal, onto the ray's
- * side: of a wall thinner than a voxel, whose two faces are in neighbouring object cells, it picks
- * the face the ray hit, as UE's object lookup does. A front face's normal is against the ray, and a
- * back face is counted, never shaded (§8.4), so the move is along the normal. A hit inside a solid
- * has no face: none.
- *
- * @type {CodeChunk}
- */
-export const chunk_brick_clipmap_object = CodeChunk.from(
-    //language=WGSL
-    `
-fn brick_clipmap_object(hit: BrickClipmapHit) -> u32 {
-    if (hit.kind != BRICK_TRACE_HIT || !brick_clipmap_entry_holds_slot(hit.slot)) {
-        return 0u;
-    }
-
-    let voxel = brick_levels[hit.cascade].cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
-
-    let local = (hit.position + 0.5 * voxel * hit.normal - hit.cell_min) / voxel;
-    let texel = vec3<u32>(clamp(round(local), vec3<f32>(0.0), vec3<f32>(${MESH_SDF_BRICK_VOXELS}.0)));
-    let cell = min(texel / 2u, vec3<u32>(${BRICK_OBJECT_CELLS_PER_AXIS - 1}u));
-
-    return brick_objects[hit.slot * ${BRICK_OBJECT_CELLS}u + cell.x + ${BRICK_OBJECT_CELLS_PER_AXIS}u * (cell.y + ${BRICK_OBJECT_CELLS_PER_AXIS}u * cell.z)];
-}
-`, [
-        chunk_brick_clipmap,
-        chunk_brick_clipmap_trace,
-    ]);
-
-chunk_brick_clipmap_object.requireResource(BRICK_OBJECTS_RESOURCE);
-chunk_brick_clipmap_object.requireResource(BRICK_LEVELS_RESOURCE);

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

@@ -38,11 +38,6 @@ export const MESH_BRICK_ROUNDS: number;
  * @type {number}
  */
 export const MESH_BRICK_ROUND_LIMIT: number;
-/**
- * The first of a build slot's object words.
- * @type {number}
- */
-export const MESH_BRICK_ACCUMULATOR_OBJECTS: number;
 /**
  * The word of the cell's flags for the frame, {@link MESH_BRICK_FLAG_TOUCHED} and
  * {@link MESH_BRICK_FLAG_UNFINISHED}. The walk that sets the first of them lists the cell for the
@@ -56,7 +51,7 @@ export const MESH_BRICK_ACCUMULATOR_FLAGS: number;
  */
 export const MESH_BRICK_ACCUMULATOR_WORDS: number;
 /**
- * A batch of the cell was made: the resolve merges its texel and object words.
+ * A batch of the cell was made: the resolve merges its texel words.
  * @type {number}
  */
 export const MESH_BRICK_FLAG_TOUCHED: number;

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

@@ -1 +1 @@
-{"version":3,"file":"MESH_BRICK.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MESH_BRICK.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,+BAFU,MAAM,CAE0C;AAE1D;;;;;;;;;;;GAWG;AACH,kCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;GAGG;AACH,sCAFU,MAAM,CAEyE;AAEzF;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;;GAKG;AACH,qCAFU,MAAM,CAEiI;AAUjJ;;;GAGG;AACH,6CAFU,MAAM,CAEyD;AAEzE;;;;;GAKG;AACH,2CAFU,MAAM,CAEgF;AAEhG;;;GAGG;AACH,2CAFU,MAAM,CAE6D;AAE7E;;;GAGG;AACH,sCAFU,MAAM,CAEyB;AAEzC;;;;;GAKG;AACH,yCAFU,MAAM,CAE4B;AAO5C;;;GAGG;AACH,2CAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,mDAFU,MAAM,CAEsC;AAEtD;;;GAGG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;GAGG;AACH,yCAFU,MAAM,CAEqD;AAErE;;;;GAIG;AACH,uCAFU,MAAM,CAEuD;AAEvE;;;GAGG;AACH,8CAFU,MAAM,CAE4D;AAE5E;;;GAGG;AACH,8CAFU,MAAM,CAEmE;AAEnF;;;GAGG;AACH,0CAFU,MAAM,CAE+D;AAE/E;;;GAGG;AACH,gDAFU,MAAM,CAEiE;AAEjF;;;GAGG;AACH,uCAFU,MAAM,CAE8D"}
+{"version":3,"file":"MESH_BRICK.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MESH_BRICK.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,+BAFU,MAAM,CAE0C;AAE1D;;;;;;;;;;;GAWG;AACH,kCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;GAGG;AACH,sCAFU,MAAM,CAEyE;AAEzF;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;;GAKG;AACH,qCAFU,MAAM,CAEiI;AASjJ;;;;;GAKG;AACH,2CAFU,MAAM,CAEuD;AAEvE;;;GAGG;AACH,2CAFU,MAAM,CAE6D;AAE7E;;;GAGG;AACH,sCAFU,MAAM,CAEyB;AAEzC;;;;;GAKG;AACH,yCAFU,MAAM,CAE4B;AAO5C;;;GAGG;AACH,2CAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,mDAFU,MAAM,CAEsC;AAEtD;;;GAGG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;GAGG;AACH,yCAFU,MAAM,CAEqD;AAErE;;;;GAIG;AACH,uCAFU,MAAM,CAEuD;AAEvE;;;GAGG;AACH,8CAFU,MAAM,CAE4D;AAE5E;;;GAGG;AACH,8CAFU,MAAM,CAEmE;AAEnF;;;GAGG;AACH,0CAFU,MAAM,CAE+D;AAE/E;;;GAGG;AACH,gDAFU,MAAM,CAEiE;AAEjF;;;GAGG;AACH,uCAFU,MAAM,CAE8D"}

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

@@ -1,5 +1,5 @@
 import { MESH_SDF_BRICK_TEXEL_COUNT } from "../../../../geometry/sdf/MESH_SDF.js";
-import { BRICK_CELL_WORKGROUP_SIZE, BRICK_OBJECT_CELLS } from "../BRICK_CLIPMAP.js";
+import { BRICK_CELL_WORKGROUP_SIZE } from "../BRICK_CLIPMAP.js";
 
 /*
  The mesh provider's device state (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7, as S9 built it).
@@ -63,26 +63,19 @@ export const MESH_BRICK_ROUNDS = 2;
 export const MESH_BRICK_ROUND_LIMIT = 1 + Math.ceil(Math.log2((1 << 20) / MESH_BRICK_BATCH) / Math.log2(MESH_BRICK_FRONTIER / MESH_BRICK_BATCH));
 
 /*
- A build slot's accumulators, MESH_BRICK_ACCUMULATOR_WORDS words: a word a texel holding 255 less the
- least byte the batches staged there, a word an object cell holding the largest object key the
- batches bid (`brick_object_key`), and the cell's flags for the frame. A texel or object word is 0
- when nothing reached it, so a buffer the device has zeroed starts empty, and the resolve leaves each
+ A build slot's accumulators, MESH_BRICK_ACCUMULATOR_WORDS words: a word a texel holding the largest
+ key the batches bid there (`brick_object_key`), its least byte and the row that gave it, then the
+ cell's flags for the frame. A texel word is 0 when nothing reached it, so a buffer the device has zeroed starts empty, and the resolve leaves each
  one it merges at 0 for the next frame; the cell's walk from the root clears the flags.
 */
 
-/**
- * The first of a build slot's object words.
- * @type {number}
- */
-export const MESH_BRICK_ACCUMULATOR_OBJECTS = MESH_SDF_BRICK_TEXEL_COUNT;
-
 /**
  * The word of the cell's flags for the frame, {@link MESH_BRICK_FLAG_TOUCHED} and
  * {@link MESH_BRICK_FLAG_UNFINISHED}. The walk that sets the first of them lists the cell for the
  * resolve: most taken cells set none, and the resolve never reads them.
  * @type {number}
  */
-export const MESH_BRICK_ACCUMULATOR_FLAGS = MESH_BRICK_ACCUMULATOR_OBJECTS + BRICK_OBJECT_CELLS;
+export const MESH_BRICK_ACCUMULATOR_FLAGS = MESH_SDF_BRICK_TEXEL_COUNT;
 
 /**
  * Words of a build slot's accumulators.
@@ -91,7 +84,7 @@ export const MESH_BRICK_ACCUMULATOR_FLAGS = MESH_BRICK_ACCUMULATOR_OBJECTS + BRI
 export const MESH_BRICK_ACCUMULATOR_WORDS = MESH_BRICK_ACCUMULATOR_FLAGS + 1;
 
 /**
- * A batch of the cell was made: the resolve merges its texel and object words.
+ * A batch of the cell was made: the resolve merges its texel words.
  * @type {number}
  */
 export const MESH_BRICK_FLAG_TOUCHED = 1;

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_mesh_brick_walk.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_walk.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,oCAFU,SAAS,CAoChB;0BAnEuB,0CAA0C"}
+{"version":3,"file":"chunk_mesh_brick_walk.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_walk.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,oCAFU,SAAS,CAmChB;0BAjEuB,0CAA0C"}

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

@@ -2,7 +2,6 @@ import { chunk_divide_round_up_u32 } from "../../../../shader/chunk/math/chunk_d
 import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
 import {
     MESH_BRICK_ACCUMULATOR_FLAGS,
-    MESH_BRICK_ACCUMULATOR_OBJECTS,
     MESH_BRICK_ACCUMULATOR_WORDS,
     MESH_BRICK_BATCH,
     MESH_BRICK_FLAG_TOUCHED,
@@ -39,7 +38,6 @@ const MESH_BRICK_BATCH = ${MESH_BRICK_BATCH}u;
 const MESH_BRICK_FRONTIER = ${MESH_BRICK_FRONTIER}u;
 const MESH_BRICK_RECORD_HEADER_WORDS = ${MESH_BRICK_RECORD_HEADER_WORDS}u;
 const MESH_BRICK_RECORD_WORDS = ${MESH_BRICK_RECORD_WORDS}u;
-const MESH_BRICK_ACCUMULATOR_OBJECTS = ${MESH_BRICK_ACCUMULATOR_OBJECTS}u;
 const MESH_BRICK_ACCUMULATOR_FLAGS = ${MESH_BRICK_ACCUMULATOR_FLAGS}u;
 const MESH_BRICK_ACCUMULATOR_WORDS = ${MESH_BRICK_ACCUMULATOR_WORDS}u;
 const MESH_BRICK_FLAG_TOUCHED = ${MESH_BRICK_FLAG_TOUCHED}u;