@woosh/meep-engine 3.61.2 → 3.61.3

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

@@ -1 +1 @@
-{"version":3,"file":"ProbeClipmapSettings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;GAgBG;AACH;IAaI;;;OAGG;IACH,mCAIC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;;OAGG;IACH,wCAKC;IAjBD;;;OAGG;IACH,uCAEC;IAyBD;;OAEG;IACH,gCAKC;IAlBD;;;;;OAKG;IACH,+BAEC;IAuBD;;OAEG;IACH,kCAIC;IAhBD;;;;OAIG;IACH,iCAEC;IAuBD;;OAEG;IACH,mCAKC;IAlBD;;;;;OAKG;IACH,kCAEC;IAyBD;;;OAGG;IACH,mCAMC;IArBD;;;;;;OAMG;IACH,kCAEC;IAoCD;;;OAGG;IACH,oCAKC;IA7BD;;;;;;;;;;;;;;;OAeG;IACH,mCAEC;IA6CD;;;OAGG;IACH,mCAKC;IAvCD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,kCAEC;IAoCD;;OAEG;IACH,iCAIC;IA5BD;;;;;;;;;;;;;;;;OAgBG;IACH,gCAEC;IAsBD;;;OAGG;IACH,mCAIC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;;OAGG;IACH,wCAKC;IAjBD;;;OAGG;IACH,uCAEC;IAyBD;;OAEG;IACH,6BAKC;IAlBD;;;;;OAKG;IACH,4BAEC;IAuBD;;;OAGG;IACH,mCAMC;IAnBD;;;;OAIG;IACH,kCAEC;IAyBD;;OAEG;IACH,gCAKC;IAjBD;;;;OAIG;IACH,+BAEC;IAuBD;;;;OAIG;IACH,8BAKC;IAnBD;;;;OAIG;IACH,6BAEC;IAyBD;;;OAGG;IACH,0BAIC;IAjBD;;;;OAIG;IACH,yBAEC;IAYD;;;;;OAKG;IACH,iCAEC;IAED;;;OAGG;IACH,+BAEC;IAeD;;;OAGG;IACH,yCAIC;IAnBD;;;;;;OAMG;IACH,wCAEC;IAuBD;;OAEG;IACH,+CAMC;IAlBD;;;;OAIG;IACH,8CAEC;IAwBD;;OAEG;IACH,4CAKC;IAjBD;;;;OAIG;IACH,2CAEC;IAuBD;;;OAGG;IACH,0CAKC;IAlBD;;;;OAIG;IACH,yCAEC;IA2BD;;OAEG;IACH,+BAKC;IApBD;;;;;;;OAOG;IACH,8BAEC;IAyBD;;OAEG;IACH,mCAIC;IAlBD;;;;;;OAMG;IACH,kCAEC;IAwBD;;OAEG;IACH,+BAIC;IAlBD;;;;;;OAMG;IACH,8BAEC;IAsBD;;OAEG;IACH,0BAIC;IAhBD;;;;OAIG;IACH,yBAEC;;CAUJ"}
+{"version":3,"file":"ProbeClipmapSettings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH;IAaI;;;OAGG;IACH,mCAIC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;;OAGG;IACH,wCAKC;IAjBD;;;OAGG;IACH,uCAEC;IAyBD;;OAEG;IACH,gCAKC;IAlBD;;;;;OAKG;IACH,+BAEC;IAuBD;;OAEG;IACH,kCAIC;IAhBD;;;;OAIG;IACH,iCAEC;IAuBD;;OAEG;IACH,mCAKC;IAlBD;;;;;OAKG;IACH,kCAEC;IAyBD;;;OAGG;IACH,mCAMC;IArBD;;;;;;OAMG;IACH,kCAEC;IAsCD;;;OAGG;IACH,oCAKC;IA/BD;;;;;;;;;;;;;;;;;OAiBG;IACH,mCAEC;IAsCD;;;OAGG;IACH,mCAIC;IA/BD;;;;;;;;;;;;;;;;;;OAkBG;IACH,kCAEC;IAuBD;;;OAGG;IACH,mCAIC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;;OAGG;IACH,wCAKC;IAjBD;;;OAGG;IACH,uCAEC;IAyBD;;OAEG;IACH,6BAKC;IAlBD;;;;;OAKG;IACH,4BAEC;IAuBD;;;OAGG;IACH,mCAMC;IAnBD;;;;OAIG;IACH,kCAEC;IAyBD;;OAEG;IACH,gCAKC;IAjBD;;;;OAIG;IACH,+BAEC;IAuBD;;;;OAIG;IACH,8BAKC;IAnBD;;;;OAIG;IACH,6BAEC;IAyBD;;;OAGG;IACH,0BAIC;IAjBD;;;;OAIG;IACH,yBAEC;IAYD;;;;;OAKG;IACH,iCAEC;IAED;;;OAGG;IACH,+BAEC;IAeD;;;OAGG;IACH,yCAIC;IAnBD;;;;;;OAMG;IACH,wCAEC;IAuBD;;OAEG;IACH,+CAMC;IAlBD;;;;OAIG;IACH,8CAEC;IAwBD;;OAEG;IACH,4CAKC;IAjBD;;;;OAIG;IACH,2CAEC;IAuBD;;;OAGG;IACH,0CAKC;IAlBD;;;;OAIG;IACH,yCAEC;IA2BD;;OAEG;IACH,+BAKC;IApBD;;;;;;;OAOG;IACH,8BAEC;IAyBD;;OAEG;IACH,mCAIC;IAlBD;;;;;;OAMG;IACH,kCAEC;IAwBD;;OAEG;IACH,+BAIC;IAlBD;;;;;;OAMG;IACH,8BAEC;IAsBD;;OAEG;IACH,0BAIC;IAhBD;;;;OAIG;IACH,yBAEC;;CAUJ"}

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

@@ -1,7 +1,5 @@
 import { assert } from "../../../../core/assert.js";
 import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
-import { MESH_CARD_CAPTURE_BUDGET_MAX } from "../../geometry/sdf/cards/GPUMeshCardSets.js";
-import { MeshCardCaptureMode } from "../../geometry/sdf/cards/MeshCardCaptureMode.js";
 import { MESH_SDF_BAKE_BUDGET_MAX } from "../../geometry/sdf/GPUGeometrySDFManager.js";
 import { ProbeClipmapDebugView } from "./debug/ProbeClipmapDebugView.js";
 import { FRUSTUM_RAY_BUDGET_FRACTION } from "./probe/PROBE_CLIPMAP.js";
@@ -11,9 +9,9 @@ import { FRUSTUM_RAY_BUDGET_FRACTION } from "./probe/PROBE_CLIPMAP.js";
  * read every frame the mode runs (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §10).
  *
  * Three kinds of field, by what a change costs:
- * - **structure**: the cascade counts and resolutions, the brick voxel, the probe spacing, and the
- *   radiance and depth resolutions. A change destroys the GI and builds it again at the next frame,
- *   so its bricks and probes warm up from nothing.
+ * - **structure**: the cascade counts and resolutions, the brick voxel, the probe spacing, the
+ *   radiance and depth resolutions, and where hits take their material. A change destroys the GI and
+ *   builds it again at the next frame, so its bricks and probes warm up from nothing.
  * - **the mesh caches**: {@link mesh_sdf_voxel_size} and {@link mesh_sdf_max_bricks}. A change bakes
  *   every cached geometry again.
  * - **budgets and times**: they size a frame's work and set uniforms, and take effect the next frame
@@ -168,7 +166,9 @@ export class ProbeClipmapSettings {
      * §6.4). Over Sponza's fill, its 103 geometries all coarsened by the cap, with the budgets
      * interleaved in one process, evaluate costs 798 µs plus 8.6 µs a brick at the median, which
      * reaches 1 ms at 23. At 23 the fill's evaluate costs 840 µs a frame at the median and 5.3 ms at
-     * worst, and every geometry is resident after 5,712 frames of baking.
+     * worst, and every geometry is resident after 5,712 frames of baking. Finding the slots that hold a
+     * frame's bricks already and comparing their bytes (the key and resolve passes) adds 29 µs at the
+     * median.
      *
      * On the AMD iGPU (RDNA2) the same 23 bricks cost 26 ms a frame at the median and 79 ms at worst,
      * and no budget fits 1 ms: one brick costs 2.3 ms there.
@@ -189,79 +189,39 @@ export class ProbeClipmapSettings {
         this.#mesh_sdf_bake_budget = v;
     }
 
-    #card_capture_budget = 16384;
+    #surface_bake_budget = 512;
 
     /**
-     * Card pages captured a frame at most: new (geometry, material) pairs first, then recaptures of
-     * materials that changed (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.5). A time knob. A page is 64
-     * texels, a thread each, and a texel is a ray through its card's slab, up to four alpha draws, and
-     * a material sample. A frame with nothing to capture spends nothing.
+     * Model Surface Cache bricks surveyed and baked a frame at most: fields' surveys first, then new
+     * (geometry, material) pairs, then bakes again of materials that changed. A time knob. A brick is a
+     * thread a texel to find which hold surface, a workgroup of 64 rays for each that does, each ray up
+     * to four alpha draws and a material sample, against the pair's geometry alone, and a workgroup for
+     * each of its blocks to code them; a survey's brick is its first pass alone. A frame with nothing to
+     * do spends nothing. A cache is held for each pair the SDF world draws: for every 4³ block of its
+     * geometry's field's bricks that can hold surface, a block of each plane that varies over the pair's
+     * surface (48 B of albedo, 20 B of metalness and roughness, 256 B of emissive) and 8 B of presence; a
+     * pair that varies in no plane is neither surveyed nor baked.
      *
-     * The default is derived against 1 ms a frame on the RTX 4090, as {@link mesh_sdf_bake_budget}
-     * is. Over Sponza's 103 card sets (154,138 pages), recaptured with the budgets interleaved frame by
-     * frame in one process, 16,384 pages cost 0.33, 0.43 and 0.87 ms at the median in three runs and
-     * 32,768 went past 1 ms in all three; the cost turns steeply between the two. The runs shared the
-     * GPU with another load of 40–73%, which is in the medians: the least loaded frames cost 0.11 ms at
-     * 16,384. At the default Sponza's cards are captured in 10 frames.
-     *
-     * Re-derived once the material reads became trilinear at a texel's footprint (2026-10-30), which
-     * costs 1.30× at the median, timed on the same pages in the same frame: 16,384 pages cost 0.54 and
-     * 0.55 ms at the median in two runs (the old capture 0.54 ms beside them), 32,768 cost 1.48 and
-     * 1.52 ms, and the least loaded frames 0.15 ms at 16,384.
-     *
-     * On the AMD iGPU (RDNA2), measured before that, a page costs 0.78 µs: 16,384 pages cost 33.5 ms at
-     * the median, and about 1,290 fit 1 ms (1,024 cost 0.80 ms).
-     *
-     * Derived for {@link MeshCardCaptureMode.Trace}. A rastered card set is taken whole, the frame's
-     * last past the budget, and a frame also stops at what its scratch holds: at the largest budget
-     * Sponza's recapture took 13 frames on the iGPU, 2.5 ms of capture a frame on average.
+     * The default is derived against 1 ms a frame on the RTX 4090, as {@link mesh_sdf_bake_budget} is.
+     * Over Sponza's 103 caches (115,978 bricks), baked again with the budgets interleaved frame by frame
+     * in one process, 512 bricks cost 0.77 to 0.95 ms at the median in four runs (1.9 to 2.5 ms at the
+     * 90th percentile), and 256 cost 0.38 to 0.42 ms, before the blocks are coded, which adds 0.08 ms at
+     * 512. Runs sharing the GPU with another load of 38-73% read 0.95 to 1.34 ms at 512. At the default
+     * Sponza's caches are baked in 227 frames.
      * @returns {number}
      */
-    get card_capture_budget() {
-        return this.#card_capture_budget;
-    }
-
-    /**
-     * @param {number} v a positive integer, at most {@link MESH_CARD_CAPTURE_BUDGET_MAX}: a workgroup a
-     *        page in one dispatch row
-     */
-    set card_capture_budget(v) {
-        assert.isPositiveInteger(v, 'card_capture_budget');
-        assert.lessThanOrEqual(v, MESH_CARD_CAPTURE_BUDGET_MAX, 'card_capture_budget');
-
-        this.#card_capture_budget = v;
-    }
-
-    #card_capture_mode = MeshCardCaptureMode.Raster;
-
-    /**
-     * How card pages are captured: each card drawn through its material's own template and textures,
-     * or a ray a texel against the geometry's BLAS with the path tracer's material sampling. A change
-     * captures every card set again.
-     *
-     * Raster is the default. The trace took one level-0 tap of the material's 64² resident copy a
-     * texel and kept it, which aliased: on Sponza's outer wall the brick texture's dark band, every
-     * 12.8 card texels, landed on a row of texels once and between rows at its other repeats, a seam
-     * across the wall. The raster samples the texture's mips at the card texel's footprint, as UE's
-     * card capture does, and since 2026-10-30 the trace reads the resident copy's mips there too,
-     * trilinearly, at 1.30× its cost (see {@link card_capture_budget}). Against the one-tap trace, the
-     * cards' colours agreed with the raster's to 3 codes on average over Sponza's wall, floor, ceiling
-     * and banners, and recapturing all of Sponza (154,138 pages) at the largest budget, the two
-     * interleaved in one process, cost the trace 9.1–12.7 ms and the raster 0.6 ms on the RTX 4090,
-     * and 335 ms against 33 ms on the AMD iGPU (RDNA2).
-     * @returns {MeshCardCaptureMode}
-     */
-    get card_capture_mode() {
-        return this.#card_capture_mode;
+    get surface_bake_budget() {
+        return this.#surface_bake_budget;
     }
 
     /**
-     * @param {MeshCardCaptureMode} v
+     * @param {number} v a positive integer: a frame lists every texel of its bricks in one storage
+     *        binding, which the bake checks against the device
      */
-    set card_capture_mode(v) {
-        assert.enum(v, MeshCardCaptureMode, 'card_capture_mode');
+    set surface_bake_budget(v) {
+        assert.isPositiveInteger(v, 'surface_bake_budget');
 
-        this.#card_capture_mode = v;
+        this.#surface_bake_budget = v;
     }
 
     #probe_cascade_count = 5;

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

@@ -28,19 +28,9 @@ export const BRICK_CLIPMAP_STORE_PENDING: number;
  */
 export const BRICK_OCCUPANCY_BLOCK: number;
 /**
- * Texels of a cell's object grid on a side: one object per 2³ texels of the brick's 8³ (§7.3).
- * @type {number}
- */
-export const BRICK_OBJECT_CELLS_PER_AXIS: number;
-/**
- * Objects a slot holds: the `meshes` row nearest in each of its 2³-texel cells, 0 for none.
- * @type {number}
- */
-export const BRICK_OBJECT_CELLS: number;
-/**
- * The `meshes` rows an object cell can name: one more than the largest row that fits in the 24 bits
- * the object decision packs a row into beside its distance byte (`chunk_brick_object`). A row past it
- * writes no object, as a provider that cannot name a row does (§7.6, contract 5).
+ * The `meshes` rows a texel's key can name: one more than the largest row that fits in the 24 bits the
+ * key packs a row into beside its distance byte (`chunk_brick_object`). A row past it names none, as a
+ * provider that cannot name a row does (§7.6, contract 8).
  * @type {number}
  */
 export const BRICK_OBJECT_ROW_LIMIT: number;
@@ -51,15 +41,22 @@ export const BRICK_OBJECT_ROW_LIMIT: number;
  */
 export const BRICK_STAGING_DISTANCE_WORDS: number;
 /**
- * The word of a build slot that asks for its cell again (§7.6, contract 7), after its distances and
- * its objects: clear makes it 0, and a provider that could not finish the cell this frame writes 1.
+ * The word of a build slot that asks for its cell again (§7.6, contract 7), after its distances: clear
+ * makes it 0, and a provider that could not finish the cell this frame writes 1.
  * Free then puts the key back on the ring rather than out of the pending set, and the cell is built
  * again from what the frame stored.
  * @type {number}
  */
 export const BRICK_STAGING_RETRY_WORD: number;
 /**
- * Words of a build slot in the staging: its distances, its objects, then its retry word.
+ * The first of a build slot's surface words, after its retry word: a word a texel, `x + 8 (y + 8 z)`,
+ * the `meshes` row whose surface the texel holds, the provider's that gave its distance (§7.6,
+ * contract 8), 0 for none. What the cell's material is gathered by; the store does not keep it.
+ * @type {number}
+ */
+export const BRICK_STAGING_SURFACE_WORDS: number;
+/**
+ * Words of a build slot in the staging: its distances, its retry word, then its surfaces.
  * @type {number}
  */
 export const BRICK_STAGING_WORDS: number;
@@ -123,6 +120,12 @@ export const BRICK_TAKE_FIRST: number;
  * @type {number}
  */
 export const BRICK_TAKE_COUNT: number;
+/**
+ * Three words: the indirect dispatch of a thread a texel of the taken cells, 8³ a cell, in workgroups of
+ * {@link BRICK_THREAD_WORKGROUP_SIZE}.
+ * @type {number}
+ */
+export const BRICK_TAKE_TEXEL_DISPATCH: number;
 /**
  * Words of the take buffer.
  * @type {number}

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

@@ -1 +1 @@
-{"version":3,"file":"BRICK_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/BRICK_CLIPMAP.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,oCAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,kCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,yCAFU,MAAM,CAEkD;AAElE;;;;GAIG;AACH,0CAFU,MAAM,CAEmD;AAEnE;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;GAGG;AACH,iCAFU,MAAM,CAEmD;AAEnE;;;;;GAKG;AACH,qCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,2CAFU,MAAM,CAE2D;AAE3E;;;;;;GAMG;AACH,uCAFU,MAAM,CAE0E;AAE1F;;;GAGG;AACH,kCAFU,MAAM,CAEgD;AAEhE;;;;GAIG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,0CAFU,MAAM,CAE8B;AAM9C;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAQnC;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;;GAIG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAOlC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;GAGG;AACH,qCAFU,MAAM,CAEwB"}
+{"version":3,"file":"BRICK_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/BRICK_CLIPMAP.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,oCAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,kCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,yCAFU,MAAM,CAEkD;AAElE;;;;GAIG;AACH,0CAFU,MAAM,CAEmD;AAEnE;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;;GAKG;AACH,qCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,2CAFU,MAAM,CAE2D;AAE3E;;;;;;GAMG;AACH,uCAFU,MAAM,CAEqD;AAErE;;;;;GAKG;AACH,0CAFU,MAAM,CAEwD;AAExE;;;GAGG;AACH,kCAFU,MAAM,CAE4E;AAE5F;;;;GAIG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,0CAFU,MAAM,CAE8B;AAM9C;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAQnC;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;;GAIG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,+BAFU,MAAM,CAEmB;AAOnC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;GAGG;AACH,qCAFU,MAAM,CAEwB"}

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

@@ -46,21 +46,9 @@ export const BRICK_CLIPMAP_STORE_PENDING = BRICK_CLIPMAP_EMPTY + 2;
 export const BRICK_OCCUPANCY_BLOCK = 4;
 
 /**
- * Texels of a cell's object grid on a side: one object per 2³ texels of the brick's 8³ (§7.3).
- * @type {number}
- */
-export const BRICK_OBJECT_CELLS_PER_AXIS = 4;
-
-/**
- * Objects a slot holds: the `meshes` row nearest in each of its 2³-texel cells, 0 for none.
- * @type {number}
- */
-export const BRICK_OBJECT_CELLS = BRICK_OBJECT_CELLS_PER_AXIS ** 3;
-
-/**
- * The `meshes` rows an object cell can name: one more than the largest row that fits in the 24 bits
- * the object decision packs a row into beside its distance byte (`chunk_brick_object`). A row past it
- * writes no object, as a provider that cannot name a row does (§7.6, contract 5).
+ * The `meshes` rows a texel's key can name: one more than the largest row that fits in the 24 bits the
+ * key packs a row into beside its distance byte (`chunk_brick_object`). A row past it names none, as a
+ * provider that cannot name a row does (§7.6, contract 8).
  * @type {number}
  */
 export const BRICK_OBJECT_ROW_LIMIT = 1 << 24;
@@ -73,19 +61,27 @@ export const BRICK_OBJECT_ROW_LIMIT = 1 << 24;
 export const BRICK_STAGING_DISTANCE_WORDS = MESH_SDF_BRICK_TEXEL_COUNT / 4;
 
 /**
- * The word of a build slot that asks for its cell again (§7.6, contract 7), after its distances and
- * its objects: clear makes it 0, and a provider that could not finish the cell this frame writes 1.
+ * The word of a build slot that asks for its cell again (§7.6, contract 7), after its distances: clear
+ * makes it 0, and a provider that could not finish the cell this frame writes 1.
  * Free then puts the key back on the ring rather than out of the pending set, and the cell is built
  * again from what the frame stored.
  * @type {number}
  */
-export const BRICK_STAGING_RETRY_WORD = BRICK_STAGING_DISTANCE_WORDS + BRICK_OBJECT_CELLS;
+export const BRICK_STAGING_RETRY_WORD = BRICK_STAGING_DISTANCE_WORDS;
 
 /**
- * Words of a build slot in the staging: its distances, its objects, then its retry word.
+ * The first of a build slot's surface words, after its retry word: a word a texel, `x + 8 (y + 8 z)`,
+ * the `meshes` row whose surface the texel holds, the provider's that gave its distance (§7.6,
+ * contract 8), 0 for none. What the cell's material is gathered by; the store does not keep it.
  * @type {number}
  */
-export const BRICK_STAGING_WORDS = BRICK_STAGING_RETRY_WORD + 1;
+export const BRICK_STAGING_SURFACE_WORDS = BRICK_STAGING_RETRY_WORD + 1;
+
+/**
+ * Words of a build slot in the staging: its distances, its retry word, then its surfaces.
+ * @type {number}
+ */
+export const BRICK_STAGING_WORDS = BRICK_STAGING_SURFACE_WORDS + MESH_SDF_BRICK_TEXEL_COUNT;
 
 /**
  * Lanes of the passes that run a workgroup a taken cell: free, store and the mesh provider's walk,
@@ -168,11 +164,18 @@ export const BRICK_TAKE_FIRST = 6;
  */
 export const BRICK_TAKE_COUNT = 7;
 
+/**
+ * Three words: the indirect dispatch of a thread a texel of the taken cells, 8³ a cell, in workgroups of
+ * {@link BRICK_THREAD_WORKGROUP_SIZE}.
+ * @type {number}
+ */
+export const BRICK_TAKE_TEXEL_DISPATCH = 8;
+
 /**
  * Words of the take buffer.
  * @type {number}
  */
-export const BRICK_TAKE_WORDS = 8;
+export const BRICK_TAKE_WORDS = 11;
 
 /*
  What a march through the clipmap ends in, `BrickClipmapHit.kind` (chunk_brick_clipmap_trace.js), and

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

@@ -6,9 +6,9 @@
  * @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
@@ -20,11 +20,23 @@
  *   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
  */
 /**
  * @typedef {Object} BrickProvider
  * @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
@@ -36,20 +48,19 @@
  * - {@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 {
     /**
@@ -95,10 +106,6 @@ export class GPUBrickClipmap {
      * @returns {GPUTileAtlas3D}
      */
     get atlas(): GPUTileAtlas3D;
-    /**
-     * @returns {GPUBuffer}
-     */
-    get objects(): GPUBuffer;
     /**
      * The cascades' windows, a {@link CLIPMAP_LEVEL_ARRAY} as a uniform, finest first: as placed by the
      * last {@link graph_update}.
@@ -107,16 +114,15 @@ export class GPUBrickClipmap {
     get levels(): GPUBuffer;
     /**
      * 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
      */
     write_bindings(bindings: any): any;
     /**
-     * Slots of the atlas and the object cells.
+     * Slots of the atlas.
      * @returns {number}
      */
     get capacity(): number;
@@ -146,8 +152,9 @@ export class GPUBrickClipmap {
     built_for(settings: ProbeClipmapSettings): boolean;
     /**
      * 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
@@ -156,19 +163,21 @@ 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 }: {
+    graph_update({ graph, x, y, z, budget, providers, material_writers, scene, movers }: {
         graph: FrameGraph;
         x: number;
         y: number;
         z: number;
         budget: number;
         providers: ArrayLike<BrickProvider>;
+        material_writers?: ArrayLike<BrickMaterialWriter>;
         scene: GPUSceneContext | null;
         movers?: number;
     }): number;
@@ -190,9 +199,9 @@ export type BrickProviderContext = {
      */
     state: number;
     /**
-     * `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.
+     * `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.
      */
     take: number;
     /**
@@ -224,9 +233,24 @@ export type BrickProviderContext = {
      * its geometry caches
      */
     scene: GPUSceneContext;
+    /**
+     * the clipmap being built, whose {@link GPUBrickClipmapwrite_bindings }
+     * a material writer binds the stored bricks through; a provider, which runs before the store, reads
+     * none of it
+     */
+    clipmap: GPUBrickClipmap;
 };
 export type BrickProvider = {
     graph_write_bricks: (arg0: FrameGraph, arg1: BrickProviderContext) => void;
 };
+/**
+ * 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.
+ */
+export type BrickMaterialWriter = {
+    graph_write_material: (arg0: FrameGraph, arg1: BrickProviderContext) => void;
+};
 import { GPUTileAtlas3D } from "../../../texture/atlas/GPUTileAtlas3D.js";
 //# sourceMappingURL=GPUBrickClipmap.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUBrickClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/GPUBrickClipmap.js"],"names":[],"mappings":"AAwFA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA2JI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QAGU,UAAU,EAA1B,MAAM;OAiGhB;IAlQD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAkPX;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;;;;;OAQG;IACH,mCASC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,sBAFW,UAAU,MAAM,CAAC,QAiB3B;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAMnB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH;QAZ+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,MAAM,EAAtB,MAAM;QAC4B,SAAS,EAA3C,UAAU,aAAa,CAAC;QACM,KAAK,EAAnC,eAAe,GAAC,IAAI;QACH,MAAM,GAAvB,MAAM;QAEJ,MAAM,CAoGlB;IAmWD,gBAcC;;CACJ;mCA17BY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;8BACpF,OAAO,mCAAmC,EAAE,eAAe;;;;;;;WAyC1D,UAAU;;;;WACV,MAAM;;;;;;UACN,MAAM;;;;;aAGN,MAAM;;;;sBAEN,MAAM;;;;;mBAEN,MAAM;;;;gBACN,MAAM;mBACN,MAAM;;;;;;;;;;WAGN,eAAe;;;+BAMN,UAAU,QAAE,oBAAoB,KAAG,IAAI;;+BAxF/B,0CAA0C"}
+{"version":3,"file":"GPUBrickClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/GPUBrickClipmap.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;GAGG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAyJI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QAGU,UAAU,EAA1B,MAAM;OAgGhB;IA/PD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IA+OX;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;;;;OAOG;IACH,mCAQC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,sBAFW,UAAU,MAAM,CAAC,QAiB3B;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAMnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAb+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,MAAM,EAAtB,MAAM;QAC4B,SAAS,EAA3C,UAAU,aAAa,CAAC;QACiB,gBAAgB,GAAzD,UAAU,mBAAmB,CAAC;QACA,KAAK,EAAnC,eAAe,GAAC,IAAI;QACH,MAAM,GAAvB,MAAM;QAEJ,MAAM,CA6GlB;IAgWD,gBAcC;;CACJ;mCAx8BY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;8BACpF,OAAO,mCAAmC,EAAE,eAAe;;;;;;;WA+C1D,UAAU;;;;WACV,MAAM;;;;;;UACN,MAAM;;;;;aAGN,MAAM;;;;sBAEN,MAAM;;;;;mBAEN,MAAM;;;;gBACN,MAAM;mBACN,MAAM;;;;;;;;;;WAGN,eAAe;;;;;;aAEf,eAAe;;;+BAON,UAAU,QAAE,oBAAoB,KAAG,IAAI;;;;;;;;;iCAUvC,UAAU,QAAE,oBAAoB,KAAG,IAAI;;+BA1G/B,0CAA0C"}