@woosh/meep-engine 3.57.0 → 3.58.0

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

@@ -0,0 +1,83 @@
+/**
+ * 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):
+ *
+ * - 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,
+ *   `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`; a virtual geometry is absent,
+ * served by its own provider. 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.
+ *
+ * When the resident material context repacks 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.
+ *
+ * {@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.
+ */
+export class ProbeClipmapSceneHolds {
+    /**
+     * @param {GPUSceneContext} scene
+     * @param {GraphicsContext} graphics whose resident materials' repacks recapture the pairs of the material
+     */
+    constructor(scene: GPUSceneContext, graphics: GraphicsContext);
+    /**
+     * @returns {GPUSceneContext}
+     */
+    get scene(): import("../../scene/GPUSceneContext.js").GPUSceneContext;
+    /**
+     * Rows holding a cache.
+     * @returns {number}
+     */
+    get hold_count(): number;
+    /**
+     * (geometry, material) pairs the rows draw, a card set each.
+     * @returns {number}
+     */
+    get pair_count(): number;
+    /**
+     * Recaptures asked for, a pair each time its material was repacked.
+     * @returns {number}
+     */
+    get recaptures_requested(): number;
+    /**
+     * The rows invalidated since the last {@link clear_invalidated}, a row as often as it was.
+     * @returns {ReadonlyArray<number>}
+     */
+    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.
+     *
+     * @param {GPUGeometryMetadata} record
+     * @param {ShadeMaterial} material
+     * @returns {number|undefined}
+     */
+    card_set_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}.
+     * @returns {GPUBuffer}
+     */
+    get rows_buffer(): GPUBuffer;
+    attach(): void;
+    detach(): void;
+    /**
+     * Put the table's changed rows on the device, ahead of the frame's commands.
+     */
+    flush(): void;
+    #private;
+}
+export type GPUSceneContext = import("../../scene/GPUSceneContext.js").GPUSceneContext;
+export type MeshletGeometry = import("../../geometry/MeshletGeometry.js").MeshletGeometry;
+export type GPUGeometryMetadata = import("../../geometry/GPUGeometryMetadata.js").GPUGeometryMetadata;
+export type ShadeMaterial = import("../../material/ShadeMaterial.js").ShadeMaterial;
+export type GPUResidentMaterialContext = import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
+export type GraphicsContext = import("../../GraphicsContext.js").GraphicsContext;
+//# sourceMappingURL=ProbeClipmapSceneHolds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProbeClipmapSceneHolds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;;GAsBG;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;8BAzmBY,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;4BACnE,OAAO,iCAAiC,EAAE,aAAa;yCACvD,OAAO,uDAAuD,EAAE,0BAA0B;8BAC1F,OAAO,0BAA0B,EAAE,eAAe"}

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

@@ -0,0 +1,626 @@
+import { assert } from "../../../../core/assert.js";
+import { BufferDescriptor } from "../../../descriptor/buffer/BufferDescriptor.js";
+import { GPU_DATABASE_NULL } from "../../buffer/table/GPU_DATABASE_NULL.js";
+import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
+import { MESH_FLAG_SDF_WORLD, MESH_FLAG_SKINNED } from "../../scene/MESH_INSTANCE_METADATA_STRUCT.js";
+import { row_of_entity } from "../../scene/rows/GPUSceneRows.js";
+
+/**
+ * @typedef {import("../../scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ * @typedef {import("../../geometry/MeshletGeometry.js").MeshletGeometry} MeshletGeometry
+ * @typedef {import("../../geometry/GPUGeometryMetadata.js").GPUGeometryMetadata} GPUGeometryMetadata
+ * @typedef {import("../../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ * @typedef {import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} GPUResidentMaterialContext
+ * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
+ */
+
+/**
+ * Material ids a geometry's pairs are told apart by: a pair's key is its geometry id times this, plus
+ * its material id. The resident material table holds far fewer.
+ * @type {number}
+ */
+const PAIR_KEY_MATERIAL_SPAN = 2 ** 20;
+
+/**
+ * Rows the row → card set 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.
+ */
+class Pair {
+    /** @type {number} */
+    key = 0;
+
+    /** @type {ShadeMaterial|undefined} */
+    material = undefined;
+
+    /** @type {number} */
+    card_set = 0;
+
+    /**
+     * Whether its rows hold the geometry's cache as drawing both sides: the material's side, as it was
+     * when last packed.
+     * @type {boolean}
+     */
+    two_sided = false;
+
+    /**
+     * The entities whose rows draw it.
+     * @type {Set<number>}
+     */
+    rows = new Set();
+}
+
+/**
+ * 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):
+ *
+ * - 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,
+ *   `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`; a virtual geometry is absent,
+ * served by its own provider. 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.
+ *
+ * When the resident material context repacks 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.
+ *
+ * {@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.
+ */
+export class ProbeClipmapSceneHolds {
+
+    /**
+     * @type {GPUSceneContext}
+     */
+    #scene;
+
+    /**
+     * @type {GPUResidentMaterialContext}
+     */
+    #materials;
+
+    /**
+     * @type {GPUDevice}
+     */
+    #device;
+
+    /**
+     * The record each entity's row holds a cache through.
+     * @type {Map<number, GPUGeometryMetadata>}
+     */
+    #held = new Map();
+
+    /**
+     * The pair each entity's row draws.
+     * @type {Map<number, Pair>}
+     */
+    #pair_of = new Map();
+
+    /**
+     * @type {Map<number, Pair>}
+     */
+    #pairs = new Map();
+
+    /**
+     * Each material's pairs, by material id.
+     * @type {Map<number, Set<Pair>>}
+     */
+    #pairs_of_material = new Map();
+
+    /**
+     * Each geometry's pairs, by geometry id: whose rows a completed bake invalidates.
+     * @type {Map<number, Set<Pair>>}
+     */
+    #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.
+     * @type {number[]}
+     */
+    #invalidated = [];
+
+    /**
+     * Each card set's pair, by card set id.
+     * @type {(Pair|undefined)[]}
+     */
+    #pair_of_card_set = [];
+
+    #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;
+
+    #attached = false;
+
+    /**
+     * @param {GPUSceneContext} scene
+     * @param {GraphicsContext} graphics whose resident materials' repacks recapture the pairs of the material
+     */
+    constructor(scene, graphics) {
+        assert.defined(scene, 'scene');
+        assert.defined(graphics, 'graphics');
+
+        this.#scene = scene;
+        this.#materials = graphics.materials_resident;
+        this.#device = graphics.device;
+    }
+
+    /**
+     * @returns {GPUSceneContext}
+     */
+    get scene() {
+        return this.#scene;
+    }
+
+    /**
+     * Rows holding a cache.
+     * @returns {number}
+     */
+    get hold_count() {
+        return this.#held.size;
+    }
+
+    /**
+     * (geometry, material) pairs the rows draw, a card set each.
+     * @returns {number}
+     */
+    get pair_count() {
+        return this.#pairs.size;
+    }
+
+    /**
+     * Recaptures asked for, a pair each time its material was repacked.
+     * @returns {number}
+     */
+    get recaptures_requested() {
+        return this.#recaptures_requested;
+    }
+
+    /**
+     * The rows invalidated since the last {@link clear_invalidated}, a row as often as it was.
+     * @returns {ReadonlyArray<number>}
+     */
+    get invalidated() {
+        return this.#invalidated;
+    }
+
+    clear_invalidated() {
+        this.#invalidated.length = 0;
+    }
+
+    /**
+     * The card set 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;
+    }
+
+    /**
+     * 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}.
+     * @returns {GPUBuffer}
+     */
+    get rows_buffer() {
+        this.#ensure_rows(1);
+
+        return this.#rows_buffer;
+    }
+
+    attach() {
+        assert.notOk(this.#attached, 'attached already');
+
+        this.#attached = true;
+
+        const rows = this.#scene.rows;
+        const cards = this.#scene.geometries.sdf.cards;
+
+        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);
+        this.#materials.onMaterialRepacked.add(this.#repacked, this);
+
+        // a row not yet written is taken now, and moved when it is
+        rows.for_each_mesh((entity, geometry, material, skinned, flags) => this.#written(entity, geometry, material, flags));
+    }
+
+    detach() {
+        if (!this.#attached) {
+            return;
+        }
+
+        this.#attached = false;
+
+        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);
+        this.#materials.onMaterialRepacked.remove(this.#repacked, this);
+
+        for (const [entity, record] of this.#held) {
+            sdf.release(record, this.#pair_of.get(entity).two_sided);
+        }
+
+        for (const pair of this.#pairs.values()) {
+            cards.release(pair.card_set);
+        }
+
+        this.#held.clear();
+        this.#pair_of.clear();
+        this.#pairs.clear();
+        this.#pairs_of_material.clear();
+        this.#pairs_of_geometry.clear();
+        this.#pair_of_card_set.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;
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * @param {number} entity
+     * @param {MeshletGeometry} geometry the source, for a skinned row
+     * @param {ShadeMaterial} material
+     * @param {number} flags
+     */
+    #written(entity, geometry, material, flags) {
+        const geometries = this.#scene.geometries;
+        const sdf = geometries.sdf;
+
+        const previous = this.#held.get(entity);
+        const previous_pair = this.#pair_of.get(entity);
+
+        let record;
+        let pair;
+
+        if ((flags & MESH_FLAG_SDF_WORLD) !== 0 && geometry.isVirtualGeometry !== true) {
+            record = geometries.get_metadata(geometry);
+        }
+
+        if (record !== undefined) {
+            pair = this.#obtain_pair(record, material);
+
+            sdf.acquire(record, pair.two_sided);
+
+            if ((flags & MESH_FLAG_SKINNED) !== 0) {
+                const clone = this.#scene.skinning.clone_of(entity);
+
+                if (clone !== undefined) {
+                    sdf.alias(clone, record);
+                }
+            }
+
+            this.#held.set(entity, record);
+            this.#pair_of.set(entity, pair);
+        } else {
+            this.#held.delete(entity);
+            this.#pair_of.delete(entity);
+        }
+
+        if (pair !== previous_pair) {
+            pair?.rows.add(entity);
+
+            if (previous_pair !== undefined) {
+                this.#leave_pair(previous_pair, entity);
+            }
+        }
+
+        this.#write_row(entity, pair !== undefined && sdf.cards.is_resident(pair.card_set) ? pair.card_set : 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)) {
+            this.#invalidated.push(row_of_entity(entity));
+        }
+
+        if (previous !== undefined) {
+            sdf.release(previous, previous_pair.two_sided);
+        }
+    }
+
+    /**
+     * A geometry's field turned resident: every row drawing it builds the bricks its box reaches again.
+     *
+     * @param {number} geometry the geometry id
+     */
+    #baked(geometry) {
+        const pairs = this.#pairs_of_geometry.get(geometry);
+
+        if (pairs === undefined) {
+            return;
+        }
+
+        for (const pair of pairs) {
+            for (const entity of pair.rows) {
+                this.#invalidated.push(row_of_entity(entity));
+            }
+        }
+    }
+
+    /**
+     * @param {number} entity
+     */
+    #released(entity) {
+        const previous = this.#held.get(entity);
+
+        if (previous === undefined) {
+            return;
+        }
+
+        const pair = this.#pair_of.get(entity);
+
+        this.#held.delete(entity);
+        this.#scene.geometries.sdf.release(previous, pair.two_sided);
+
+        this.#pair_of.delete(entity);
+        this.#leave_pair(pair, entity);
+
+        this.#write_row(entity, GPU_DATABASE_NULL);
+    }
+
+    /**
+     * @param {GPUGeometryMetadata} record
+     * @param {ShadeMaterial} material
+     * @returns {Pair}
+     */
+    #obtain_pair(record, material) {
+        assert.lessThan(material.id, PAIR_KEY_MATERIAL_SPAN, 'material.id');
+
+        const key = record.index * PAIR_KEY_MATERIAL_SPAN + material.id;
+
+        let pair = this.#pairs.get(key);
+
+        if (pair !== undefined) {
+            return pair;
+        }
+
+        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);
+
+        this.#pairs.set(key, pair);
+        this.#pair_of_card_set[pair.card_set] = pair;
+
+        let of_material = this.#pairs_of_material.get(material.id);
+
+        if (of_material === undefined) {
+            of_material = new Set();
+            this.#pairs_of_material.set(material.id, of_material);
+        }
+
+        of_material.add(pair);
+
+        let of_geometry = this.#pairs_of_geometry.get(record.index);
+
+        if (of_geometry === undefined) {
+            of_geometry = new Set();
+            this.#pairs_of_geometry.set(record.index, of_geometry);
+        }
+
+        of_geometry.add(pair);
+
+        return pair;
+    }
+
+    /**
+     * @param {Pair} pair
+     * @param {number} entity
+     */
+    #leave_pair(pair, entity) {
+        pair.rows.delete(entity);
+
+        if (pair.rows.size > 0) {
+            return;
+        }
+
+        this.#scene.geometries.sdf.cards.release(pair.card_set);
+
+        this.#pairs.delete(pair.key);
+        this.#pair_of_card_set[pair.card_set] = undefined;
+
+        const of_material = this.#pairs_of_material.get(pair.material.id);
+
+        of_material.delete(pair);
+
+        if (of_material.size === 0) {
+            this.#pairs_of_material.delete(pair.material.id);
+        }
+
+        const geometry = Math.floor(pair.key / PAIR_KEY_MATERIAL_SPAN);
+        const of_geometry = this.#pairs_of_geometry.get(geometry);
+
+        of_geometry.delete(pair);
+
+        if (of_geometry.size === 0) {
+            this.#pairs_of_geometry.delete(geometry);
+        }
+    }
+
+    /**
+     * @param {number} card_set
+     */
+    #card_set_resident(card_set) {
+        const pair = this.#pair_of_card_set[card_set];
+
+        if (pair === undefined) {
+            return;
+        }
+
+        for (const entity of pair.rows) {
+            this.#write_row(entity, card_set);
+        }
+    }
+
+    /**
+     * @param {number} card_set
+     */
+    #card_set_withdrawn(card_set) {
+        const pair = this.#pair_of_card_set[card_set];
+
+        if (pair === undefined) {
+            return;
+        }
+
+        for (const entity of pair.rows) {
+            this.#write_row(entity, GPU_DATABASE_NULL);
+        }
+    }
+
+    /**
+     * @param {ShadeMaterial} material
+     */
+    #repacked(material) {
+        const of_material = this.#pairs_of_material.get(material.id);
+
+        if (of_material === undefined) {
+            return;
+        }
+
+        const sdf = this.#scene.geometries.sdf;
+        const two_sided = material.draw_side === ShadeDrawSide.Double;
+
+        for (const pair of of_material) {
+            sdf.cards.recapture(pair.card_set);
+            this.#recaptures_requested++;
+
+            if (pair.two_sided === two_sided) {
+                continue;
+            }
+
+            // the new hold taken before the old one goes, so the cache is never let go in between
+            for (const entity of pair.rows) {
+                const record = this.#held.get(entity);
+
+                sdf.acquire(record, two_sided);
+                sdf.release(record, pair.two_sided);
+            }
+
+            pair.two_sided = two_sided;
+        }
+    }
+
+    /**
+     * @param {number} entity
+     * @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;
+    }
+}