@woosh/meep-engine 3.69.0 → 3.70.0

package/src/shade/renderer/geometry/bvh/GPUBLASRefitBatch.js

@@ -1,13 +1,11 @@
 import { assert } from "../../../../core/assert.js";
-import {
-    BVH_REFIT_DEFERRED_HEADER_BYTES,
-    bvh_refit_deferred_byte_size
-} from "../../gpu_primitive/bvh/BVH_REFIT_DEFERRED_LAYOUT.js";
-import { shader_bvh_refit_repair } from "../../gpu_primitive/bvh/shader_bvh_refit_repair.js";
 import { write_gpu_typed_buffer } from "../../shader/type/serde/write_gpu_typed_buffer.js";
-import { BLAS_REFIT_TARGET_STRUCT } from "./BLAS_REFIT_TARGET_STRUCT.js";
-import { BLAS_REFIT_BATCH_WORKGROUP_SIZE, shader_blas_refit_batch } from "./shader_blas_refit_batch.js";
-import { shader_blas_refit_batch_seed } from "./shader_blas_refit_batch_seed.js";
+import { BLAS8_REFIT_TARGET_STRUCT } from "./BLAS8_REFIT_TARGET_STRUCT.js";
+import {
+    BLAS8_REFIT_BATCH_WORKGROUP_SIZE,
+    BLAS8_REFIT_SPINE_STRIDE_WORDS,
+    shader_blas8_refit_batch
+} from "./shader_blas8_refit_batch.js";
 
 /**
  * Initial capacity of the target table, in rows. Doubles as needed.
@@ -15,7 +13,7 @@ import { shader_blas_refit_batch_seed } from "./shader_blas_refit_batch_seed.js"
 const TARGETS_INITIAL_CAPACITY = 16;
 
 /**
- * Initial capacity of a workgroup lookup, in `(target_index, base)` pairs. Doubles as needed.
+ * Initial capacity of the workgroup lookup, in `(target_index, node_base)` pairs. Doubles as needed.
  */
 const LOOKUP_INITIAL_CAPACITY = 256;
 
@@ -28,35 +26,32 @@ const LOOKUP_PAIR_WORDS = 2;
  * Refit a set of BLAS trees every frame, as one batch: a fixed number of commands whatever the
  * number of trees, and no per-tree host work while the set and its residency hold still.
  *
- * The seam is the one the per-tree recorder had: an entry is an `owner` — the identity a tree
- * was registered under, per {@link GPUGeometryBVHManager#obtain} — and a `geometry_index`, the row
- * whose vertices the bounds come from. Nothing here knows what a clone is, or that skinning is why
- * the vertices moved; anything that deforms vertices in place can list its trees here.
+ * An entry is an `owner` — the identity a tree was registered under, per
+ * {@link GPUGeometryBVHManager#obtain} — and a `geometry_index`, the row whose vertices the boxes
+ * come from. Nothing here knows what a clone is, or that skinning is why the vertices moved; anything
+ * that deforms vertices in place can list its trees here.
  *
- * Three tables live on the GPU between frames. The target rows ({@link BLAS_REFIT_TARGET_STRUCT})
- * say where each tree sits in the manager's arenas and where its arrival counters sit in the
- * batch's own; the two lookups say, for every workgroup of a dispatch, which tree it serves and
- * which run of that tree's leaves — or, for the seeding pass, of its node slots. All three are
- * rebuilt from {@link GPUGeometryBVHManager#get_refit_target} when the entries change or the
- * manager's {@link GPUGeometryBVHManager#residency_version} moves, and not otherwise. Entries whose
- * tree is not resident yet are simply absent from the tables; the version moving is what brings
+ * Two tables live on the GPU between frames. The target rows ({@link BLAS8_REFIT_TARGET_STRUCT}) say
+ * where each tree sits in the manager's arena and where its part of the batch's spine starts; the
+ * lookup says, for every workgroup of the dispatch, which tree it serves and which run of that tree's
+ * nodes. Both are rebuilt from {@link GPUGeometryBVHManager#get_refit_target} when the entries change
+ * or the manager's {@link GPUGeometryBVHManager#residency_version} moves, and not otherwise. Entries
+ * whose tree is not resident yet are simply absent from the tables; the version moving is what brings
  * them in.
  *
- * Every frame is then: two transient buffers, the counters and the deferred list, with a clear
- * each; {@link shader_blas_refit_batch_seed} and then {@link shader_blas_refit_batch}, one dispatch
- * per page of workgroups under the device's per-dimension cap — one page for well over a hundred
- * characters of the playground's size; and one indirect {@link shader_bvh_refit_repair}, which runs
- * nothing unless a climb read a box before it arrived (R1 in GPU_BVH_BUILD_PLAN.md).
+ * Every frame is then one transient buffer, the spine, with its clear, and
+ * {@link shader_blas8_refit_batch}: one dispatch per page of workgroups under the device's
+ * per-dimension cap.
  *
  * `record` belongs inside {@link GPUMeshSkinningContext#update}, or somewhere with the same
- * guarantee: it binds the manager's arena buffers as they are at that moment, and those buffers are
- * replaced — the old ones destroyed — when an arena grows in {@link GPUGeometryBVHManager#update}.
+ * guarantee: it binds the manager's arena buffer as it is at that moment, and that buffer is
+ * replaced — the old one destroyed — when the arena grows in {@link GPUGeometryBVHManager#update}.
  * That runs before the frame's command context exists, so a refit recorded inside the frame is safe
  * by call order. A refit recorded across one of those updates would submit a destroyed buffer, and
  * the software device cannot catch it, since it executes nothing at submit.
  */
-export class GPUBLASRefitBatch {
-
+export class GPUBLASRefitBatch {
+
     /** @type {GPUDevice} */
     #device;
 
@@ -92,22 +87,20 @@ export class GPUBLASRefitBatch {
     #targets_capacity = 0;
 
     /**
-     * The refit's workgroup lookup: a `(target_index, leaf_base)` pair per workgroup.
+     * A `(target_index, node_base)` pair per workgroup.
      *
-     * @type {{buffer: GPUBuffer|null, capacity: number, label: string}}
+     * @type {GPUBuffer|null}
      */
-    #leaf_runs = { buffer: null, capacity: 0, label: 'GPUBLASRefitBatch/Lookup' };
+    #lookup_buffer = null;
 
     /**
-     * The seeding pass's workgroup lookup: a `(target_index, slot_base)` pair per workgroup, over
-     * every node slot of every tree.
-     *
-     * @type {{buffer: GPUBuffer|null, capacity: number, label: string}}
+     * Capacity of {@link #lookup_buffer}, in pairs.
+     * @type {number}
      */
-    #slot_runs = { buffer: null, capacity: 0, label: 'GPUBLASRefitBatch/SlotLookup' };
+    #lookup_capacity = 0;
 
     /**
-     * Workgroups the batch dispatches, across every page: one per aligned run of leaves of every
+     * Workgroups the batch dispatches, across every page: one per aligned run of nodes of every
      * resident tree. Zero means there is nothing to record.
      *
      * @type {number}
@@ -115,26 +108,11 @@ export class GPUBLASRefitBatch {
     #workgroup_count = 0;
 
     /**
-     * Workgroups the seeding pass dispatches, across every page: one per aligned run of node slots of
-     * every resident tree.
-     *
-     * @type {number}
-     */
-    #slot_workgroup_count = 0;
-
-    /**
-     * Words of arrival counters the batch needs: the sum of every resident tree's node slots.
-     *
-     * @type {number}
-     */
-    #counter_words = 0;
-
-    /**
-     * Internal nodes across every resident tree: the most the climbs can defer.
+     * Nodes across every resident tree: what the spine has to hold a box for.
      *
      * @type {number}
      */
-    #internal_node_count = 0;
+    #node_count = 0;
 
     /**
      * @param {GPUDevice} device
@@ -149,7 +127,7 @@ export class GPUBLASRefitBatch {
      * The set of trees to refit from now on. Replaces the previous set; the tables are rebuilt on the
      * next {@link record}.
      *
-     * An owner may appear once: two rows for one tree would be two climbs racing on its nodes.
+     * An owner may appear once: two rows for one tree would be two sets of lanes writing its nodes.
      *
      * @param {{owner: object, geometry_index: number}[]} entries
      */
@@ -176,8 +154,8 @@ export class GPUBLASRefitBatch {
      *
      * @param {ShadeGPUCommandContext} cmd
      * @param {Object} options
-     * @param {GPUGeometryBVHManager} options.blas tree residency — arenas for nodes, parents and leaf lists
-     * @param {GPUGeometryManager} options.geometries geometry metadata table the leaf boxes read vertices through
+     * @param {GPUGeometryBVHManager} options.blas tree residency — the node arena
+     * @param {GPUGeometryManager} options.geometries geometry metadata table the boxes read vertices through
      * @returns {boolean} whether anything was recorded
      */
     record(cmd, { blas, geometries }) {
@@ -195,61 +173,32 @@ export class GPUBLASRefitBatch {
             return false;
         }
 
-        // One counter per node slot of every tree, and every one of them has to start at zero: a
-        // leftover count lets a first arrival believe it is a second and fit a node from a sibling
-        // nothing has written yet. The transient allocator pools its buffers, so whatever comes
-        // back is carrying the last frame's counts and gets cleared — once, for the whole batch.
-        const counters_size = this.#counter_words * Uint32Array.BYTES_PER_ELEMENT;
-
-        const counters = cmd.allocateTransientBuffer(GPUBufferUsage.STORAGE, counters_size);
+        // A box per node of every tree, and every word of it has to start at zero, which reads "not
+        // here yet": a leftover word would be taken for a box nothing has found this frame. The
+        // transient allocator pools its buffers, so whatever comes back is carrying an earlier
+        // frame's boxes and gets cleared — once, for the whole batch.
+        const spine_size = this.#node_count * BLAS8_REFIT_SPINE_STRIDE_WORDS * Uint32Array.BYTES_PER_ELEMENT;
 
-        cmd.clearBuffer(counters, 0, counters_size);
+        const spine = cmd.allocateTransientBuffer(GPUBufferUsage.STORAGE, spine_size);
 
-        // What the climbs defer, with the repair's dispatch command in its first words. Only the
-        // header has to start at zero, for the reason the counters do.
-        const deferred = cmd.allocateTransientBuffer(
-            GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
-            bvh_refit_deferred_byte_size(this.#internal_node_count)
-        );
-
-        cmd.clearBuffer(deferred, 0, BVH_REFIT_DEFERRED_HEADER_BYTES);
+        cmd.clearBuffer(spine, 0, spine_size);
 
         const meshlets = geometries.meshlets;
 
-        // The arena buffers are read off the manager here and now, every frame: they are replaced
-        // when an arena grows, and only their contents' offsets are stable.
+        // The arena buffer is read off the manager here and now, every frame: it is replaced when
+        // the arena grows, and only its contents' offsets are stable.
         const page = this.#device.limits.maxComputeWorkgroupsPerDimension;
 
-        // Every bound word the climbs will read, seeded a dispatch ahead of them, so a box that has
-        // not reached its reader is one the reader can see is missing.
-        const slot_workgroup_count = this.#slot_workgroup_count;
-
-        for (let offset = 0; offset < slot_workgroup_count; offset += page) {
-            shader_blas_refit_batch_seed.dispatch({
-                encoder: cmd,
-                group_count_x: Math.min(page, slot_workgroup_count - offset),
-                bindings: {
-                    dispatch_offset: offset,
-                    targets: this.#targets_buffer,
-                    lookup: this.#slot_runs.buffer,
-                    nodes: blas.buffer_data,
-                },
-            });
-        }
-
         for (let offset = 0; offset < workgroup_count; offset += page) {
-            shader_blas_refit_batch.dispatch({
+            shader_blas8_refit_batch.dispatch({
                 encoder: cmd,
                 group_count_x: Math.min(page, workgroup_count - offset),
                 bindings: {
                     dispatch_offset: offset,
                     targets: this.#targets_buffer,
-                    lookup: this.#leaf_runs.buffer,
-                    leaf_nodes: blas.buffer_leaf_nodes,
-                    parents: blas.buffer_parents,
-                    counters,
+                    lookup: this.#lookup_buffer,
                     nodes: blas.buffer_data,
-                    refit_deferred: deferred,
+                    spine,
                     geometries: geometries.buffer_metadata,
                     meshlet_metadata: meshlets.buffer_metadata,
                     meshlet_data: meshlets.buffer_data,
@@ -257,16 +206,6 @@ export class GPUBLASRefitBatch {
             });
         }
 
-        shader_bvh_refit_repair.dispatchIndirect({
-            encoder: cmd,
-            command: deferred,
-            bindings: {
-                parents: blas.buffer_parents,
-                refit_deferred: deferred,
-                nodes: blas.buffer_data,
-            },
-        });
-
         return true;
     }
 
@@ -278,45 +217,35 @@ export class GPUBLASRefitBatch {
     #resolve(blas) {
         const rows = [];
 
-        let counter_words = 0;
+        let node_count = 0;
         let workgroup_count = 0;
-        let slot_workgroup_count = 0;
-        let internal_node_count = 0;
 
         for (const entry of this.#entries) {
             const target = blas.get_refit_target(entry.owner);
 
-            if (target === undefined || target.leaf_count === 0) {
+            if (target === undefined || target.node_count === 0) {
                 // not resident yet, or nothing to fit; the version moving is what brings it in
                 continue;
             }
 
             rows.push({
-                node_word_offset: target.node_word_offset,
-                parents_offset: target.parents_offset,
-                leaf_nodes_offset: target.leaf_nodes_offset,
-                leaf_count: target.leaf_count,
+                node_offset: target.node_offset,
                 node_count: target.node_count,
-                counters_offset: counter_words,
+                spine_offset: node_count,
                 geometry_index: entry.geometry_index,
             });
 
-            counter_words += target.node_count;
-            workgroup_count += Math.ceil(target.leaf_count / BLAS_REFIT_BATCH_WORKGROUP_SIZE);
-            slot_workgroup_count += Math.ceil(target.node_count / BLAS_REFIT_BATCH_WORKGROUP_SIZE);
-            internal_node_count += target.leaf_count - 1;
+            node_count += target.node_count;
+            workgroup_count += Math.ceil(target.node_count / BLAS8_REFIT_BATCH_WORKGROUP_SIZE);
         }
 
         if (rows.length > 0) {
             this.#upload_targets(rows);
-            this.#upload_runs(this.#leaf_runs, rows, row => row.leaf_count, workgroup_count);
-            this.#upload_runs(this.#slot_runs, rows, row => row.node_count, slot_workgroup_count);
+            this.#upload_lookup(rows, workgroup_count);
         }
 
         this.#workgroup_count = workgroup_count;
-        this.#slot_workgroup_count = slot_workgroup_count;
-        this.#counter_words = counter_words;
-        this.#internal_node_count = internal_node_count;
+        this.#node_count = node_count;
 
         this.#entries_dirty = false;
         this.#resolved_version = blas.residency_version;
@@ -326,45 +255,42 @@ export class GPUBLASRefitBatch {
      * @param {object[]} rows
      */
     #upload_targets(rows) {
-        const stride = BLAS_REFIT_TARGET_STRUCT.aligned_size;
+        const stride = BLAS8_REFIT_TARGET_STRUCT.aligned_size;
 
         this.#ensure_targets_capacity(rows.length);
 
         const data = new ArrayBuffer(rows.length * stride);
 
         for (let i = 0; i < rows.length; i++) {
-            write_gpu_typed_buffer(rows[i], BLAS_REFIT_TARGET_STRUCT, data, i * stride);
+            write_gpu_typed_buffer(rows[i], BLAS8_REFIT_TARGET_STRUCT, data, i * stride);
         }
 
         this.#device.queue.writeBuffer(this.#targets_buffer, 0, data);
     }
 
     /**
-     * One `(target_index, base)` pair per workgroup: tree by tree, run by run of whatever
-     * `count_of` counts in it — its leaves for the refit, its node slots for the seeding pass.
+     * One `(target_index, node_base)` pair per workgroup: tree by tree, run by run of its nodes.
      *
-     * @param {{buffer: GPUBuffer|null, capacity: number, label: string}} runs
      * @param {object[]} rows
-     * @param {function(object): number} count_of
      * @param {number} workgroup_count
      */
-    #upload_runs(runs, rows, count_of, workgroup_count) {
-        this.#ensure_runs_capacity(runs, workgroup_count);
+    #upload_lookup(rows, workgroup_count) {
+        this.#ensure_lookup_capacity(workgroup_count);
 
         const pairs = new Uint32Array(workgroup_count * LOOKUP_PAIR_WORDS);
 
         let cursor = 0;
 
         for (let target_index = 0; target_index < rows.length; target_index++) {
-            const count = count_of(rows[target_index]);
+            const count = rows[target_index].node_count;
 
-            for (let base = 0; base < count; base += BLAS_REFIT_BATCH_WORKGROUP_SIZE) {
+            for (let base = 0; base < count; base += BLAS8_REFIT_BATCH_WORKGROUP_SIZE) {
                 pairs[cursor++] = target_index;
                 pairs[cursor++] = base;
             }
         }
 
-        this.#device.queue.writeBuffer(runs.buffer, 0, pairs);
+        this.#device.queue.writeBuffer(this.#lookup_buffer, 0, pairs);
     }
 
     /**
@@ -387,7 +313,7 @@ export class GPUBLASRefitBatch {
 
         this.#targets_buffer = this.#device.createBuffer({
             label: 'GPUBLASRefitBatch/Targets',
-            size: capacity * BLAS_REFIT_TARGET_STRUCT.aligned_size,
+            size: capacity * BLAS8_REFIT_TARGET_STRUCT.aligned_size,
             usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
         });
 
@@ -395,31 +321,30 @@ export class GPUBLASRefitBatch {
     }
 
     /**
-     * @param {{buffer: GPUBuffer|null, capacity: number, label: string}} runs
      * @param {number} pairs
      */
-    #ensure_runs_capacity(runs, pairs) {
-        if (runs.buffer !== null && pairs <= runs.capacity) {
+    #ensure_lookup_capacity(pairs) {
+        if (this.#lookup_buffer !== null && pairs <= this.#lookup_capacity) {
             return;
         }
 
-        let capacity = Math.max(runs.capacity, LOOKUP_INITIAL_CAPACITY);
+        let capacity = Math.max(this.#lookup_capacity, LOOKUP_INITIAL_CAPACITY);
 
         while (capacity < pairs) {
             capacity *= 2;
         }
 
-        if (runs.buffer !== null) {
-            runs.buffer.destroy();
+        if (this.#lookup_buffer !== null) {
+            this.#lookup_buffer.destroy();
         }
 
-        runs.buffer = this.#device.createBuffer({
-            label: runs.label,
+        this.#lookup_buffer = this.#device.createBuffer({
+            label: 'GPUBLASRefitBatch/Lookup',
             size: capacity * LOOKUP_PAIR_WORDS * Uint32Array.BYTES_PER_ELEMENT,
             usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
         });
 
-        runs.capacity = capacity;
+        this.#lookup_capacity = capacity;
     }
 
     destroy() {
@@ -428,20 +353,15 @@ export class GPUBLASRefitBatch {
             this.#targets_buffer = null;
         }
 
-        for (const runs of [this.#leaf_runs, this.#slot_runs]) {
-            if (runs.buffer !== null) {
-                runs.buffer.destroy();
-                runs.buffer = null;
-            }
-
-            runs.capacity = 0;
+        if (this.#lookup_buffer !== null) {
+            this.#lookup_buffer.destroy();
+            this.#lookup_buffer = null;
         }
 
         this.#targets_capacity = 0;
+        this.#lookup_capacity = 0;
         this.#workgroup_count = 0;
-        this.#slot_workgroup_count = 0;
-        this.#counter_words = 0;
-        this.#internal_node_count = 0;
+        this.#node_count = 0;
         this.#entries_dirty = true;
     }
 }

package/src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.d.ts

@@ -12,12 +12,11 @@ export const BLAS_METADATA_STRUCT: WebGPUStruct;
 /**
  * Arena node index of the empty tree: what the lookup names for a geometry that has no tree yet.
  *
- * One internal node whose box is +inf below and -inf above. No ray enters it, so the ray queries
- * pop it and miss; no point is within any distance of it, so the point queries prune it; and it is
- * internal, so nothing ever fetches a triangle for it. Its children are itself, and are never
- * descended into. Every traversal reads `blas_lookup[geometry_index]` and starts walking without a
- * null check, so "no tree" has to be a tree — and it must not be whatever tree happens to sit at
- * the arena's end, which is what a record resident over zero bytes used to point at.
+ * One node with every slot empty, which is a node of zeroes: no slot holds a triangle or a child, so
+ * a query finds nothing in it and has nowhere to go from it. Every traversal reads
+ * `blas_lookup[geometry_index]` and starts walking without a null check, so "no tree" has to be a
+ * tree — and it must not be whatever tree happens to sit at the arena's end, which is what a record
+ * resident over zero bytes used to point at.
  *
  * @type {number}
  */
@@ -53,14 +52,6 @@ export class GPUGeometryBVHManager {
      * @returns {GPUBuffer}
      */
     get buffer_data(): GPUBuffer;
-    /**
-     * @returns {GPUBuffer}
-     */
-    get buffer_parents(): GPUBuffer;
-    /**
-     * @returns {GPUBuffer}
-     */
-    get buffer_leaf_nodes(): GPUBuffer;
     /**
      * @returns {number}
      */
@@ -76,48 +67,40 @@ export class GPUGeometryBVHManager {
      * Bytes of the node arena that trees actually occupy: its capacity, less every region
      * {@link #allocator} still holds free.
      *
-     * Beside {@link gpu_memory_usage}, which is what the arenas cost whether or not anything is
-     * in them. The gap between the two is what a released tree gives back and what the next tree
+     * Beside {@link gpu_memory_usage}, which is what the arena and the lookup cost whether or not
+     * anything is in them. The gap between the two is what a released tree gives back and what the next tree
      * of that size takes, so it is the one worth watching.
      *
      * @returns {number} in bytes
      */
     get gpu_memory_usage_occupied(): number;
     /**
-     * The tree belonging to `owner`, registered against `source`'s shape if it does not exist yet.
+     * The tree belonging to `owner`, registered as a copy of `source`'s if it does not exist yet.
      *
      * Two arguments rather than one because those are two different questions. `owner` is the
      * identity the tree is looked up by; `source` is the geometry whose nodes it starts as. They
      * coincide for anything that owns its geometry outright, and they do not for a per-instance
-     * copy — a skinned clone deforms its own vertices, so its bounds are its own and cannot be
-     * written into the tree everyone else is tracing, but its *shape* is by definition the
-     * source's. Keeping the two separate is what lets one derivation serve every copy.
+     * copy — a skinned clone deforms its own vertices, so its boxes are its own and cannot be
+     * written into the tree everyone else is tracing.
      *
      * @param {object} owner identity to look this tree up by — a geometry, a clone's metadata row
-     * @param {MeshletGeometry} source geometry whose nodes this tree takes its shape and rest-pose
-     * bounds from
+     * @param {MeshletGeometry} source geometry whose nodes this tree starts as
      * @returns {GPUGeometryMeshletsBVH}
      */
     obtain(owner: object, source: MeshletGeometry): GPUGeometryMeshletsBVH;
     /**
      * Everything a refit needs to find a resident tree, or `undefined` while it is not resident.
      *
-     * "Resident" means the owner's nodes and its shape are both in their arenas, and that they are
-     * the same tree. A record snapshots its geometry's bytes when it is registered, and a geometry
-     * registered before its tree exists is uploaded as nothing — resident over zero bytes, at the
-     * arena's end. Its shape is derived later, from the bytes as they are then. Answering with that
-     * shape's counts at that record's address would hand a refit whichever tree was appended next,
-     * so the answer is withheld until the nodes actually uploaded are the tree the shape describes.
+     * The count is of the nodes that were uploaded, not of the geometry's tree as it is now: a
+     * refit writes exactly the region the record holds.
      *
      * @param {object} owner the identity passed to {@link obtain}
-     * @returns {{node_word_offset: number, node_count: number, leaf_count: number, parents_offset: number, leaf_nodes_offset: number}|undefined}
+     * @returns {{node_offset: number, node_count: number}|undefined} the arena node the tree's root
+     * sits at, and the nodes in the tree
      */
     get_refit_target(owner: object): {
-        node_word_offset: number;
+        node_offset: number;
         node_count: number;
-        leaf_count: number;
-        parents_offset: number;
-        leaf_nodes_offset: number;
     } | undefined;
     /**
      * Where a registered tree's root sits in the arena, or `undefined` while nothing is resident
@@ -152,16 +135,12 @@ export class GPUGeometryBVHManager {
      */
     remove(owner: object): boolean;
     /**
-     * Bring the arenas up to date with everything registered since the last call, and move the
+     * Bring the arena up to date with everything registered since the last call, and move the
      * residency version if anything a refit reads has changed.
-     *
-     * Shapes first, and as their own question: they are not behind the node queue, so a frame in
-     * which a shape arrives for an already-uploaded record still uploads it — and still moves the
-     * version, because that record's refit answer has changed all the same.
      */
     update(): void;
     /**
-     * Release the arena and its tables. For the geometry manager's own teardown: nothing is
+     * Release the arena and the lookup. For the geometry manager's own teardown: nothing is
      * obtained, uploaded or traced afterwards. Safe to call twice.
      */
     destroy(): void;

package/src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometryBVHManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.js"],"names":[],"mappings":"AAkBA;;;GAGG;AAEH;;;;;GAKG;AACH,gDAGG;AAEH;;;;;;;;;;;GAWG;AACH,sCAFU,MAAM,CAEyB;AA0CzC;;;;;;;;;;;;;;GAcG;AACH;IA8JI;;;OAGG;IACH,+BAoDC;IA9MD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,6BAEC;IAuCD;;OAEG;IACH,gCAEC;IAOD;;OAEG;IACH,mCAEC;IAmDD;;OAEG;IACH,gCAEC;IA6ED;;;;OAIG;IACH,iCAEC;IAED,+BAoBC;IAED;;;;;;;;;OASG;IACH,wCAIC;IAED;;;;;;;;;;;;;;OAcG;IACH,cALW,MAAM,UACN,eAAe,GAEb,sBAAsB,CAalC;IA8DD;;;;;;;;;;;;OAYG;IACH,wBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,GAAC,SAAS,CAqB3I;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAU5B;IAED;;;;;;;;;OASG;IACH,0BAFW,WAAW,QAQrB;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,GACJ,OAAO,CA8BnB;IA8RD;;;;;;;OAOG;IACH,eAOC;IAmJD;;;OAGG;IACH,gBAKC;;CACJ;8BA1+BY,OAAO,uBAAuB,EAAE,eAAe;yBAC/C,OAAO,sDAAsD,EAAE,UAAU;6BAbzD,mCAAmC;uCASzB,6BAA6B"}
+{"version":3,"file":"GPUGeometryBVHManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.js"],"names":[],"mappings":"AAYA;;;GAGG;AAEH;;;;;GAKG;AACH,gDAGG;AAEH;;;;;;;;;;GAUG;AACH,sCAFU,MAAM,CAEyB;AAmCzC;;;;;;;;;;;;;;GAcG;AACH;IAgGI;;;OAGG;IACH,+BAgCC;IA5HD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,6BAEC;IA6CD;;OAEG;IACH,gCAEC;IAyDD;;;;OAIG;IACH,iCAEC;IAED,+BAYC;IAED;;;;;;;;;OASG;IACH,wCAIC;IAED;;;;;;;;;;;;OAYG;IACH,cAJW,MAAM,UACN,eAAe,GACb,sBAAsB,CAalC;IA6BD;;;;;;;;;OASG;IACH,wBAJW,MAAM,GACJ;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,GAAC,SAAS,CAc/D;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAU5B;IAED;;;;;;;;;OASG;IACH,0BAFW,WAAW,QAQrB;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,GACJ,OAAO,CA4BnB;IAwFD;;;OAGG;IACH,eAIC;IAmJD;;;OAGG;IACH,gBAGC;;CACJ;8BAzoBY,OAAO,uBAAuB,EAAE,eAAe;yBAC/C,OAAO,sDAAsD,EAAE,UAAU;6BAPzD,mCAAmC;uCAGzB,6BAA6B"}