@woosh/meep-engine 3.61.1 → 3.61.3

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.d.ts

@@ -1,32 +1,38 @@
 /**
  * What the probe clipmap GI holds of one scene's geometry caches (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
- * §6.1, §6.5), kept by entity and moved as the rows' events say, O(changes):
+ * §6.1), kept by entity and moved as the rows' events say, O(changes):
  *
  * - a hold on the cache of the geometry each mesh row in the SDF world draws, drawing both sides
  *   when the row's material does;
- * - one card set per (geometry, material) pair those rows draw, with the rows drawing each pair;
- * - the row → card set table readers find a row's card set in: the pair's once it is resident,
+ * - one Model Surface Cache per (geometry, material) pair those rows draw, with the rows drawing each
+ *   pair, which the brick material is gathered from;
+ * - the row → surface cache table readers find a row's cache in: the pair's once it is resident,
  *   `GPU_DATABASE_NULL` until then and for a row out of the SDF world.
  *
  * A row is in the SDF world when its `flags` carry `MESH_FLAG_SDF_WORLD`, whatever its geometry: a
  * virtual geometry's cache is held as a mesh's is, and is its proxy's once `VGeoSDFProxies` aliases it: the
- * hold and its side move to the proxy, and the pair's card set captures the proxy's layout.
+ * hold and its side move to the proxy, and the pair's cache follows the proxy's field.
  * A skinned row draws a clone: the hold and the pair are its source's,
- * whose unskinned field and cards the clone's header is aliased to (§6.3). A row written again moves
- * its hold and its pair, the new ones taken before the old ones go, so a cache or card set a row keeps
- * drawing is never let go in between.
+ * whose unskinned field and caches the clone's header is aliased to (§6.3). A row written again moves
+ * its hold and its pair, the new ones taken before the old ones go, so a cache a row keeps drawing is
+ * never let go in between.
+ *
+ * Rows the world's bricks must be built again over are kept until drained: a row whose geometry's field
+ * turned resident, one that joined or left the SDF world (§6.4, §7.4), and each row of a pair whose
+ * surface cache a bake completed, the first and every one after, since the bricks hold the materials
+ * their caches held when each was gathered.
  *
  * When the material manager restages a material whose version moved, each of that material's pairs
- * is recaptured (§6.5), and the holds of its rows move to the side it draws now.
+ * is baked again, and the holds of its rows move to the side it draws now.
  *
- * {@link attach} subscribes and walks the rows already there; {@link detach} gives every hold and card
- * set back. Neither trims: a cache with no holder stays until its user trims, so leaving the mode keeps
- * the caches for the next time (D28). Card sets go with their last row, and are captured again.
+ * {@link attach} subscribes and walks the rows already there; {@link detach} gives every hold and cache
+ * back. Neither trims: a field with no holder stays until its user trims, so leaving the mode keeps
+ * the fields for the next time (D28). Caches go with their last row, and are made again.
  */
 export class ProbeClipmapSceneHolds {
     /**
      * @param {GPUSceneContext} scene
-     * @param {GraphicsContext} graphics whose material manager's restages recapture the pairs of the material
+     * @param {GraphicsContext} graphics whose material manager's restages bake the pairs of the material again
      */
     constructor(scene: GPUSceneContext, graphics: GraphicsContext);
     /**
@@ -39,12 +45,12 @@ export class ProbeClipmapSceneHolds {
      */
     get hold_count(): number;
     /**
-     * (geometry, material) pairs the rows draw, a card set each.
+     * (geometry, material) pairs the rows draw, a cache each.
      * @returns {number}
      */
     get pair_count(): number;
     /**
-     * Recaptures asked for, a pair each time its material was restaged.
+     * Bakes again asked for, a pair each time its material was restaged.
      * @returns {number}
      */
     get recaptures_requested(): number;
@@ -55,19 +61,20 @@ export class ProbeClipmapSceneHolds {
     get invalidated(): readonly number[];
     clear_invalidated(): void;
     /**
-     * The card set of the pair `material` makes with a geometry, or undefined when no row draws it.
+     * The Model Surface Cache of the pair `material` makes with a geometry, or undefined when no row
+     * draws it.
      *
      * @param {GPUGeometryMetadata} record
      * @param {ShadeMaterial} material
      * @returns {number|undefined}
      */
-    card_set_of(record: GPUGeometryMetadata, material: ShadeMaterial): number | undefined;
+    surface_cache_of(record: GPUGeometryMetadata, material: ShadeMaterial): number | undefined;
     /**
-     * The row → card set table: a word a `meshes` row. Made on first use, replaced when it grows; take it
-     * each frame, after {@link flush}.
+     * The row → Model Surface Cache table: a word a `meshes` row. Made on first use, replaced when it
+     * grows; take it each frame, after {@link flush}.
      * @returns {GPUBuffer}
      */
-    get rows_buffer(): GPUBuffer;
+    get surface_rows_buffer(): GPUBuffer;
     attach(): void;
     detach(): void;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"ProbeClipmapSceneHolds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAwEI;;;OAGG;IACH,mBAHW,eAAe,YACf,eAAe,EASzB;IAED;;OAEG;IACH,sEAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED,0BAEC;IAED;;;;;;OAMG;IACH,oBAJW,mBAAmB,YACnB,aAAa,GACX,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,6BAIC;IAED,eAiBC;IAED,eAuCC;IAED;;OAEG;IACH,cAiBC;;CA4TJ;8BA3mBY,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;4BACnE,OAAO,iCAAiC,EAAE,aAAa;iCACvD,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,0BAA0B,EAAE,eAAe"}
+{"version":3,"file":"ProbeClipmapSceneHolds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js"],"names":[],"mappings":"AAyLA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAiEI;;;OAGG;IACH,mBAHW,eAAe,YACf,eAAe,EASzB;IAED;;OAEG;IACH,sEAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED,0BAEC;IAED;;;;;;;OAOG;IACH,yBAJW,mBAAmB,YACnB,aAAa,GACX,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,qCAEC;IAED,eAmBC;IAED,eAoCC;IAED;;OAEG;IACH,cAEC;;CA2RJ;8BAzrBY,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;4BACnE,OAAO,iCAAiC,EAAE,aAAa;iCACvD,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,0BAA0B,EAAE,eAAe"}

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

@@ -22,13 +22,14 @@ import { row_of_entity } from "../../scene/rows/GPUSceneRows.js";
 const PAIR_KEY_MATERIAL_SPAN = 2 ** 20;
 
 /**
- * Rows the row → card set table starts with room for; it doubles past that.
+ * Rows a row table starts with room for; it doubles past that.
  * @type {number}
  */
 const INITIAL_ROW_CAPACITY = 256;
 
 /**
- * A (geometry, material) pair some row in the SDF world draws, and the card set capturing it.
+ * A (geometry, material) pair some row in the SDF world draws, and the Model Surface Cache of it the
+ * holds keep.
  */
 class Pair {
     /** @type {number} */
@@ -38,7 +39,7 @@ class Pair {
     material = undefined;
 
     /** @type {number} */
-    card_set = 0;
+    cache = 0;
 
     /**
      * Whether its rows hold the geometry's cache as drawing both sides: the material's side, as it was
@@ -54,30 +55,164 @@ class Pair {
     rows = new Set();
 }
 
+/**
+ * A row → cache table: a word a `meshes` row, mirrored on the host and put on the device by changed
+ * range. A row with nothing is `GPU_DATABASE_NULL`.
+ */
+class RowTable {
+    #mirror = new Uint32Array(0);
+    /** @type {GPUBuffer|null} */
+    #buffer = null;
+    #dirty_low = Infinity;
+    #dirty_high = -1;
+    #label;
+
+    /**
+     * @param {string} label
+     */
+    constructor(label) {
+        this.#label = label;
+    }
+
+    /**
+     * @param {number} row
+     * @param {number} value
+     */
+    write(row, value) {
+        if (row >= this.#mirror.length) {
+            this.#grow_mirror(row + 1);
+        }
+
+        if (this.#mirror[row] === value) {
+            return;
+        }
+
+        this.#mirror[row] = value;
+
+        this.#dirty_low = Math.min(this.#dirty_low, row);
+        this.#dirty_high = Math.max(this.#dirty_high, row);
+    }
+
+    /**
+     * @param {GPUDevice} device
+     * @returns {GPUBuffer}
+     */
+    buffer(device) {
+        this.#ensure(device, 1);
+
+        return this.#buffer;
+    }
+
+    /**
+     * @param {GPUDevice} device
+     */
+    flush(device) {
+        const low = this.#dirty_low;
+        const high = this.#dirty_high;
+
+        if (high < low) {
+            return;
+        }
+
+        this.#dirty_low = Infinity;
+        this.#dirty_high = -1;
+
+        if (this.#ensure(device, high + 1)) {
+            // a new table took the whole mirror
+            return;
+        }
+
+        device.queue.writeBuffer(this.#buffer, 4 * low, this.#mirror, low, high + 1 - low);
+    }
+
+    clear() {
+        this.#buffer?.destroy();
+        this.#buffer = null;
+        this.#mirror = new Uint32Array(0);
+        this.#dirty_low = Infinity;
+        this.#dirty_high = -1;
+    }
+
+    /**
+     * @param {number} length
+     */
+    #grow_mirror(length) {
+        let capacity = Math.max(INITIAL_ROW_CAPACITY, this.#mirror.length);
+
+        while (capacity < length) {
+            capacity *= 2;
+        }
+
+        const grown = new Uint32Array(capacity).fill(GPU_DATABASE_NULL);
+
+        grown.set(this.#mirror);
+
+        this.#mirror = grown;
+    }
+
+    /**
+     * A table buffer for at least `rows` rows; a new one gets the whole mirror.
+     *
+     * @param {GPUDevice} device
+     * @param {number} rows
+     * @returns {boolean} whether the buffer is new
+     */
+    #ensure(device, rows) {
+        if (rows > this.#mirror.length) {
+            this.#grow_mirror(rows);
+        }
+
+        if (this.#buffer !== null && this.#buffer.size >= 4 * this.#mirror.length) {
+            return false;
+        }
+
+        this.#buffer?.destroy();
+
+        this.#buffer = device.createBuffer(BufferDescriptor.fromJSON({
+            label: this.#label,
+            size: 4 * this.#mirror.length,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        }));
+
+        device.queue.writeBuffer(this.#buffer, 0, this.#mirror);
+
+        this.#dirty_low = Infinity;
+        this.#dirty_high = -1;
+
+        return true;
+    }
+}
+
 /**
  * What the probe clipmap GI holds of one scene's geometry caches (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
- * §6.1, §6.5), kept by entity and moved as the rows' events say, O(changes):
+ * §6.1), kept by entity and moved as the rows' events say, O(changes):
  *
  * - a hold on the cache of the geometry each mesh row in the SDF world draws, drawing both sides
  *   when the row's material does;
- * - one card set per (geometry, material) pair those rows draw, with the rows drawing each pair;
- * - the row → card set table readers find a row's card set in: the pair's once it is resident,
+ * - one Model Surface Cache per (geometry, material) pair those rows draw, with the rows drawing each
+ *   pair, which the brick material is gathered from;
+ * - the row → surface cache table readers find a row's cache in: the pair's once it is resident,
  *   `GPU_DATABASE_NULL` until then and for a row out of the SDF world.
  *
  * A row is in the SDF world when its `flags` carry `MESH_FLAG_SDF_WORLD`, whatever its geometry: a
  * virtual geometry's cache is held as a mesh's is, and is its proxy's once `VGeoSDFProxies` aliases it: the
- * hold and its side move to the proxy, and the pair's card set captures the proxy's layout.
+ * hold and its side move to the proxy, and the pair's cache follows the proxy's field.
  * A skinned row draws a clone: the hold and the pair are its source's,
- * whose unskinned field and cards the clone's header is aliased to (§6.3). A row written again moves
- * its hold and its pair, the new ones taken before the old ones go, so a cache or card set a row keeps
- * drawing is never let go in between.
+ * whose unskinned field and caches the clone's header is aliased to (§6.3). A row written again moves
+ * its hold and its pair, the new ones taken before the old ones go, so a cache a row keeps drawing is
+ * never let go in between.
+ *
+ * Rows the world's bricks must be built again over are kept until drained: a row whose geometry's field
+ * turned resident, one that joined or left the SDF world (§6.4, §7.4), and each row of a pair whose
+ * surface cache a bake completed, the first and every one after, since the bricks hold the materials
+ * their caches held when each was gathered.
  *
  * When the material manager restages a material whose version moved, each of that material's pairs
- * is recaptured (§6.5), and the holds of its rows move to the side it draws now.
+ * is baked again, and the holds of its rows move to the side it draws now.
  *
- * {@link attach} subscribes and walks the rows already there; {@link detach} gives every hold and card
- * set back. Neither trims: a cache with no holder stays until its user trims, so leaving the mode keeps
- * the caches for the next time (D28). Card sets go with their last row, and are captured again.
+ * {@link attach} subscribes and walks the rows already there; {@link detach} gives every hold and cache
+ * back. Neither trims: a field with no holder stays until its user trims, so leaving the mode keeps
+ * the fields for the next time (D28). Caches go with their last row, and are made again.
  */
 export class ProbeClipmapSceneHolds {
 
@@ -126,34 +261,27 @@ export class ProbeClipmapSceneHolds {
     #pairs_of_geometry = new Map();
 
     /**
-     * Rows the world's bricks must be built again over, since they were last drained: a row whose
-     * geometry's field turned resident, and one that joined or left the SDF world (§6.4, §7.4). Rows
-     * as the GPU's tables address them (`row_of_entity`), not entities.
+     * Rows the world's bricks must be built again over, since they were last drained. Rows as the GPU's
+     * tables address them (`row_of_entity`), not entities.
      * @type {number[]}
      */
     #invalidated = [];
 
     /**
-     * Each card set's pair, by card set id.
+     * Each cache's pair, by cache id.
      * @type {(Pair|undefined)[]}
      */
-    #pair_of_card_set = [];
+    #pair_of_cache = [];
 
     #recaptures_requested = 0;
 
-    // ---- the row → card set table ----
-
-    #rows_mirror = new Uint32Array(0);
-    /** @type {GPUBuffer|null} */
-    #rows_buffer = null;
-    #rows_dirty_low = Infinity;
-    #rows_dirty_high = -1;
+    #surface_rows = new RowTable("ProbeClipmapSceneHolds/surface rows");
 
     #attached = false;
 
     /**
      * @param {GPUSceneContext} scene
-     * @param {GraphicsContext} graphics whose material manager's restages recapture the pairs of the material
+     * @param {GraphicsContext} graphics whose material manager's restages bake the pairs of the material again
      */
     constructor(scene, graphics) {
         assert.defined(scene, 'scene');
@@ -180,7 +308,7 @@ export class ProbeClipmapSceneHolds {
     }
 
     /**
-     * (geometry, material) pairs the rows draw, a card set each.
+     * (geometry, material) pairs the rows draw, a cache each.
      * @returns {number}
      */
     get pair_count() {
@@ -188,7 +316,7 @@ export class ProbeClipmapSceneHolds {
     }
 
     /**
-     * Recaptures asked for, a pair each time its material was restaged.
+     * Bakes again asked for, a pair each time its material was restaged.
      * @returns {number}
      */
     get recaptures_requested() {
@@ -208,25 +336,24 @@ export class ProbeClipmapSceneHolds {
     }
 
     /**
-     * The card set of the pair `material` makes with a geometry, or undefined when no row draws it.
+     * The Model Surface Cache of the pair `material` makes with a geometry, or undefined when no row
+     * draws it.
      *
      * @param {GPUGeometryMetadata} record
      * @param {ShadeMaterial} material
      * @returns {number|undefined}
      */
-    card_set_of(record, material) {
-        return this.#pairs.get(record.index * PAIR_KEY_MATERIAL_SPAN + material.id)?.card_set;
+    surface_cache_of(record, material) {
+        return this.#pairs.get(record.index * PAIR_KEY_MATERIAL_SPAN + material.id)?.cache;
     }
 
     /**
-     * The row → card set table: a word a `meshes` row. Made on first use, replaced when it grows; take it
-     * each frame, after {@link flush}.
+     * The row → Model Surface Cache table: a word a `meshes` row. Made on first use, replaced when it
+     * grows; take it each frame, after {@link flush}.
      * @returns {GPUBuffer}
      */
-    get rows_buffer() {
-        this.#ensure_rows(1);
-
-        return this.#rows_buffer;
+    get surface_rows_buffer() {
+        return this.#surface_rows.buffer(this.#device);
     }
 
     attach() {
@@ -235,13 +362,15 @@ export class ProbeClipmapSceneHolds {
         this.#attached = true;
 
         const rows = this.#scene.rows;
-        const cards = this.#scene.geometries.sdf.cards;
+        const sdf = this.#scene.geometries.sdf;
 
         rows.onMeshWritten.add(this.#written, this);
         rows.onMeshReleased.add(this.#released, this);
-        this.#scene.geometries.sdf.onBaked.add(this.#baked, this);
-        cards.onResident.add(this.#card_set_resident, this);
-        cards.onWithdrawn.add(this.#card_set_withdrawn, this);
+        sdf.onBaked.add(this.#baked, this);
+
+        sdf.surfaces.onBaked.add(this.#surface_baked, this);
+        sdf.surfaces.onWithdrawn.add(this.#cache_withdrawn, this);
+
         this.#materials.onMaterialRestaged.add(this.#restaged, this);
 
         // a row not yet written is taken now, and moved when it is
@@ -257,13 +386,14 @@ export class ProbeClipmapSceneHolds {
 
         const rows = this.#scene.rows;
         const sdf = this.#scene.geometries.sdf;
-        const cards = sdf.cards;
 
         rows.onMeshWritten.remove(this.#written, this);
         rows.onMeshReleased.remove(this.#released, this);
         sdf.onBaked.remove(this.#baked, this);
-        cards.onResident.remove(this.#card_set_resident, this);
-        cards.onWithdrawn.remove(this.#card_set_withdrawn, this);
+
+        sdf.surfaces.onBaked.remove(this.#surface_baked, this);
+        sdf.surfaces.onWithdrawn.remove(this.#cache_withdrawn, this);
+
         this.#materials.onMaterialRestaged.remove(this.#restaged, this);
 
         for (const [entity, record] of this.#held) {
@@ -271,7 +401,7 @@ export class ProbeClipmapSceneHolds {
         }
 
         for (const pair of this.#pairs.values()) {
-            cards.release(pair.card_set);
+            this.#release_cache(pair.cache);
         }
 
         this.#held.clear();
@@ -279,36 +409,17 @@ export class ProbeClipmapSceneHolds {
         this.#pairs.clear();
         this.#pairs_of_material.clear();
         this.#pairs_of_geometry.clear();
-        this.#pair_of_card_set.length = 0;
+        this.#pair_of_cache.length = 0;
         this.#invalidated.length = 0;
 
-        this.#rows_buffer?.destroy();
-        this.#rows_buffer = null;
-        this.#rows_mirror = new Uint32Array(0);
-        this.#rows_dirty_low = Infinity;
-        this.#rows_dirty_high = -1;
+        this.#surface_rows.clear();
     }
 
     /**
      * Put the table's changed rows on the device, ahead of the frame's commands.
      */
     flush() {
-        const low = this.#rows_dirty_low;
-        const high = this.#rows_dirty_high;
-
-        if (high < low) {
-            return;
-        }
-
-        this.#rows_dirty_low = Infinity;
-        this.#rows_dirty_high = -1;
-
-        if (this.#ensure_rows(high + 1)) {
-            // a new table took the whole mirror
-            return;
-        }
-
-        this.#device.queue.writeBuffer(this.#rows_buffer, 4 * low, this.#rows_mirror, low, high + 1 - low);
+        this.#surface_rows.flush(this.#device);
     }
 
     /**
@@ -359,7 +470,7 @@ export class ProbeClipmapSceneHolds {
             }
         }
 
-        this.#write_row(entity, pair !== undefined && sdf.cards.is_resident(pair.card_set) ? pair.card_set : GPU_DATABASE_NULL);
+        this.#write_row(entity, pair !== undefined && this.#is_resident(pair.cache) ? pair.cache : GPU_DATABASE_NULL);
 
         // in the SDF world or out of it now: the bricks its box reaches are built again
         if ((previous === undefined) !== (record === undefined)) {
@@ -384,9 +495,7 @@ export class ProbeClipmapSceneHolds {
         }
 
         for (const pair of pairs) {
-            for (const entity of pair.rows) {
-                this.#invalidated.push(row_of_entity(entity));
-            }
+            this.#invalidate_pair(pair);
         }
     }
 
@@ -427,15 +536,17 @@ export class ProbeClipmapSceneHolds {
             return pair;
         }
 
+        const sdf = this.#scene.geometries.sdf;
+
         pair = new Pair();
 
         pair.key = key;
         pair.material = material;
         pair.two_sided = material.draw_side === ShadeDrawSide.Double;
-        pair.card_set = this.#scene.geometries.sdf.cards.acquire(record.index, material);
+        pair.cache = sdf.surfaces.acquire(record.index, material);
 
         this.#pairs.set(key, pair);
-        this.#pair_of_card_set[pair.card_set] = pair;
+        this.#pair_of_cache[pair.cache] = pair;
 
         let of_material = this.#pairs_of_material.get(material.id);
 
@@ -469,10 +580,10 @@ export class ProbeClipmapSceneHolds {
             return;
         }
 
-        this.#scene.geometries.sdf.cards.release(pair.card_set);
+        this.#release_cache(pair.cache);
 
         this.#pairs.delete(pair.key);
-        this.#pair_of_card_set[pair.card_set] = undefined;
+        this.#pair_of_cache[pair.cache] = undefined;
 
         const of_material = this.#pairs_of_material.get(pair.material.id);
 
@@ -493,25 +604,54 @@ export class ProbeClipmapSceneHolds {
     }
 
     /**
-     * @param {number} card_set
+     * @param {number} cache
      */
-    #card_set_resident(card_set) {
-        const pair = this.#pair_of_card_set[card_set];
+    #release_cache(cache) {
+        this.#scene.geometries.sdf.surfaces.release(cache);
+    }
+
+    /**
+     * @param {number} cache
+     * @returns {boolean}
+     */
+    #is_resident(cache) {
+        return this.#scene.geometries.sdf.surfaces.is_resident(cache);
+    }
+
+    /**
+     * @param {Pair} pair
+     */
+    #invalidate_pair(pair) {
+        for (const entity of pair.rows) {
+            this.#invalidated.push(row_of_entity(entity));
+        }
+    }
+
+    /**
+     * A bake of a surface cache is recorded in full: its rows find it, and the bricks they reach gather
+     * what it holds now.
+     *
+     * @param {number} cache
+     */
+    #surface_baked(cache) {
+        const pair = this.#pair_of_cache[cache];
 
         if (pair === undefined) {
             return;
         }
 
         for (const entity of pair.rows) {
-            this.#write_row(entity, card_set);
+            this.#write_row(entity, cache);
         }
+
+        this.#invalidate_pair(pair);
     }
 
     /**
-     * @param {number} card_set
+     * @param {number} cache
      */
-    #card_set_withdrawn(card_set) {
-        const pair = this.#pair_of_card_set[card_set];
+    #cache_withdrawn(cache) {
+        const pair = this.#pair_of_cache[cache];
 
         if (pair === undefined) {
             return;
@@ -536,7 +676,8 @@ export class ProbeClipmapSceneHolds {
         const two_sided = material.draw_side === ShadeDrawSide.Double;
 
         for (const pair of of_material) {
-            sdf.cards.recapture(pair.card_set);
+            sdf.surfaces.recapture(pair.cache);
+
             this.#recaptures_requested++;
 
             if (pair.two_sided === two_sided) {
@@ -560,69 +701,6 @@ export class ProbeClipmapSceneHolds {
      * @param {number} value
      */
     #write_row(entity, value) {
-        const row = row_of_entity(entity);
-
-        if (row >= this.#rows_mirror.length) {
-            this.#grow_mirror(row + 1);
-        }
-
-        if (this.#rows_mirror[row] === value) {
-            return;
-        }
-
-        this.#rows_mirror[row] = value;
-
-        this.#rows_dirty_low = Math.min(this.#rows_dirty_low, row);
-        this.#rows_dirty_high = Math.max(this.#rows_dirty_high, row);
-    }
-
-    /**
-     * @param {number} length
-     */
-    #grow_mirror(length) {
-        let capacity = Math.max(INITIAL_ROW_CAPACITY, this.#rows_mirror.length);
-
-        while (capacity < length) {
-            capacity *= 2;
-        }
-
-        const grown = new Uint32Array(capacity).fill(GPU_DATABASE_NULL);
-
-        grown.set(this.#rows_mirror);
-
-        this.#rows_mirror = grown;
-    }
-
-    /**
-     * A table buffer for at least `rows` rows; a new one gets the whole mirror.
-     *
-     * @param {number} rows
-     * @returns {boolean} whether the buffer is new
-     */
-    #ensure_rows(rows) {
-        if (rows > this.#rows_mirror.length) {
-            this.#grow_mirror(rows);
-        }
-
-        if (this.#rows_buffer !== null && this.#rows_buffer.size >= 4 * this.#rows_mirror.length) {
-            return false;
-        }
-
-        this.#rows_buffer?.destroy();
-
-        const device = this.#device;
-
-        this.#rows_buffer = device.createBuffer(BufferDescriptor.fromJSON({
-            label: "ProbeClipmapSceneHolds/rows",
-            size: 4 * this.#rows_mirror.length,
-            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-        }));
-
-        device.queue.writeBuffer(this.#rows_buffer, 0, this.#rows_mirror);
-
-        this.#rows_dirty_low = Infinity;
-        this.#rows_dirty_high = -1;
-
-        return true;
+        this.#surface_rows.write(row_of_entity(entity), value);
     }
 }