@woosh/meep-engine 3.68.0 → 3.70.0

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

@@ -6,14 +6,8 @@ import { Deque } from "../../../../core/collection/queue/Deque.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
-import {
-    BVH_NODE_BOUNDS_WORD,
-    BVH_NODE_CHILD_1_WORD,
-    BVH_NODE_CHILD_2_WORD
-} from "../../gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js";
+import { BVH8_INODE_STRUCT } from "../../shader/chunk/bvh/bvh8/webgpu/BVH8_INODE_STRUCT.js";
 import { ensure_buffer_capacity } from "../make_temp_gpu_buffer.js";
-import { bvh2_derive_topology } from "./bvh2_derive_topology.js";
 import { GPUGeometryMeshletsBVH } from "./GPUGeometryMeshletsBVH.js";
 
 /**
@@ -35,12 +29,11 @@ export const BLAS_METADATA_STRUCT = WebGPUStruct.from({
 /**
  * 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}
  */
@@ -52,13 +45,6 @@ const DATA_INITIAL_CAPACITY = round_up(1024, DATA_SIZE_ALIGNMENT);
 const DATA_GROWTH_STEP = 1024;
 const DATA_GROWTH_MULTIPLIER = 1.2;
 
-/**
- * Words of dead shape-arena space below which a re-pack is not worth running, however large the
- * fraction. A scene of a few small topologies churning would otherwise re-pack on every release.
- * @type {number}
- */
-const SHAPE_ARENA_COMPACT_FLOOR = 4096;
-
 /**
  * Regions the node arena's allocator can describe at once — live trees plus the free gaps
  * between them. A scene's live trees are one per geometry plus one per skinned instance.
@@ -154,68 +140,6 @@ export class GPUGeometryBVHManager {
      */
     #allocator;
 
-    /**
-     * Parent of every node, and the node index of every leaf, for each *distinct topology* — one
-     * arena each, addressed like {@link #buffer_data}.
-     *
-     * Separate from the nodes because they are separate things. Node bounds are per instance: a
-     * skinned clone's are its own, recomputed every frame from its own deformed vertices. Parents
-     * and leaf positions are the shape of the tree, and every copy of a geometry has the same
-     * shape, so one derivation serves all of them.
-     *
-     * @type {GPUBuffer}
-     */
-    #buffer_parents;
-
-    /**
-     * @returns {GPUBuffer}
-     */
-    get buffer_parents() {
-        return this.#buffer_parents;
-    }
-
-    /**
-     * @type {GPUBuffer}
-     */
-    #buffer_leaf_nodes;
-
-    /**
-     * @returns {GPUBuffer}
-     */
-    get buffer_leaf_nodes() {
-        return this.#buffer_leaf_nodes;
-    }
-
-    #buffer_parents_end = 0;
-    #buffer_leaf_nodes_end = 0;
-
-    /**
-     * How many words of each shape arena live topologies actually occupy.
-     *
-     * The arenas are bump pointers, and a released topology used to leave its words where they
-     * were — the same story the node arena was moved off a bump pointer to fix (MEEP-009), left
-     * behind in the two arenas beside it. Streaming distinct geometries therefore grew both
-     * buffers forever: a district-by-district tour of a converted map, where the whole set is
-     * hundreds of thousands of distinct geometries, grows them monotonically until `createBuffer`
-     * refuses.
-     *
-     * The difference between this and the end pointer is the waste, and
-     * {@link #compact_shape_arenas} closes it when it is worth closing.
-     *
-     * @type {number}
-     */
-    #buffer_parents_used = 0;
-
-    /** @type {number} */
-    #buffer_leaf_nodes_used = 0;
-
-    /**
-     * Topology by the geometry whose nodes it was derived from, shared by every copy of it.
-     *
-     * @type {Map<MeshletGeometry, {parents_offset: number, leaf_nodes_offset: number, leaf_count: number, node_count: number, resident: boolean, derived: {parents: Uint32Array, leaf_nodes: Uint32Array}}>}
-     */
-    #topology = new Map();
-
     /**
      *
      * @type {number}
@@ -224,7 +148,7 @@ export class GPUGeometryBVHManager {
 
     /**
      * Moves whenever the answer of {@link get_refit_target} may have changed for any owner: a tree's
-     * nodes uploaded, a shape uploaded, an owner removed. Registration alone does not move it —
+     * nodes uploaded, an owner removed. Registration alone does not move it —
      * nothing a refit can read has changed until {@link update} runs.
      *
      * A consumer that builds tables from those answers keeps them until this moves. Coarse on
@@ -278,37 +202,17 @@ export class GPUGeometryBVHManager {
             usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
         });
 
-        this.#buffer_parents = device.createBuffer({
-            label: "GPUGeometryBVHManager/parents",
-            size: DATA_INITIAL_CAPACITY,
-            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
-        });
-
-        this.#buffer_leaf_nodes = device.createBuffer({
-            label: "GPUGeometryBVHManager/leaf_nodes",
-            size: DATA_INITIAL_CAPACITY,
-            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
-        });
-
-        // Node 0 is the empty tree, reserved before anything is appended — see BLAS_EMPTY_TREE_ADDRESS.
-        const empty_tree = new Uint32Array(BVH2_NODE_STRUCT.size / Uint32Array.BYTES_PER_ELEMENT);
-
-        new Float32Array(empty_tree.buffer, BVH_NODE_BOUNDS_WORD * Uint32Array.BYTES_PER_ELEMENT, 6)
-            .set([Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity]);
-
-        empty_tree[BVH_NODE_CHILD_1_WORD] = BLAS_EMPTY_TREE_ADDRESS;
-        empty_tree[BVH_NODE_CHILD_2_WORD] = BLAS_EMPTY_TREE_ADDRESS;
-
-        device.queue.writeBuffer(this.#buffer_data, BLAS_EMPTY_TREE_ADDRESS * BVH2_NODE_STRUCT.size, empty_tree);
+        // Node 0 is the empty tree — see BLAS_EMPTY_TREE_ADDRESS. A buffer is created zeroed, and the
+        // region is taken out of circulation below before anything else can be put there.
 
         // Capacity is what the buffer actually holds, not what was asked for — `createBuffer`
         // rounds up, and an allocator sized below its arena just refuses allocations that fit.
-        this.#node_capacity = Math.floor(this.#buffer_data.size / BVH2_NODE_STRUCT.size);
+        this.#node_capacity = Math.floor(this.#buffer_data.size / BVH8_INODE_STRUCT.size);
 
         this.#allocator = new OffsetAllocator(this.#node_capacity, NODE_ALLOCATION_LIMIT);
 
-        // Take node 0 out of circulation permanently: it holds the empty tree written above, and
-        // a real tree handed that region would overwrite what every unresident geometry traces.
+        // Take node 0 out of circulation permanently: it is the empty tree, and a real tree handed
+        // that region would overwrite what every unresident geometry traces.
         const empty_tree_region = this.#allocator.allocate(1);
 
         assert.equal(
@@ -337,14 +241,6 @@ export class GPUGeometryBVHManager {
             r += this.#buffer_data.size;
         }
 
-        if (this.#buffer_parents) {
-            r += this.#buffer_parents.size;
-        }
-
-        if (this.#buffer_leaf_nodes) {
-            r += this.#buffer_leaf_nodes.size;
-        }
-
         return r;
     }
 
@@ -352,8 +248,8 @@ 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
@@ -361,22 +257,20 @@ export class GPUGeometryBVHManager {
     get gpu_memory_usage_occupied() {
         const free_nodes = this.#allocator.storageReport().totalFreeSpace;
 
-        return (this.#node_capacity - free_nodes) * BVH2_NODE_STRUCT.size;
+        return (this.#node_capacity - free_nodes) * BVH8_INODE_STRUCT.size;
     }
 
     /**
-     * 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, source) {
@@ -397,8 +291,7 @@ export class GPUGeometryBVHManager {
      *
      * `owner` is the identity the tree is looked up by and `source` is the geometry whose nodes it
      * holds. For an ordinary geometry those are the same object. For a per-instance copy they are
-     * not: the copy needs a node region of its own, because its bounds move independently, while
-     * the *shape* it is a copy of belongs to the source.
+     * not: the copy needs a node region of its own, because its boxes move independently.
      *
      * @param {object} owner
      * @param {MeshletGeometry} source
@@ -411,7 +304,7 @@ export class GPUGeometryBVHManager {
         // No bytes are taken now. The upload reads the geometry's tree as it is *then*, so a tree
         // that arrives after registration is uploaded once it exists rather than never — and a
         // geometry with none is not resident over nothing.
-        bvh.topology = this.#obtain_topology(source);
+        bvh.source = source;
 
         this.#map.set(owner, bvh);
 
@@ -420,69 +313,26 @@ export class GPUGeometryBVHManager {
         return bvh;
     }
 
-    /**
-     * The parents/leaf-nodes derivation for a geometry, made once and shared by every tree that is
-     * a copy of it.
-     *
-     * @param {MeshletGeometry} source
-     * @returns {object} the topology record
-     */
-    #obtain_topology(source) {
-        let topology = this.#topology.get(source);
-
-        if (topology !== undefined) {
-            return topology;
-        }
-
-        // Derivation waits for {@link #upload_pending_topology}, beside the residency decision it
-        // feeds. A geometry can be registered before its BLAS bytes exist — nothing has to have
-        // built one yet — and a record that says "not resident" is the honest answer for that,
-        // rather than an empty derivation cached forever.
-        topology = {
-            source,
-            leaf_count: 0,
-            node_count: 0,
-            parents_offset: 0,
-            leaf_nodes_offset: 0,
-            resident: false,
-        };
-
-        this.#topology.set(source, topology);
-
-        return topology;
-    }
-
     /**
      * 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) {
         const bvh = this.#map.get(owner);
 
-        if (bvh === undefined || bvh.released || !bvh.resident || !bvh.topology.resident) {
-            return undefined;
-        }
-
-        if (bvh.uploaded_byte_length !== bvh.topology.node_count * BVH2_NODE_STRUCT.size) {
-            // the nodes in the arena are not the tree the shape was derived from
+        if (bvh === undefined || bvh.released || !bvh.resident) {
             return undefined;
         }
 
         return {
-            node_word_offset: bvh.address * (BVH2_NODE_STRUCT.size / Uint32Array.BYTES_PER_ELEMENT),
-            node_count: bvh.topology.node_count,
-            leaf_count: bvh.topology.leaf_count,
-            parents_offset: bvh.topology.parents_offset,
-            leaf_nodes_offset: bvh.topology.leaf_nodes_offset,
+            node_offset: bvh.address,
+            node_count: bvh.uploaded_byte_length / BVH8_INODE_STRUCT.size,
         };
     }
 
@@ -555,134 +405,12 @@ export class GPUGeometryBVHManager {
 
         this.#map.delete(owner);
 
-        this.#release_topology_if_orphaned(bvh.topology);
-
         // a refit target that answered a moment ago answers `undefined` now
         this.#residency_version += 1;
 
         return true;
     }
 
-    /**
-     * Re-pack the shape arenas when enough of them is dead to be worth the pass.
-     *
-     * Half, over a floor that keeps a handful of small topologies from re-packing on every
-     * release. The re-pack is O(resident topologies) and the threshold makes it amortised: each
-     * one is paid for by at least as many words released as it moves.
-     */
-    #compact_shape_arenas_if_wasteful() {
-        const parents_waste = this.#buffer_parents_end - this.#buffer_parents_used;
-        const leaf_nodes_waste = this.#buffer_leaf_nodes_end - this.#buffer_leaf_nodes_used;
-
-        const wasteful = parents_waste > this.#buffer_parents_used
-            || leaf_nodes_waste > this.#buffer_leaf_nodes_used;
-
-        const worth_it = parents_waste + leaf_nodes_waste >= SHAPE_ARENA_COMPACT_FLOOR;
-
-        if (wasteful && worth_it) {
-            this.#compact_shape_arenas();
-        }
-    }
-
-    /**
-     * Re-pack both shape arenas so the live topologies sit at the front of them.
-     *
-     * A derivation is position-independent — it is copied into the arena verbatim and its address
-     * is recorded separately, and every consumer reaches it through {@link get_refit_target} —
-     * so a topology can be moved by writing it somewhere else and saying where. Nothing is read
-     * between the move and the republish that {@link #residency_version} asks for.
-     *
-     * Rebuilt from the source rather than read back: `bvh2_derive_topology` is a pure function of
-     * bytes the record already holds, and a readback would be a frame late.
-     *
-     * The buffers are not resized. Growing one destroys it, which an open encoder cannot survive,
-     * and this is reachable from {@link remove}; shrinking is not worth a copy of the whole arena
-     * when the space is about to be reused.
-     */
-    #compact_shape_arenas() {
-        const queue = this.#device.queue;
-
-        let parents_end = 0;
-        let leaf_nodes_end = 0;
-
-        for (const topology of this.#topology.values()) {
-            if (!topology.resident) {
-                continue;
-            }
-
-            const bytes = topology.source.bvh;
-
-            if (bytes === undefined || bytes.byteLength === 0) {
-                // the source lost its tree since; it is no longer resident in any useful sense
-                topology.resident = false;
-
-                continue;
-            }
-
-            const { parents, leaf_nodes } = bvh2_derive_topology(bytes);
-
-            topology.parents_offset = parents_end;
-            topology.leaf_nodes_offset = leaf_nodes_end;
-
-            queue.writeBuffer(
-                this.#buffer_parents,
-                parents_end * Uint32Array.BYTES_PER_ELEMENT,
-                parents, 0, parents.length
-            );
-
-            queue.writeBuffer(
-                this.#buffer_leaf_nodes,
-                leaf_nodes_end * Uint32Array.BYTES_PER_ELEMENT,
-                leaf_nodes, 0, leaf_nodes.length
-            );
-
-            parents_end += parents.length;
-            leaf_nodes_end += leaf_nodes.length;
-        }
-
-        this.#buffer_parents_end = parents_end;
-        this.#buffer_leaf_nodes_end = leaf_nodes_end;
-
-        this.#buffer_parents_used = parents_end;
-        this.#buffer_leaf_nodes_used = leaf_nodes_end;
-
-        // every offset just moved
-        this.#residency_version += 1;
-    }
-
-    /**
-     * Drop a shape once the last tree that had it is gone.
-     *
-     * The map entry holds a strong reference to the geometry it is keyed by, so leaving it would
-     * keep every geometry a scene ever loaded alive for as long as the manager is — and its words
-     * in the two shape arenas, which are bump pointers, are given back by re-packing rather than by
-     * a free list. See {@link #buffer_parents_used}.
-     *
-     * @param {object} topology
-     */
-    #release_topology_if_orphaned(topology) {
-        for (const bvh of this.#map.values()) {
-            if (bvh.topology === topology) {
-                return;
-            }
-        }
-
-        for (const [source, candidate] of this.#topology) {
-            if (candidate === topology) {
-                this.#topology.delete(source);
-
-                if (candidate.resident) {
-                    this.#buffer_parents_used -= candidate.node_count;
-                    this.#buffer_leaf_nodes_used -= candidate.leaf_count;
-
-                    this.#compact_shape_arenas_if_wasteful();
-                }
-
-                return;
-            }
-        }
-    }
-
     /**
      * Make the node arena hold at least `size` nodes, keeping {@link #allocator} the same size as
      * the buffer it describes.
@@ -703,7 +431,7 @@ export class GPUGeometryBVHManager {
         this.#buffer_data = ensure_buffer_capacity(
             this.#device,
             this.#buffer_data,
-            size * BVH2_NODE_STRUCT.size,
+            size * BVH8_INODE_STRUCT.size,
             DATA_SIZE_ALIGNMENT,
             DATA_GROWTH_STEP,
             DATA_GROWTH_MULTIPLIER
@@ -712,7 +440,7 @@ export class GPUGeometryBVHManager {
         // What the buffer actually came back as, not what was asked for: the helper grows by at
         // least a step and rounds up, and arena space the allocator does not know about is space
         // nothing can ever be put in.
-        this.#node_capacity = Math.floor(this.#buffer_data.size / BVH2_NODE_STRUCT.size);
+        this.#node_capacity = Math.floor(this.#buffer_data.size / BVH8_INODE_STRUCT.size);
 
         this.#allocator.grow(this.#node_capacity);
     }
@@ -770,96 +498,11 @@ export class GPUGeometryBVHManager {
     }
 
     /**
-     * Append every topology derived but not yet uploaded to its arena.
-     *
-     * Queue-free: the map is small (one entry per distinct geometry) and a `resident` flag says what
-     * is left to do, which is one fewer thing to keep in step than a second queue would be.
-     *
-     * @returns {boolean} whether any shape became resident
-     */
-    #upload_pending_topology() {
-        const queue = this.#device.queue;
-
-        let uploaded = false;
-
-        for (const topology of this.#topology.values()) {
-            if (topology.resident) {
-                continue;
-            }
-
-            const bytes = topology.source.bvh;
-
-            if (bytes === undefined || bytes.byteLength === 0) {
-                // no tree to take the shape of yet; try again next time
-                continue;
-            }
-
-            const { parents, leaf_nodes } = bvh2_derive_topology(bytes);
-
-            this.#buffer_parents = ensure_buffer_capacity(
-                this.#device,
-                this.#buffer_parents,
-                (this.#buffer_parents_end + parents.length) * Uint32Array.BYTES_PER_ELEMENT,
-                DATA_SIZE_ALIGNMENT,
-                DATA_GROWTH_STEP,
-                DATA_GROWTH_MULTIPLIER
-            );
-
-            this.#buffer_leaf_nodes = ensure_buffer_capacity(
-                this.#device,
-                this.#buffer_leaf_nodes,
-                (this.#buffer_leaf_nodes_end + leaf_nodes.length) * Uint32Array.BYTES_PER_ELEMENT,
-                DATA_SIZE_ALIGNMENT,
-                DATA_GROWTH_STEP,
-                DATA_GROWTH_MULTIPLIER
-            );
-
-            topology.parents_offset = this.#buffer_parents_end;
-            topology.leaf_nodes_offset = this.#buffer_leaf_nodes_end;
-
-            queue.writeBuffer(
-                this.#buffer_parents,
-                topology.parents_offset * Uint32Array.BYTES_PER_ELEMENT,
-                parents, 0, parents.length
-            );
-
-            queue.writeBuffer(
-                this.#buffer_leaf_nodes,
-                topology.leaf_nodes_offset * Uint32Array.BYTES_PER_ELEMENT,
-                leaf_nodes, 0, leaf_nodes.length
-            );
-
-            this.#buffer_parents_end += parents.length;
-            this.#buffer_leaf_nodes_end += leaf_nodes.length;
-
-            this.#buffer_parents_used += parents.length;
-            this.#buffer_leaf_nodes_used += leaf_nodes.length;
-
-            topology.leaf_count = leaf_nodes.length;
-            // slots, not tree nodes — the arena numbers a tree's nodes with the free list's holes
-            // in, and a refit's arrival counters are indexed by that numbering
-            topology.node_count = parents.length;
-            topology.resident = true;
-
-            uploaded = true;
-        }
-
-        return uploaded;
-    }
-
-    /**
-     * 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() {
-        const topology_uploaded = this.#upload_pending_topology();
-        const nodes_uploaded = this.#upload_pending_nodes();
-
-        if (topology_uploaded || nodes_uploaded) {
+        if (this.#upload_pending_nodes()) {
             this.#residency_version += 1;
         }
     }
@@ -891,7 +534,7 @@ export class GPUGeometryBVHManager {
                 has_work = true;
                 break;
             }
-            const bytes = record.topology.source.bvh;
+            const bytes = record.source.bvh;
             if (bytes !== undefined && bytes.byteLength > 0) {
                 has_work = true;
                 break;
@@ -918,7 +561,7 @@ export class GPUGeometryBVHManager {
 
             if (record.released) { continue; }
 
-            const bytes = record.topology.source.bvh;
+            const bytes = record.source.bvh;
 
             if (bytes === undefined || bytes.byteLength === 0) {
                 // no tree yet; try again next time
@@ -927,7 +570,7 @@ export class GPUGeometryBVHManager {
                 continue;
             }
 
-            const node_count = bytes.byteLength / BVH2_NODE_STRUCT.size;
+            const node_count = bytes.byteLength / BVH8_INODE_STRUCT.size;
 
             assert.isNonNegativeInteger(node_count, "node_count");
 
@@ -957,7 +600,7 @@ export class GPUGeometryBVHManager {
         // Every region first, while growing is still allowed to replace the buffer — see
         // #allocate_nodes. `used_node_count` is only the total; the regions need not be adjacent.
         for (const upload of uploads) {
-            upload.allocation = this.#allocate_nodes(upload.bytes.byteLength / BVH2_NODE_STRUCT.size);
+            upload.allocation = this.#allocate_nodes(upload.bytes.byteLength / BVH8_INODE_STRUCT.size);
         }
 
         const device = this.#device;
@@ -991,12 +634,12 @@ export class GPUGeometryBVHManager {
             record.address = allocation.offset;
             record.resident = true;
             record.bvh = bytes;
-            // what actually went into the arena, for `get_refit_target` to hold against the shape
+            // what actually went into the arena, which is what a refit of this record covers
             record.uploaded_byte_length = bytes.byteLength;
 
             encoder.copyBufferToBuffer(
                 temp_data_buffer, offset,
-                this.#buffer_data, allocation.offset * BVH2_NODE_STRUCT.size,
+                this.#buffer_data, allocation.offset * BVH8_INODE_STRUCT.size,
                 bytes.byteLength
             );
         }
@@ -1010,13 +653,11 @@ export class GPUGeometryBVHManager {
     }
 
     /**
-     * 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() {
         this.#buffer_metadata.destroy();
         this.#buffer_data.destroy();
-        this.#buffer_parents.destroy();
-        this.#buffer_leaf_nodes.destroy();
     }
 }

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

@@ -1,5 +1,6 @@
 /**
  * @typedef {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation} Allocation
+ * @typedef {import("../MeshletGeometry.js").MeshletGeometry} MeshletGeometry
  */
 export class GPUGeometryMeshletsBVH {
     /**
@@ -26,12 +27,11 @@ export class GPUGeometryMeshletsBVH {
      */
     allocation: Allocation | null;
     /**
-     * The shape of this tree — parents and leaf positions — shared with every other copy of the same
-     * geometry, because a copy differs only in where its bounds are.
+     * The geometry whose tree this one starts as a copy of.
      *
-     * @type {object}
+     * @type {MeshletGeometry}
      */
-    topology: object;
+    source: MeshletGeometry;
     /**
      * Whether {@link address} means anything yet. A record is registered before its nodes are
      * resident, and an address of 0 is a perfectly good arena position, so "not yet uploaded"
@@ -42,9 +42,7 @@ export class GPUGeometryMeshletsBVH {
     resident: boolean;
     /**
      * Bytes of {@link bvh} that {@link GPUGeometryBVHManager#update} actually copied into the arena
-     * at {@link address}. `get_refit_target` holds it against the shape's node count: a record
-     * registered before its geometry had a tree is uploaded as nothing, and a shape derived later,
-     * from the bytes that exist by then, must not be answered for at that empty region.
+     * at {@link address}: the region a refit of this tree covers.
      *
      * @type {number}
      */
@@ -58,4 +56,5 @@ export class GPUGeometryMeshletsBVH {
     released: boolean;
 }
 export type Allocation = import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation;
+export type MeshletGeometry = import("../MeshletGeometry.js").MeshletGeometry;
 //# sourceMappingURL=GPUGeometryMeshletsBVH.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometryMeshletsBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryMeshletsBVH.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;IAEI;;;;;;OAMG;IACH,KAFU,WAAW,GAAC,SAAS,CAE3B;IAEJ;;;;;OAKG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;;OAMG;IACH,YAFU,UAAU,GAAC,IAAI,CAEP;IAElB;;;;;OAKG;IACH,UAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;OAOG;IACH,sBAFU,MAAM,CAES;IAEzB;;;;;OAKG;IACH,UAFU,OAAO,CAEA;CACpB;yBAjEY,OAAO,sDAAsD,EAAE,UAAU"}
+{"version":3,"file":"GPUGeometryMeshletsBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryMeshletsBVH.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;IAEI;;;;;;OAMG;IACH,KAFU,WAAW,GAAC,SAAS,CAE3B;IAEJ;;;;;OAKG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;;OAMG;IACH,YAFU,UAAU,GAAC,IAAI,CAEP;IAElB;;;;OAIG;IACH,QAFU,eAAe,CAElB;IAEP;;;;;;OAMG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;OAKG;IACH,sBAFU,MAAM,CAES;IAEzB;;;;;OAKG;IACH,UAFU,OAAO,CAEA;CACpB;yBA/DY,OAAO,sDAAsD,EAAE,UAAU;8BACzE,OAAO,uBAAuB,EAAE,eAAe"}