@woosh/meep-engine 3.68.0 → 3.70.0

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

@@ -1,5 +1,6 @@
 /**
  * @typedef {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation} Allocation
+ * @typedef {import("../MeshletGeometry.js").MeshletGeometry} MeshletGeometry
  */
 
 export class GPUGeometryMeshletsBVH {
@@ -31,12 +32,11 @@ export class GPUGeometryMeshletsBVH {
     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;
+    source;
 
     /**
      * Whether {@link address} means anything yet. A record is registered before its nodes are
@@ -49,9 +49,7 @@ export class GPUGeometryMeshletsBVH {
 
     /**
      * 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}
      */

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

@@ -0,0 +1,36 @@
+/**
+ * Build a BVH8 over a meshlet batch that addresses the batch's own triangles, with no index table
+ * between the tree and the geometry.
+ *
+ * A BVH8 node names its triangles as one run: `base_index_triangle`, plus an offset of at most 23.
+ * A tree built over a mesh therefore wants the triangles in the tree's order, which is usually paid
+ * for with a second, re-ordered index buffer ({@link BVH8#primitives}). A meshlet already owns a
+ * private index list of at most {@link GEOMETRY_MESHLET_TRIANGLE_LIMIT} triangles whose order nothing
+ * else depends on, so the order is imposed there instead:
+ *
+ * - the tree is built so that every meshlet is one subtree, and every node at or below a meshlet's root
+ *   holds triangles of that meshlet alone ({@link meshlet_batch_to_clustered_bvh},
+ *   {@link BVH8Converter#cluster_roots});
+ * - each meshlet's triangles are then re-ordered into the order its nodes visit them
+ *   ({@link MeshletBatch#reorder_triangles}).
+ *
+ * `base_index_triangle` comes out as `(meshlet_index << 8) | triangle_index`, the id every ray query
+ * in the engine already resolves through `geometry_read_triangle_vertices`. A run never crosses a
+ * meshlet, so adding a slot's offset to it stays inside the low byte and the sum is again such an id.
+ * Nodes above the meshlet roots hold no triangles.
+ *
+ * Throws for a batch whose tree comes out deeper than {@link BVH8_BLAS_MAX_DEPTH}: the traversal's stack
+ * could not walk it. By then the triangles have been re-ordered and `bvh8` holds the refused tree.
+ *
+ * **This re-orders the triangles inside `meshlets`.** Any `(meshlet, triangle)` id recorded before the
+ * call is stale after it; build this before anything else that names triangles.
+ *
+ * @param {BVH8} bvh8 output; {@link BVH8#primitives} is left empty
+ * @param {MeshletBatch} meshlets triangles are re-ordered within each meshlet
+ * @param {Float32Array} bounding_box bounds of the whole batch
+ * @param {number} [optimization] treelet optimization passes over the binary tree the BVH8 is collapsed from
+ */
+export function bvh8_build_for_meshlets(bvh8: BVH8, meshlets: MeshletBatch, bounding_box: Float32Array, optimization?: number): void;
+export type BVH8 = import("../../../../core/bvh8/BVH8.js").BVH8;
+export type MeshletBatch = import("../meshlet/MeshletBatch.js").MeshletBatch;
+//# sourceMappingURL=bvh8_build_for_meshlets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_build_for_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/bvh8_build_for_meshlets.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,8CALW,IAAI,YACJ,YAAY,gBACZ,YAAY,iBACZ,MAAM,QAsHhB;mBAzKY,OAAO,+BAA+B,EAAE,IAAI;2BAC5C,OAAO,4BAA4B,EAAE,YAAY"}

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

@@ -0,0 +1,179 @@
+import { assert } from "../../../../core/assert.js";
+import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { BVH8Converter } from "../../../../core/bvh8/build/BVH8Converter.js";
+import { bvh8_depth } from "../../../../core/bvh8/bvh8_depth.js";
+import { BVH8_BLAS_MAX_DEPTH } from "../../shader/chunk/bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js";
+import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
+import { meshlet_batch_to_clustered_bvh } from "./meshlet_batch_to_clustered_bvh.js";
+
+/**
+ * @typedef {import("../../../../core/bvh8/BVH8.js").BVH8} BVH8
+ * @typedef {import("../meshlet/MeshletBatch.js").MeshletBatch} MeshletBatch
+ */
+
+/**
+ * Triangles in a batch, by its meshlets' own headers. A batch put together from stored buffers has
+ * no count of its own to give.
+ *
+ * @param {MeshletBatch} meshlets
+ * @returns {number}
+ */
+function count_triangles(meshlets) {
+    let count = 0;
+
+    for (let i = 0; i < meshlets.count; i++) {
+        count += meshlets.read_header(i).primitive_count;
+    }
+
+    return count;
+}
+
+/**
+ * Build a BVH8 over a meshlet batch that addresses the batch's own triangles, with no index table
+ * between the tree and the geometry.
+ *
+ * A BVH8 node names its triangles as one run: `base_index_triangle`, plus an offset of at most 23.
+ * A tree built over a mesh therefore wants the triangles in the tree's order, which is usually paid
+ * for with a second, re-ordered index buffer ({@link BVH8#primitives}). A meshlet already owns a
+ * private index list of at most {@link GEOMETRY_MESHLET_TRIANGLE_LIMIT} triangles whose order nothing
+ * else depends on, so the order is imposed there instead:
+ *
+ * - the tree is built so that every meshlet is one subtree, and every node at or below a meshlet's root
+ *   holds triangles of that meshlet alone ({@link meshlet_batch_to_clustered_bvh},
+ *   {@link BVH8Converter#cluster_roots});
+ * - each meshlet's triangles are then re-ordered into the order its nodes visit them
+ *   ({@link MeshletBatch#reorder_triangles}).
+ *
+ * `base_index_triangle` comes out as `(meshlet_index << 8) | triangle_index`, the id every ray query
+ * in the engine already resolves through `geometry_read_triangle_vertices`. A run never crosses a
+ * meshlet, so adding a slot's offset to it stays inside the low byte and the sum is again such an id.
+ * Nodes above the meshlet roots hold no triangles.
+ *
+ * Throws for a batch whose tree comes out deeper than {@link BVH8_BLAS_MAX_DEPTH}: the traversal's stack
+ * could not walk it. By then the triangles have been re-ordered and `bvh8` holds the refused tree.
+ *
+ * **This re-orders the triangles inside `meshlets`.** Any `(meshlet, triangle)` id recorded before the
+ * call is stale after it; build this before anything else that names triangles.
+ *
+ * @param {BVH8} bvh8 output; {@link BVH8#primitives} is left empty
+ * @param {MeshletBatch} meshlets triangles are re-ordered within each meshlet
+ * @param {Float32Array} bounding_box bounds of the whole batch
+ * @param {number} [optimization] treelet optimization passes over the binary tree the BVH8 is collapsed from
+ */
+export function bvh8_build_for_meshlets(bvh8, meshlets, bounding_box, optimization = 1) {
+    assert.defined(bvh8, 'bvh8');
+    assert.equal(meshlets.isMeshletBatch, true, 'meshlets.isMeshletBatch !== true');
+    assert.isArrayLike(bounding_box, 'bounding_box');
+
+    const meshlet_count = meshlets.count;
+
+    if (meshlet_count === 0) {
+        bvh8.clear();
+        return;
+    }
+
+    const bvh2 = new BVH();
+    const meshlet_roots = new Uint32Array(meshlet_count);
+
+    meshlet_batch_to_clustered_bvh({
+        bvh: bvh2,
+        meshlets,
+        bounding_box,
+        meshlet_roots,
+        optimization,
+    });
+
+    const cluster_roots = new Uint8Array(bvh2.size);
+
+    for (let i = 0; i < meshlet_count; i++) {
+        cluster_roots[meshlet_roots[i]] = 1;
+    }
+
+    const converter = new BVH8Converter(bvh8, bvh2);
+
+    converter.cluster_roots = cluster_roots;
+    converter.convert();
+
+    // ===========
+    // The pool now lists every triangle id in the order the nodes address them, one meshlet after
+    // another. Find where each meshlet's run starts
+    // ===========
+    const pool = bvh8.primitives.data_uint32;
+    const pool_size = bvh8.primitives.size;
+
+    assert.equal(pool_size, count_triangles(meshlets), 'the tree must hold every triangle of the batch');
+
+    const run_start = new Uint32Array(meshlet_count);
+
+    for (let i = 0, previous = -1; i < pool_size; i++) {
+        const meshlet_index = pool[i] >>> 8;
+
+        if (meshlet_index !== previous) {
+            run_start[meshlet_index] = i;
+            previous = meshlet_index;
+        }
+    }
+
+    // ===========
+    // Point every node at its run inside the meshlet, instead of inside the pool
+    // ===========
+    const node_count = bvh8.nodes.size;
+
+    for (let node = 0; node < node_count; node++) {
+        const imask = bvh8.node_get_imask(node);
+
+        let has_triangles = false;
+
+        for (let slot = 0; slot < 8; slot++) {
+            if ((imask & (1 << slot)) === 0 && bvh8.node_get_meta(node, slot) !== 0) {
+                has_triangles = true;
+                break;
+            }
+        }
+
+        if (!has_triangles) {
+            bvh8.node_set_base_index_triangle(node, 0);
+            continue;
+        }
+
+        const base = bvh8.node_get_base_index_triangle(node);
+
+        const meshlet_index = pool[base] >>> 8;
+
+        const base_in_meshlet = base - run_start[meshlet_index];
+
+        assert.lessThan(base_in_meshlet, GEOMETRY_MESHLET_TRIANGLE_LIMIT, 'run starts outside of its meshlet');
+
+        bvh8.node_set_base_index_triangle(node, ((meshlet_index << 8) | base_in_meshlet) >>> 0);
+    }
+
+    // ===========
+    // Put each meshlet's triangles in the order of its run
+    // ===========
+    const order = new Uint8Array(GEOMETRY_MESHLET_TRIANGLE_LIMIT);
+
+    for (let meshlet_index = 0; meshlet_index < meshlet_count; meshlet_index++) {
+        const triangle_count = meshlets.read_header(meshlet_index).primitive_count;
+
+        const start = run_start[meshlet_index];
+
+        for (let i = 0; i < triangle_count; i++) {
+            const id = pool[start + i];
+
+            assert.equal(id >>> 8, meshlet_index, "a meshlet's run holds another meshlet's triangle");
+
+            order[i] = id & 0xFF;
+        }
+
+        meshlets.reorder_triangles(meshlet_index, order);
+    }
+
+    // the order lives in the meshlets now
+    bvh8.primitives.clear();
+
+    const depth = bvh8_depth(bvh8);
+
+    if (depth > BVH8_BLAS_MAX_DEPTH) {
+        throw new Error(`BVH8 over ${count_triangles(meshlets)} triangles in ${meshlet_count} meshlets is ${depth} levels deep, the traversal holds ${BVH8_BLAS_MAX_DEPTH}`);
+    }
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Binary BVH over the triangles of a meshlet batch, in which every meshlet is one subtree.
+ *
+ * Treelets are optimized on either side of the meshlet roots and never across them, where an
+ * optimization of the whole tree would be free to trade triangles between meshlets: the tree above
+ * the roots sees each meshlet as a leaf, and the tree below one holds that meshlet's triangles and
+ * no others. That is the property a
+ * wide BVH needs in order to address triangles as a run inside a meshlet, see
+ * {@link bvh8_build_for_meshlets}.
+ *
+ * A leaf's user data is `(meshlet_index << 8) | triangle_index`, as everywhere else.
+ *
+ * @param {Object} options
+ * @param {BVH} options.bvh output, anything it held is released
+ * @param {MeshletBatch} options.meshlets every meshlet must hold at least one triangle
+ * @param {Float32Array} options.bounding_box bounds of the whole batch
+ * @param {Uint32Array} options.meshlet_roots output, the node each meshlet is rooted at, by meshlet
+ * index. A meshlet of one triangle is rooted at that triangle's leaf.
+ * @param {number} [options.optimization] treelet optimization passes
+ */
+export function meshlet_batch_to_clustered_bvh({ bvh, meshlets, bounding_box, meshlet_roots, optimization }: {
+    bvh: BVH;
+    meshlets: MeshletBatch;
+    bounding_box: Float32Array;
+    meshlet_roots: Uint32Array;
+    optimization?: number;
+}): void;
+export type BVH = import("../../../../core/bvh2/bvh3/BVH.js").BVH;
+export type MeshletBatch = import("../meshlet/MeshletBatch.js").MeshletBatch;
+//# sourceMappingURL=meshlet_batch_to_clustered_bvh.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"meshlet_batch_to_clustered_bvh.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/meshlet_batch_to_clustered_bvh.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAPwB,GAAG,EAAhB,GAAG;IACmB,QAAQ,EAA9B,YAAY;IACU,YAAY,EAAlC,YAAY;IACS,aAAa,EAAlC,WAAW;IAEM,YAAY,GAA7B,MAAM;SA8IhB;kBAlMY,OAAO,mCAAmC,EAAE,GAAG;2BAC/C,OAAO,4BAA4B,EAAE,YAAY"}

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

@@ -0,0 +1,207 @@
+import { assert } from "../../../../core/assert.js";
+import { NULL_NODE } from "../../../../core/bvh2/bvh3/BVH.js";
+import { ebvh_build_hierarchy } from "../../../../core/bvh2/bvh3/ebvh_build_hierarchy.js";
+import { ebvh_optimize_treelet } from "../../../../core/bvh2/bvh3/ebvh_optimize_treelet.js";
+import {
+    array_quick_sort_by_lookup_uint
+} from "../../../../core/collection/array/array_quick_sort_by_lookup_uint.js";
+import { v3_morton_encode_bounded } from "../../../../core/geom/3d/morton/v3_morton_encode_bounded.js";
+import { aabb3_compute_from_triangle } from "../../../../core/geom/3d/triangle/aabb3_compute_from_triangle.js";
+import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
+
+/**
+ * @typedef {import("../../../../core/bvh2/bvh3/BVH.js").BVH} BVH
+ * @typedef {import("../meshlet/MeshletBatch.js").MeshletBatch} MeshletBatch
+ */
+
+/**
+ * Arrange `count` unattached nodes into a hierarchy, nearest in Morton order first.
+ *
+ * @param {BVH} bvh
+ * @param {Uint32Array} nodes the nodes to arrange; left in an unspecified order
+ * @param {Uint32Array} codes Morton code of each of `nodes`, by position
+ * @param {number} count
+ * @param {Uint32Array} scratch_order at least `count` long
+ * @param {Uint32Array} scratch_nodes at least `2 * count` long
+ * @returns {number} root of the hierarchy; `nodes[0]` itself when `count` is 1
+ */
+function build_hierarchy_by_morton(bvh, nodes, codes, count, scratch_order, scratch_nodes) {
+    for (let i = 0; i < count; i++) {
+        scratch_order[i] = i;
+    }
+
+    array_quick_sort_by_lookup_uint(scratch_order, codes, 0, count - 1);
+
+    for (let i = 0; i < count; i++) {
+        scratch_nodes[i] = nodes[scratch_order[i]];
+    }
+
+    // a binary tree over `count` leaves has `count - 1` parents
+    for (let i = 0; i < count - 1; i++) {
+        scratch_nodes[count + i] = bvh.allocate_node();
+    }
+
+    return ebvh_build_hierarchy(bvh, scratch_nodes, count, scratch_nodes, count);
+}
+
+/**
+ * Binary BVH over the triangles of a meshlet batch, in which every meshlet is one subtree.
+ *
+ * Treelets are optimized on either side of the meshlet roots and never across them, where an
+ * optimization of the whole tree would be free to trade triangles between meshlets: the tree above
+ * the roots sees each meshlet as a leaf, and the tree below one holds that meshlet's triangles and
+ * no others. That is the property a
+ * wide BVH needs in order to address triangles as a run inside a meshlet, see
+ * {@link bvh8_build_for_meshlets}.
+ *
+ * A leaf's user data is `(meshlet_index << 8) | triangle_index`, as everywhere else.
+ *
+ * @param {Object} options
+ * @param {BVH} options.bvh output, anything it held is released
+ * @param {MeshletBatch} options.meshlets every meshlet must hold at least one triangle
+ * @param {Float32Array} options.bounding_box bounds of the whole batch
+ * @param {Uint32Array} options.meshlet_roots output, the node each meshlet is rooted at, by meshlet
+ * index. A meshlet of one triangle is rooted at that triangle's leaf.
+ * @param {number} [options.optimization] treelet optimization passes
+ */
+export function meshlet_batch_to_clustered_bvh({
+                                                   bvh,
+                                                   meshlets,
+                                                   bounding_box,
+                                                   meshlet_roots,
+                                                   optimization = 1
+                                               }) {
+
+    assert.defined(bvh, 'bvh');
+    assert.defined(meshlets, 'meshlets');
+    assert.defined(bounding_box, 'bounding_box');
+
+    const meshlet_count = meshlets.count;
+
+    assert.greaterThanOrEqual(meshlet_roots.length, meshlet_count, 'meshlet_roots is too short');
+
+    bvh.release_all();
+
+    if (meshlet_count === 0) {
+        bvh.root = NULL_NODE;
+        return;
+    }
+
+    const scratch_size = Math.max(meshlet_count, GEOMETRY_MESHLET_TRIANGLE_LIMIT);
+
+    const scratch_codes = new Uint32Array(scratch_size);
+    const scratch_order = new Uint32Array(scratch_size);
+    const scratch_nodes = new Uint32Array(scratch_size * 2);
+
+    // ===========
+    // The tree over the meshlets, each one a leaf for now
+    // ===========
+    for (let i = 0; i < meshlet_count; i++) {
+        const header = meshlets.read_header(i);
+
+        assert.greaterThan(header.primitive_count, 0, 'meshlet holds no triangles');
+
+        const bb = header.bounds_box;
+
+        const node = bvh.allocate_node();
+
+        bvh.node_set_aabb(node, bb);
+
+        meshlet_roots[i] = node;
+
+        scratch_codes[i] = v3_morton_encode_bounded(
+            (bb[0] + bb[3]) * 0.5,
+            (bb[1] + bb[4]) * 0.5,
+            (bb[2] + bb[5]) * 0.5,
+            bounding_box,
+        );
+    }
+
+    const root = build_hierarchy_by_morton(bvh, meshlet_roots, scratch_codes, meshlet_count, scratch_order, scratch_nodes);
+
+    bvh.root = root;
+
+    for (let i = 0; i < optimization; i++) {
+        ebvh_optimize_treelet(bvh, root);
+    }
+
+    // ===========
+    // The tree inside each meshlet, grown under its leaf
+    // ===========
+    const triangle_nodes = new Uint32Array(GEOMETRY_MESHLET_TRIANGLE_LIMIT);
+    const triangle_aabb = new Float32Array(6);
+
+    for (let meshlet_index = 0; meshlet_index < meshlet_count; meshlet_index++) {
+        const meshlet = meshlets.read_meshlet(meshlet_index);
+
+        const meshlet_bounds = meshlet.header.bounds_box;
+
+        // NOTE: indices and vertices are per-meshlet, there are no global attributes
+        const meshlet_indices = meshlet.attribute_index;
+        const meshlet_positions = meshlet.attribute_position;
+
+        const triangle_count = meshlet.header.primitive_count;
+
+        const meshlet_root = meshlet_roots[meshlet_index];
+
+        for (let triangle_index = 0; triangle_index < triangle_count; triangle_index++) {
+            const index3 = triangle_index * 3;
+
+            aabb3_compute_from_triangle(
+                triangle_aabb, 0,
+                meshlet_positions,
+                meshlet_indices[index3],
+                meshlet_indices[index3 + 1],
+                meshlet_indices[index3 + 2],
+            );
+
+            // the leaf of a one-triangle meshlet is the meshlet's own node
+            const node = triangle_count === 1 ? meshlet_root : bvh.allocate_node();
+
+            bvh.node_set_aabb(node, triangle_aabb);
+
+            // NOTE: we already limit the number of triangles per meshlet to 256, so this is safe.
+            bvh.node_set_user_data(node, (((meshlet_index & 0x00FFFFFF) << 8) | (triangle_index & 0xFF)) >>> 0);
+
+            triangle_nodes[triangle_index] = node;
+
+            scratch_codes[triangle_index] = v3_morton_encode_bounded(
+                (triangle_aabb[0] + triangle_aabb[3]) * 0.5,
+                (triangle_aabb[1] + triangle_aabb[4]) * 0.5,
+                (triangle_aabb[2] + triangle_aabb[5]) * 0.5,
+                meshlet_bounds,
+            );
+        }
+
+        if (triangle_count === 1) {
+            continue;
+        }
+
+        const subtree = build_hierarchy_by_morton(bvh, triangle_nodes, scratch_codes, triangle_count, scratch_order, scratch_nodes);
+
+        // the meshlet's node is already wired into the tree above, so it takes over as the root
+        bvh.node_assign_children(meshlet_root, bvh.node_get_child1(subtree), bvh.node_get_child2(subtree));
+        bvh.release_node(subtree);
+
+        for (let i = 0; i < optimization; i++) {
+            ebvh_optimize_treelet(bvh, meshlet_root);
+        }
+    }
+
+    // ===========
+    // The tree above was measured with every meshlet a leaf; bring it up to date
+    // ===========
+    for (let meshlet_index = 0; meshlet_index < meshlet_count; meshlet_index++) {
+        let node = bvh.node_get_parent(meshlet_roots[meshlet_index]);
+
+        while (node !== NULL_NODE) {
+            const child_1 = bvh.node_get_child1(node);
+            const child_2 = bvh.node_get_child2(node);
+
+            bvh.node_set_combined_aabb(node, child_1, child_2);
+            bvh.node_set_height(node, 1 + Math.max(bvh.node_get_height(child_1), bvh.node_get_height(child_2)));
+
+            node = bvh.node_get_parent(node);
+        }
+    }
+}

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

@@ -0,0 +1,52 @@
+/**
+ * Nodes per workgroup. A workgroup serves one tree and one aligned run of this many of its nodes,
+ * which is what the lookup's second word counts in.
+ *
+ * @type {number}
+ */
+export const BLAS8_REFIT_BATCH_WORKGROUP_SIZE: number;
+/**
+ * `u32` words of spine a node takes: its box's six floats, 24 bits to a word, under a flag.
+ *
+ * @type {number}
+ */
+export const BLAS8_REFIT_SPINE_STRIDE_WORDS: number;
+/**
+ * Refit every BVH8 in a batch, from one dispatch.
+ *
+ * One lane per node, across every tree the batch lists. A node holds its slots' boxes on a grid of
+ * its own box, so a lane has two things to find: the box of everything under each of its slots, and
+ * from their union its own. A slot of triangles is read off the vertex buffer as it stands *now*. A
+ * slot that is a child node depends on that child's lane — as a tile of a prefix scan depends on the
+ * tiles before it, and this takes the scan's shape (`graph_prefix_scan_csdldf`):
+ *
+ * - **Published under a flag.** A lane leaves its node's box in the `spine`, box and flag in the same
+ *   atomic words, as soon as it has it. A reader has the whole box or none of it.
+ * - **Looked for, not waited for.** A lane looks for its children's boxes a fixed number of rounds,
+ *   and publishes the moment the last turns up. What has not turned up by then the lane finds out
+ *   for itself, from the triangles under that child, taking as it stands the box of any node on the
+ *   way down that has published. Nothing spins on another lane,
+ *   and nothing depends on when a store reaches whom.
+ * - **Never in place.** Everything a lane reads to find a box out — the vertices, and the four words
+ *   of a node that say what it holds — no lane writes. Everything a lane writes, no lane reads.
+ * - **In the order of the dependency.** Lanes take a tree's nodes last to first, and a child's index
+ *   is above its parent's, so a device that starts workgroups in order runs the children first. Within
+ *   a lane the order is the same: its own triangles, its box published if that is all there is to it,
+ *   and only then a look at its children. A device that keeps neither order is slower and no less
+ *   right.
+ *
+ * So there are no counters, no parents, no seeding pass and nothing to repair: a zeroed spine, then
+ * this, whatever the trees' depth.
+ *
+ * Boxes are rounded outward at every step that rounds, so a refitted node holds what is under it
+ * exactly as a built one does; it is not the same node the builder would write, whose arithmetic is
+ * exact where this is `f32`.
+ *
+ * For a skinned mesh this runs against the per-instance clone, after the skinning pass has deformed
+ * its vertex region; `geometry_index` on the row is the clone's.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_blas8_refit_batch: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_blas8_refit_batch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_blas8_refit_batch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/shader_blas8_refit_batch.js"],"names":[],"mappings":"AAiBA;;;;;GAKG;AACH,+CAFU,MAAM,CAEmC;AAEnD;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAyYhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,uCAFU,aAAa,CAMpB;8BA9c2B,+BAA+B"}