@woosh/meep-engine 3.58.0 → 3.59.0

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

@@ -37,6 +37,13 @@ export const BRICK_OBJECT_CELLS_PER_AXIS: number;
  * @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).
+ * @type {number}
+ */
+export const BRICK_OBJECT_ROW_LIMIT: number;
 /**
  * Words of a build slot's staged distances: 512 bytes, four texels a word, texel `t` in byte `t % 4`
  * of word `t / 4`.

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;;;;GAIG;AACH,2CAFU,MAAM,CAE2D;AAE3E;;;GAGG;AACH,kCAFU,MAAM,CAEqE;AAErF;;;;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;;;GAGG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;GAGG;AACH,iCAFU,MAAM,CAEmD;AAEnE;;;;;GAKG;AACH,qCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,2CAFU,MAAM,CAE2D;AAE3E;;;GAGG;AACH,kCAFU,MAAM,CAEqE;AAErF;;;;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"}

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

@@ -57,6 +57,14 @@ export const BRICK_OBJECT_CELLS_PER_AXIS = 4;
  */
 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).
+ * @type {number}
+ */
+export const BRICK_OBJECT_ROW_LIMIT = 1 << 24;
+
 /**
  * Words of a build slot's staged distances: 512 bytes, four texels a word, texel `t` in byte `t % 4`
  * of word `t / 4`.

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

@@ -12,6 +12,11 @@
  * @property {number} staging `brick_staging`'s handle, `BRICK_STAGING_WORDS` words a build slot
  * @property {GPUBuffer} ring the keys; taken key `b` sits at `(taken_first + b) & (ring_capacity - 1)`
  * @property {number} ring_capacity
+ * @property {GPUBuffer} pending a bit per key, set while the key is on the ring or being built. With `state` and
+ *   `ring`, the queue that a provider which learns on the device that a cell must be built again puts its key on,
+ *   with `brick_clipmap_enqueue` (contract 6). Such a pass writes `state` and hands its version on, as
+ *   `staging`.
+ * @property {number} budget cells taken a frame at most: what sizes a provider's own buffers of the taken cells
  * @property {number} resolution cells a cascade's window has a side
  * @property {number} cascade_count
  * @property {GPUBuffer} levels the cascades' windows, a {@link CLIPMAP_LEVEL_ARRAY}, finest first, a
@@ -200,6 +205,17 @@ export type BrickProviderContext = {
      */
     ring: GPUBuffer;
     ring_capacity: number;
+    /**
+     * a bit per key, set while the key is on the ring or being built. With `state` and
+     * `ring`, the queue that a provider which learns on the device that a cell must be built again puts its key on,
+     * with `brick_clipmap_enqueue` (contract 6). Such a pass writes `state` and hands its version on, as
+     * `staging`.
+     */
+    pending: GPUBuffer;
+    /**
+     * cells taken a frame at most: what sizes a provider's own buffers of the taken cells
+     */
+    budget: number;
     /**
      * cells a cascade's window has a side
      */

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":"AAiFA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA0JI;;;;;;OAMG;IACH;QAJ2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,UAAU,EAA1B,MAAM;OA8FhB;IA5PD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IA4OX;;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,CAgGlB;IAgWD,gBAcC;;CACJ;mCA36BY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;8BACpF,OAAO,mCAAmC,EAAE,eAAe;;;;;;;WAyC1D,UAAU;;;;WACV,MAAM;;;;;;UACN,MAAM;;;;aAGN,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":"AAiFA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA4JI;;;;;;OAMG;IACH;QAJ2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,UAAU,EAA1B,MAAM;OA8FhB;IA9PD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IA8OX;;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,CAkGlB;IAgWD,gBAcC;;CACJ;mCAp7BY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;8BACpF,OAAO,mCAAmC,EAAE,eAAe;;;;;;;WAyC1D,UAAU;;;;WACV,MAAM;;;;;;UACN,MAAM;;;;aAGN,MAAM;;;;;mBAEN,MAAM;;;;;;;;;;;YAKN,MAAM;;;;gBACN,MAAM;mBACN,MAAM;;;;;;;;;;WAGN,eAAe;;;+BAMN,UAAU,QAAE,oBAAoB,KAAG,IAAI;;+BA7F/B,0CAA0C"}

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

@@ -93,6 +93,11 @@ const SCROLL_BOXES_PER_CASCADE = 3;
  * @property {number} staging `brick_staging`'s handle, `BRICK_STAGING_WORDS` words a build slot
  * @property {GPUBuffer} ring the keys; taken key `b` sits at `(taken_first + b) & (ring_capacity - 1)`
  * @property {number} ring_capacity
+ * @property {GPUBuffer} pending a bit per key, set while the key is on the ring or being built. With `state` and
+ *   `ring`, the queue that a provider which learns on the device that a cell must be built again puts its key on,
+ *   with `brick_clipmap_enqueue` (contract 6). Such a pass writes `state` and hands its version on, as
+ *   `staging`.
+ * @property {number} budget cells taken a frame at most: what sizes a provider's own buffers of the taken cells
  * @property {number} resolution cells a cascade's window has a side
  * @property {number} cascade_count
  * @property {GPUBuffer} levels the cascades' windows, a {@link CLIPMAP_LEVEL_ARRAY}, finest first, a
@@ -280,6 +285,8 @@ export class GPUBrickClipmap {
         staging: -1,
         ring: null,
         ring_capacity: 0,
+        pending: null,
+        budget: 0,
         resolution: 0,
         cascade_count: 0,
         levels: null,
@@ -578,6 +585,8 @@ export class GPUBrickClipmap {
         context.staging = take_data.staging;
         context.ring = this.#ring;
         context.ring_capacity = this.#ring_capacity;
+        context.pending = this.#pending;
+        context.budget = budget;
         context.resolution = this.resolution;
         context.cascade_count = this.cascade_count;
         context.levels = this.#levels;

package/src/shade/renderer/global_illumination/probe_clipmap/brick/{mesh/chunk_mesh_brick_object.d.ts → chunk_brick_object.d.ts}

@@ -1,12 +1,12 @@
 /**
- * A world texel's byte and a texel's bid to be its object cell's object
+ * A world texel's byte and a texel's bid to be its object cell's object, the same for every provider
  * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.2, §7.6):
  *
  * ```wgsl
- * fn mesh_brick_encode(distance: f32, band: f32) -> u32     // saturate(d / 2R + 0.5), in a byte
- * fn mesh_brick_object_key(byte: u32, row: u32) -> u32      // larger for a nearer texel
- * fn mesh_brick_object_key_byte(key: u32) -> u32
- * fn mesh_brick_object_key_row(key: u32) -> u32
+ * fn brick_encode(distance: f32, band: f32) -> u32     // saturate(d / 2R + 0.5), in a byte
+ * fn brick_object_key(byte: u32, row: u32) -> u32      // larger for a nearer texel
+ * fn brick_object_key_byte(key: u32) -> u32
+ * fn brick_object_key_row(key: u32) -> u32
  * ```
  *
  * A key is the complement of the byte in its high eight bits and the row in its low 24, so the
@@ -16,6 +16,6 @@
  *
  * @type {CodeChunk}
  */
-export const chunk_mesh_brick_object: CodeChunk;
-import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_mesh_brick_object.d.ts.map
+export const chunk_brick_object: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_brick_object.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_brick_object.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_object.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,iCAFU,SAAS,CAsBhB;0BAzCuB,uCAAuC"}

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

@@ -0,0 +1,42 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { BRICK_OBJECT_ROW_LIMIT } from "./BRICK_CLIPMAP.js";
+
+/**
+ * A world texel's byte and a texel's bid to be its object cell's object, the same for every provider
+ * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.2, §7.6):
+ *
+ * ```wgsl
+ * fn brick_encode(distance: f32, band: f32) -> u32     // saturate(d / 2R + 0.5), in a byte
+ * fn brick_object_key(byte: u32, row: u32) -> u32      // larger for a nearer texel
+ * fn brick_object_key_byte(key: u32) -> u32
+ * fn brick_object_key_row(key: u32) -> u32
+ * ```
+ *
+ * A key is the complement of the byte in its high eight bits and the row in its low 24, so the
+ * largest of a cell's keys, which workgroup atomics can take, is its nearest texel, and among equally
+ * near ones the lowest row: the same object whatever order the lanes ran in. A row past the 24 bits
+ * cannot be named and bids as row 0, no object.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_object = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick_encode(distance: f32, band: f32) -> u32 {
+    return u32(round(saturate(distance / (2.0 * band) + 0.5) * 255.0));
+}
+
+fn brick_object_key(byte: u32, row: u32) -> u32 {
+    let named = select(0u, row, row < ${BRICK_OBJECT_ROW_LIMIT}u);
+
+    return ~((byte << 24u) | named);
+}
+
+fn brick_object_key_byte(key: u32) -> u32 {
+    return (~key) >> 24u;
+}
+
+fn brick_object_key_row(key: u32) -> u32 {
+    return (~key) & ${BRICK_OBJECT_ROW_LIMIT - 1}u;
+}
+`);

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

@@ -0,0 +1,45 @@
+/**
+ * A brick provider's resolution cull (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7), which reads nothing:
+ *
+ * ```wgsl
+ * fn brick_provider_resolves(bounds: array<f32, 6>, voxel: f32) -> bool
+ * ```
+ *
+ * An instance whose world box is under half a voxel across is out of the cascade, emissive or not. The ½-voxel
+ * hit would make it a lamp a voxel wide, 4 m at cascade 5.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_provider_resolves: CodeChunk;
+/**
+ * A taken cell's key's cell in the world (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.6), the same for every provider:
+ *
+ * ```wgsl
+ * fn brick_provider_cell(key: u32, resolution: u32) -> BrickProviderCell
+ * ```
+ *
+ * Its cascade, its lattice cell (the window's one congruent to the storage cell), the cascade's voxel and the band
+ * of the field's encoding in world units, and the cell's box, texel 0 at its corner (§7.2).
+ *
+ * Requires the importing shader to declare `brick_levels`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_provider_cell: CodeChunk;
+/**
+ * What a brick provider (§7.6) reads of a taken cell, the same for every provider:
+ *
+ * ```wgsl
+ * fn brick_provider_key(build: u32, ring_capacity: u32) -> u32
+ * ```
+ *
+ * Taken cell `build`'s key, whose cell {@link chunk_brick_provider_cell} places. The resolution cull comes with it
+ * ({@link chunk_brick_provider_resolves}).
+ *
+ * Requires the importing shader to declare `brick_take`, `brick_ring` and `brick_levels`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_provider: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_brick_provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_brick_provider.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_provider.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,4CAFU,SAAS,CAUhB;AAEH;;;;;;;;;;;;;GAaG;AACH,wCAFU,SAAS,CA+BsB;AAEzC;;;;;;;;;;;;;GAaG;AACH,mCAFU,SAAS,CAQiE;0BA1F1D,uCAAuC"}

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

@@ -0,0 +1,93 @@
+import { MESH_SDF_BAND_VOXELS, MESH_SDF_BRICK_VOXELS } from "../../../geometry/sdf/MESH_SDF.js";
+import { chunk_mod_v3i } from "../../../shader/chunk/geometry/vec3/chunk_mod_v3i.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_brick_clipmap } from "./chunk_brick_clipmap.js";
+
+/**
+ * A brick provider's resolution cull (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7), which reads nothing:
+ *
+ * ```wgsl
+ * fn brick_provider_resolves(bounds: array<f32, 6>, voxel: f32) -> bool
+ * ```
+ *
+ * An instance whose world box is under half a voxel across is out of the cascade, emissive or not. The ½-voxel
+ * hit would make it a lamp a voxel wide, 4 m at cascade 5.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_provider_resolves = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick_provider_resolves(bounds: array<f32, 6>, voxel: f32) -> bool {
+    let diagonal = length(vec3<f32>(bounds[3] - bounds[0], bounds[4] - bounds[1], bounds[5] - bounds[2]));
+
+    return !(diagonal < 0.5 * voxel);
+}
+`);
+
+/**
+ * A taken cell's key's cell in the world (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.6), the same for every provider:
+ *
+ * ```wgsl
+ * fn brick_provider_cell(key: u32, resolution: u32) -> BrickProviderCell
+ * ```
+ *
+ * Its cascade, its lattice cell (the window's one congruent to the storage cell), the cascade's voxel and the band
+ * of the field's encoding in world units, and the cell's box, texel 0 at its corner (§7.2).
+ *
+ * Requires the importing shader to declare `brick_levels`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_provider_cell = CodeChunk.from(
+    //language=WGSL
+    `
+struct BrickProviderCell {
+    cascade: u32,
+    cell: vec3<i32>,
+    voxel: f32,
+    band: f32,
+    corner: vec3<f32>,
+    far: vec3<f32>,
+}
+
+fn brick_provider_cell(key: u32, resolution: u32) -> BrickProviderCell {
+    let cascade = brick_clipmap_key_cascade(key, resolution);
+    let level = brick_levels[cascade];
+
+    var out: BrickProviderCell;
+
+    out.cascade = cascade;
+    // the world cell the storage cell holds: the window's one congruent to it
+    out.cell = level.corner + mod_v3i(vec3<i32>(brick_clipmap_key_storage(key, resolution)) - level.corner, vec3<i32>(i32(resolution)));
+    out.voxel = level.cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
+    out.band = ${MESH_SDF_BAND_VOXELS}.0 * out.voxel;
+    // texel 0, at voxel 7·cell of the cascade (§7.2)
+    out.corner = vec3<f32>(out.cell) * level.cell_size;
+    out.far = out.corner + vec3<f32>(level.cell_size);
+
+    return out;
+}
+`, [chunk_brick_clipmap, chunk_mod_v3i]);
+
+/**
+ * What a brick provider (§7.6) reads of a taken cell, the same for every provider:
+ *
+ * ```wgsl
+ * fn brick_provider_key(build: u32, ring_capacity: u32) -> u32
+ * ```
+ *
+ * Taken cell `build`'s key, whose cell {@link chunk_brick_provider_cell} places. The resolution cull comes with it
+ * ({@link chunk_brick_provider_resolves}).
+ *
+ * Requires the importing shader to declare `brick_take`, `brick_ring` and `brick_levels`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_provider = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick_provider_key(build: u32, ring_capacity: u32) -> u32 {
+    return brick_ring[(brick_take[BRICK_TAKE_FIRST] + build) & (ring_capacity - 1u)];
+}
+`, [chunk_brick_clipmap, chunk_brick_provider_cell, chunk_brick_provider_resolves]);

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

@@ -5,13 +5,6 @@
  * @type {number}
  */
 export const MESH_BRICK_INSTANCE_LIMIT: 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. A row past it writes no object, as
- * a provider that cannot name a row does (§7.6, contract 5).
- * @type {number}
- */
-export const MESH_BRICK_ROW_LIMIT: number;
 /**
  * An instance as the mesh provider samples it, made once a cell (§7.7):
  * - `to_local_0..2`: the rows of the inverse of the instance's `node.global`, from the world into the

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

@@ -1 +1 @@
-{"version":3,"file":"MESH_BRICK_INSTANCE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MESH_BRICK_INSTANCE_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;;GAKG;AACH,mCAFU,MAAM,CAE4B;AAE5C;;;;;;;;;;;;GAYG;AACH,yCAFU,YAAY,CAYE;6BAzCK,yCAAyC"}
+{"version":3,"file":"MESH_BRICK_INSTANCE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MESH_BRICK_INSTANCE_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;;;;;;;;;GAYG;AACH,yCAFU,YAAY,CAYE;6BAjCK,yCAAyC"}

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

@@ -9,14 +9,6 @@ import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
  */
 export const MESH_BRICK_INSTANCE_LIMIT = 64;
 
-/**
- * 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. A row past it writes no object, as
- * a provider that cannot name a row does (§7.6, contract 5).
- * @type {number}
- */
-export const MESH_BRICK_ROW_LIMIT = 1 << 24;
-
 /**
  * An instance as the mesh provider samples it, made once a cell (§7.7):
  * - `to_local_0..2`: the rows of the inverse of the instance's `node.global`, from the world into the

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

@@ -9,10 +9,8 @@
  *
  * `mesh_brick_accept` is the gather's leaf filter, with `bounds` the row's world box and `voxel` the
  * cascade's: the row is in the SDF world, its geometry's field is resident (a skinned clone's through
- * its source's, the hook), and its box is at least half a voxel across. A virtual geometry has no
- * header, so it is not resident and is the vgeo provider's (§7.8). Under the cull an instance is out
- * of the cascade, emissive or not: the half-voxel hit would make it a lamp a voxel wide, 4 m at
- * cascade 5.
+ * its source's, the hook), and its box resolves in the cascade (`brick_provider_resolves`). A virtual
+ * geometry has no header, so it is not resident and is the vgeo provider's (§7.8).
  *
  * `mesh_brick_instance` makes the instance the texels sample: the inverse of its transform, its box,
  * its smallest axis scale, and the coarsest level of its field no coarser than the cascade,

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_mesh_brick_instance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_instance.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wCAFU,SAAS,CA8DZ;0BAzFmB,0CAA0C"}
+{"version":3,"file":"chunk_mesh_brick_instance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_instance.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wCAFU,SAAS,CA4DZ;0BAtFmB,0CAA0C"}

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

@@ -4,6 +4,7 @@ import { chunk_scene_database_access } from "../../../../scene/chunk_scene_datab
 import { MESH_FLAG_SDF_WORLD } from "../../../../scene/MESH_INSTANCE_METADATA_STRUCT.js";
 import { chunk_mat4_inverse } from "../../../../shader/chunk/geometry/mat4/chunk_mat4_inverse.js";
 import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+import { chunk_brick_provider_resolves } from "../chunk_brick_provider.js";
 import { MESH_BRICK_INSTANCE_STRUCT } from "./MESH_BRICK_INSTANCE_STRUCT.js";
 
 /**
@@ -17,10 +18,8 @@ import { MESH_BRICK_INSTANCE_STRUCT } from "./MESH_BRICK_INSTANCE_STRUCT.js";
  *
  * `mesh_brick_accept` is the gather's leaf filter, with `bounds` the row's world box and `voxel` the
  * cascade's: the row is in the SDF world, its geometry's field is resident (a skinned clone's through
- * its source's, the hook), and its box is at least half a voxel across. A virtual geometry has no
- * header, so it is not resident and is the vgeo provider's (§7.8). Under the cull an instance is out
- * of the cascade, emissive or not: the half-voxel hit would make it a lamp a voxel wide, 4 m at
- * cascade 5.
+ * its source's, the hook), and its box resolves in the cascade (`brick_provider_resolves`). A virtual
+ * geometry has no header, so it is not resident and is the vgeo provider's (§7.8).
  *
  * `mesh_brick_instance` makes the instance the texels sample: the inverse of its transform, its box,
  * its smallest axis scale, and the coarsest level of its field no coarser than the cascade,
@@ -50,10 +49,7 @@ fn mesh_brick_accept(row: u32, bounds: array<f32, 6>, voxel: f32) -> bool {
         return false;
     }
 
-    // the resolution cull
-    let diagonal = length(vec3<f32>(bounds[3] - bounds[0], bounds[4] - bounds[1], bounds[5] - bounds[2]));
-
-    if (diagonal < 0.5 * voxel) {
+    if (!brick_provider_resolves(bounds, voxel)) {
         return false;
     }
 
@@ -89,6 +85,7 @@ fn mesh_brick_instance(row: u32, voxel: f32) -> ${MESH_BRICK_INSTANCE_STRUCT.wgs
 }
 `, [
         chunk_mesh_sdf,
+        chunk_brick_provider_resolves,
         chunk_scene_database_access,
         chunk_mat4_inverse,
         MESH_BRICK_INSTANCE_STRUCT.declaration_chunk,

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

@@ -1 +1 @@
-{"version":3,"file":"shader_mesh_brick_provider.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.js"],"names":[],"mappings":"AAkCA;;GAEG;AACH,uDAAwD;AACxD,wDAAyD;AACzD,mDAAoD;AACpD,2CAA4C;AAE5C;;GAEG;AACH,2CAFU,YAAY,CAOU;AA4KhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCAFU,aAAa,CAMpB;6BAjO0B,yCAAyC;8BAJxC,qCAAqC"}
+{"version":3,"file":"shader_mesh_brick_provider.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.js"],"names":[],"mappings":"AAiCA;;GAEG;AACH,uDAAwD;AACxD,wDAAyD;AACzD,mDAAoD;AACpD,2CAA4C;AAE5C;;GAEG;AACH,2CAFU,YAAY,CAOU;AAoKhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCAFU,aAAa,CAMpB;6BA1N0B,yCAAyC;8BAJxC,qCAAqC"}

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

@@ -1,6 +1,5 @@
 import { assert } from "../../../../../../core/assert.js";
 import { WebGPUExtensionType } from "../../../../../descriptor/WebGPUExtensionType.js";
-import { MESH_SDF_BAND_VOXELS, MESH_SDF_BRICK_VOXELS } from "../../../../geometry/sdf/MESH_SDF.js";
 import {
     MESH_SDF_ATLAS_RESOURCE,
     MESH_SDF_HEADERS_RESOURCE,
@@ -12,7 +11,6 @@ import { BVH_STRUCT } from "../../../../shader/chunk/bvh/BVH_STRUCT.js";
 import { chunk_bvh_query_aabb_cooperative } from "../../../../shader/chunk/bvh/chunk_bvh_query_aabb_cooperative.js";
 import { BVH_QUERY_AABB_WORKGROUP_SIZE } from "../../../../shader/chunk/bvh/chunk_bvh_query_aabb_frontier.js";
 import { CLIPMAP_LEVEL_ARRAY } from "../../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
-import { chunk_mod_v3i } from "../../../../shader/chunk/geometry/vec3/chunk_mod_v3i.js";
 import { chunk_folded_workgroup_index } from "../../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
 import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../../shader/ComputeShader.js";
@@ -21,6 +19,8 @@ import { atomic_u32, u32 } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_T
 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 { chunk_brick_object } from "../chunk_brick_object.js";
+import { chunk_brick_provider } from "../chunk_brick_provider.js";
 import {
     BRICK_RING_RESOURCE,
     BRICK_STAGING_RESOURCE,
@@ -28,7 +28,6 @@ import {
     chunk_brick_clipmap
 } from "../chunk_brick_clipmap.js";
 import { chunk_mesh_brick_instance } from "./chunk_mesh_brick_instance.js";
-import { chunk_mesh_brick_object } from "./chunk_mesh_brick_object.js";
 import { chunk_mesh_brick_texel } from "./chunk_mesh_brick_texel.js";
 import { MESH_BRICK_INSTANCE_LIMIT, MESH_BRICK_INSTANCE_STRUCT } from "./MESH_BRICK_INSTANCE_STRUCT.js";
 
@@ -116,20 +115,12 @@ fn main(
         return;
     }
 
-    let key = brick_ring[(brick_take[BRICK_TAKE_FIRST] + build) & (settings.ring_capacity - 1u)];
-    let resolution = settings.resolution;
-    let cascade = brick_clipmap_key_cascade(key, resolution);
-    let level = brick_levels[cascade];
+    let at = brick_provider_cell(brick_provider_key(build, settings.ring_capacity), settings.resolution);
 
-    // the world cell the storage cell holds: the window's one congruent to it
-    let cell = level.corner + mod_v3i(vec3<i32>(brick_clipmap_key_storage(key, resolution)) - level.corner, vec3<i32>(i32(resolution)));
-
-    let voxel = level.cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
-    let band = ${MESH_SDF_BAND_VOXELS}.0 * voxel;
-
-    // texel 0, at voxel 7·cell of the cascade (§7.2)
-    let corner = vec3<f32>(cell) * level.cell_size;
-    let far = corner + vec3<f32>(level.cell_size);
+    let voxel = at.voxel;
+    let band = at.band;
+    let corner = at.corner;
+    let far = at.far;
 
     mesh_brick_voxel = voxel;
 
@@ -174,7 +165,7 @@ fn main(
             let staged = (word >> shift) & 0xffu;
 
             let texel = mesh_brick_texel(corner + vec3<f32>(f32(x), f32(y), f32(z)) * voxel, count);
-            let byte = mesh_brick_encode(texel.distance, band);
+            let byte = brick_encode(texel.distance, band);
 
             // 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);
@@ -183,7 +174,7 @@ fn main(
             let o = x / 2u;
 
             staged_min[o] = min(staged_min[o], staged);
-            best[o] = max(best[o], mesh_brick_object_key(byte, texel.row));
+            best[o] = max(best[o], brick_object_key(byte, texel.row));
         }
 
         brick_staging[first + w] = word;
@@ -203,19 +194,19 @@ fn main(
         // the provider's cell minimum against the staged one from before its merge: ties keep the staged
         let nearest = atomicLoad(&object_best[object]);
 
-        if (mesh_brick_object_key_byte(nearest) < 255u - atomicLoad(&object_staged[object])) {
-            brick_staging[build * BRICK_STAGING_WORDS + BRICK_STAGING_DISTANCE_WORDS + object] = mesh_brick_object_key_row(nearest);
+        if (brick_object_key_byte(nearest) < 255u - atomicLoad(&object_staged[object])) {
+            brick_staging[build * BRICK_STAGING_WORDS + BRICK_STAGING_DISTANCE_WORDS + object] = brick_object_key_row(nearest);
         }
     }
 }
 `, [
     chunk_brick_clipmap,
+    chunk_brick_provider,
     chunk_folded_workgroup_index,
-    chunk_mod_v3i,
     chunk_bvh_query_aabb_cooperative,
     chunk_mesh_brick_instance,
     chunk_mesh_brick_texel,
-    chunk_mesh_brick_object,
+    chunk_brick_object,
 ]);
 
 body.addExtension(WebGPUExtensionType.Subgroups);

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/VGEO_BRICK.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The provider's settings, an immediate of each of its passes.
+ * @type {WebGPUStruct}
+ */
+export const VGEO_BRICK_SETTINGS: WebGPUStruct;
+/**
+ * Where a pair record keeps the box it is cut against: the cell grown by the field's band, in the instance's
+ * object space, lower xyz then upper xyz, in the words a view's record keeps its frustum in.
+ * @type {number}
+ */
+export const VGEO_BRICK_PAIR_BOX: number;
+/**
+ * Where a pair record keeps its taken cell: the first word a view's record leaves free.
+ * @type {number}
+ */
+export const VGEO_BRICK_PAIR_BUILD: number;
+/**
+ * Pair records a frame holds, for each cell of its take budget; past them, pairs are dropped and counted.
+ * @type {number}
+ */
+export const VGEO_BRICK_PAIRS_PER_CELL: number;
+/**
+ * Clusters a taken cell's list holds; past them, clusters are dropped and counted.
+ * @type {number}
+ */
+export const VGEO_BRICK_CELL_CLUSTERS: number;
+/**
+ * A waiting cell: its key, then what the first cluster of its cut that stood something in waits on, and what wants
+ * it. The page it waits on is `PAGE` of the geometry whose page lookup starts at `LOOKUP`, and `GROUP` is the group in
+ * that page. The want for that page goes through the page the cluster was found in: `SOURCE` is its row, `SOURCE_PAGE`
+ * its own page index in the geometry, `REF` the entry of its child table naming the page, and `ERROR` the cluster's
+ * projected error, as the want's priority (`vg_want`). A group held back carries no want, as in the cut, whose rule
+ * leaves a held verdict's `REF` and `ERROR` at zero: the clamp beside it wants the page that holds it back.
+ */
+export const VGEO_BRICK_WAIT_OFFSET: Readonly<{
+    KEY: 0;
+    LOOKUP: 1;
+    PAGE: 2;
+    GROUP: 3;
+    SOURCE: 4;
+    SOURCE_PAGE: 5;
+    REF: 6;
+    ERROR: 7;
+}>;
+/**
+ * Words of a waiting cell.
+ * @type {number}
+ */
+export const VGEO_BRICK_WAIT_WORDS: number;
+/**
+ * A taken cell's list: its header, then from `ENTRIES` a cluster's pair and meshlet row each. The header holds the
+ * clusters taken (a count that runs past what the list holds), how many of them stood in for a page or a group not
+ * there yet, and from `WAIT` the cell as a waiting cell's words ({@link VGEO_BRICK_WAIT_OFFSET}): its key, then the
+ * first stand-in's wait, which the distances copy onto the waiting list whole.
+ */
+export const VGEO_BRICK_CELL_OFFSET: Readonly<{
+    COUNT: 0;
+    WAITS: 1;
+    WAIT: 2;
+    KEY: number;
+    ENTRIES: number;
+}>;
+/**
+ * Words of a taken cell's list.
+ * @type {number}
+ */
+export const VGEO_BRICK_CELL_WORDS: number;
+/**
+ * Waiting cells the provider holds, for each cell of the take budget; past them, a cell that stood a cluster in is
+ * dropped and counted, and is not built again when its page arrives.
+ * @type {number}
+ */
+export const VGEO_BRICK_WAITS_PER_CELL: number;
+/**
+ * Triangles of a taken cell's cut that its distances are made from, in workgroup memory (§7.8, chosen): past
+ * them, triangles are dropped and counted, and a dropped triangle can leave a hole. A texel's distance is a loop
+ * over them.
+ * @type {number}
+ */
+export const VGEO_BRICK_CELL_TRIANGLES: number;
+/**
+ * Lanes of the distance pass, a workgroup a taken cell: a lane a triangle, of as many of the cell's clusters at a
+ * time as the lanes hold whole, then the cell's texels shared out evenly.
+ * @type {number}
+ */
+export const VGEO_BRICK_DISTANCE_WORKGROUP_SIZE: number;
+/**
+ * Words of the provider's statistics, every one an atomic that accumulates: pairs dropped (the records were full,
+ * or the instance's transform flattens it), candidates and subtrees the gather's query dropped, triangles the
+ * distance pass dropped past {@link VGEO_BRICK_CELL_TRIANGLES}, and waiting cells dropped past the waiting list.
+ */
+export const VGEO_BRICK_STATISTIC_PAIRS_DROPPED: 0;
+export const VGEO_BRICK_STATISTIC_CANDIDATES_DROPPED: 1;
+export const VGEO_BRICK_STATISTIC_NODES_DROPPED: 2;
+export const VGEO_BRICK_STATISTIC_TRIANGLES_DROPPED: 3;
+export const VGEO_BRICK_STATISTIC_WAITS_DROPPED: 4;
+export const VGEO_BRICK_STATISTIC_WORDS: 8;
+import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=VGEO_BRICK.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VGEO_BRICK.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/VGEO_BRICK.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,kCAFU,YAAY,CAWE;AAExB;;;;GAIG;AACH,kCAFU,MAAM,CAEgD;AAEhE;;;GAGG;AACH,oCAFU,MAAM,CAE8D;AAI9E;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,uCAFU,MAAM,CAE2B;AAE3C;;;;;;;GAOG;AACH;;;;;;;;;GASG;AAEH;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;;GAKG;AACH;;;;;;GAMG;AAEH;;;GAGG;AACH,oCAFU,MAAM,CAEmF;AAEnG;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;GAKG;AACH,wCAFU,MAAM,CAE6B;AAE7C;;;;GAIG;AACH,iDAFU,MAAM,CAEsE;AAKtF;;;;GAIG;AACH,mDAAoD;AACpD,wDAAyD;AACzD,mDAAoD;AACpD,uDAAwD;AACxD,mDAAoD;AACpD,2CAA4C;6BApIf,yCAAyC"}