@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/playground/skinned_blas_refit/verify_skinned_blas_refit.js

@@ -1,22 +1,15 @@
-import { GEOMETRY_METADATA_STRUCT } from "../../renderer/geometry/GEOMETRY_METADATA_STRUCT.js";
 import { align_4 } from "../../../core/binary/align_4.js";
-import {
-    BVH_NODE_BOUNDS_WORD,
-    BVH_NODE_CHILD_1_WORD,
-    BVH_NODE_CHILD_2_WORD,
-    BVH_NODE_STRIDE_WORDS
-} from "../../renderer/gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js";
-import { bvh2_check_containment } from "../../renderer/geometry/bvh/bvh2_check_bounds.js";
-import { GPUBLASRefitBatch } from "../../renderer/geometry/bvh/GPUBLASRefitBatch.js";
-import { BVH2_NODE_STRUCT } from "../../renderer/shader/chunk/bvh/BVH2_NODE_STRUCT.js";
+import { reinterpret_uint32_as_float32 } from "../../../core/binary/reinterpret_uint32_as_float32.js";
+import { BVH8 } from "../../../core/bvh8/BVH8.js";
+import { bvh8_get_node_bounds } from "../../../core/bvh8/bvh8_get_node_bounds.js";
+import { bvh8_validate_structure } from "../../../core/bvh8/bvh8_validate_structure.js";
 import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import { GPUBLASRefitBatch } from "../../renderer/geometry/bvh/GPUBLASRefitBatch.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../renderer/geometry/GEOMETRY_METADATA_STRUCT.js";
+import { BVH8_INODE_STRUCT } from "../../renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_INODE_STRUCT.js";
 import { render_submitted_frames } from "../render_submitted_frames.js";
 import { geometry_of } from "./place_character.js";
-
-/**
- * @type {number}
- */
-const BVH_NULL_NODE = 0xffffffff;
+import { verify_leaf_triangles } from "./verify_leaf_triangles.js";
 
 /**
  * Device-level check for the per-frame BLAS refit, for when looking at the picture is not enough or
@@ -29,11 +22,13 @@ const BVH_NULL_NODE = 0xffffffff;
  *   - `shader_meshlet_bounds_reduce` atomically merges every deformed vertex into the clone's
  *     geometry-metadata bounding box. It exists for the rasterizer's culling and knows nothing
  *     about trees.
- *   - {@link GPUBLASRefitBatch} takes each leaf triangle's box and climbs the tree. The root node
- *     ends up bounding every triangle.
+ *   - {@link GPUBLASRefitBatch} fits every node of the tree to the triangles under it. The boxes of
+ *     the root's slots, together, end up bounding every triangle.
  *
  * Same vertices, same frame, two paths that share no code. They have to agree, and a stale BLAS
- * cannot make them: the metadata box tracks the pose while the root node holds the bind pose.
+ * cannot make them: the metadata box tracks the pose while the root holds the bind pose. Agreement
+ * here is the root's box holding the metadata box and reaching no more than a step of the root's own
+ * grid past it: a node keeps its slots' boxes on a grid of 255 steps across itself, rounded outward.
  *
  * Both are read straight out of the buffers the shaders wrote, so this needs a real device — call
  * it from the playground page's console, not from a spec.
@@ -78,17 +73,79 @@ async function read_back(device, buffer, offset, size) {
 }
 
 /**
- * `[min.xyz, max.xyz]` of the tree's root node, as the refit left it.
+ * A tree's nodes as the refit left them.
  *
  * @param {GPUDevice} device
  * @param {GPUGeometryBVHManager} blas
  * @param {number} address arena node index of the tree's root
- * @returns {Promise<number[]>}
+ * @param {number} node_count
+ * @returns {Promise<BVH8>}
  */
-async function read_root_bounds(device, blas, address) {
-    const bytes = await read_back(device, blas.buffer_data, address * BVH2_NODE_STRUCT.size, 24);
+async function read_tree(device, blas, address, node_count) {
+    const tree = new BVH8();
 
-    return [...new Float32Array(bytes)];
+    tree.nodes.fromArrayBuffer(
+        await read_back(device, blas.buffer_data, address * BVH8_INODE_STRUCT.size, node_count * BVH8_INODE_STRUCT.size),
+        node_count
+    );
+
+    return tree;
+}
+
+/**
+ * `[min.xyz, max.xyz]` of everything a node's slots hold.
+ *
+ * @param {BVH8} tree
+ * @param {number} node
+ * @returns {number[]}
+ */
+function node_bounds(tree, node) {
+    const box = new Float32Array(6);
+
+    bvh8_get_node_bounds(box, 0, tree, node);
+
+    return [...box];
+}
+
+/**
+ * The steps of the grid a node keeps its slots' boxes on, an axis each: a power of two, the node's
+ * own to choose.
+ *
+ * @param {BVH8} tree
+ * @param {number} node
+ * @returns {number[]}
+ */
+function node_steps(tree, node) {
+    const exponents = new Uint8Array(3);
+
+    tree.node_get_e(node, exponents);
+
+    return Array.from(exponents, e => reinterpret_uint32_as_float32(e << 23));
+}
+
+/**
+ * How far `outer` fails to hold `inner`, and how far it reaches past it, both in `steps` an axis.
+ * A fitted root holds what is under it (zero short) and reaches less than a step past it: its slots'
+ * boxes are rounded outward to its grid.
+ *
+ * @param {number[]} outer
+ * @param {number[]} inner
+ * @param {number[]} steps
+ * @returns {{short: number, past: number}}
+ */
+function box_fit(outer, inner, steps) {
+    let short = 0;
+    let past = 0;
+
+    for (let axis = 0; axis < 3; axis++) {
+        const low = (inner[axis] - outer[axis]) / steps[axis];
+        const high = (outer[axis + 3] - inner[axis + 3]) / steps[axis];
+
+        short = Math.max(short, -low, -high);
+        past = Math.max(past, low, high);
+    }
+
+    return { short, past };
 }
 
 /**
@@ -165,7 +222,8 @@ async function advance(renderer, camera, scene, frames, dt = 1 / 60) {
  * @param {PerspectiveCamera} options.camera
  * @param {Scene} options.scene
  * @param {number} options.entity a skinned mesh entity, whose clone is being deformed
- * @param {number} [options.tolerance] relative box disagreement to accept
+ * @param {number} [options.tolerance] slack on the fit, in steps of the root's grid, and the relative
+ * movement between the samples below which the pose is taken not to have moved
  * @returns {Promise<object>} the samples and the verdict
  */
 export async function verify_skinned_blas_refit({
@@ -197,8 +255,12 @@ export async function verify_skinned_blas_refit({
         await read_back(device, geometries.blas.buffer_metadata, geometry_index * 4, 4)
     )[0];
 
+    const node_count = geometry_of(scene.dataset, entity).bvh.byteLength / BVH8_INODE_STRUCT.size;
+
     const samples = [];
 
+    let tree;
+
     for (let i = 0; i < 2; i++) {
         // a third of a second between samples — far enough into the dance that a limb has moved,
         // close enough that the whole check is quick
@@ -206,25 +268,40 @@ export async function verify_skinned_blas_refit({
             await advance(renderer, camera, scene, 20);
         }
 
-        const root = await read_root_bounds(device, geometries.blas, address);
+        tree = await read_tree(device, geometries.blas, address, node_count);
+
+        const root = node_bounds(tree, 0);
         const metadata = await read_metadata_bounds(device, geometries, geometry_index);
 
-        samples.push({ root, metadata, disagreement: box_disagreement(metadata, root) });
+        samples.push({ root, metadata, fit: box_fit(root, metadata, node_steps(tree, 0)) });
     }
 
-    // and the interior, which the root box alone says nothing about
-    const region = await read_back(
-        device,
-        geometries.blas.buffer_data,
-        address * BVH2_NODE_STRUCT.size,
-        (geometry_of(scene.dataset, entity).bvh.byteLength / BVH2_NODE_STRUCT.size | 0) * BVH2_NODE_STRUCT.size
-    );
+    // and the interior, which the root's box alone says nothing about
+    let structure = null;
 
-    // the same checker the spec asserts with, so the browser tier and CI ask one question
-    const union_check = bvh2_check_containment(region);
+    try {
+        // the same checker the builder's specs assert with
+        bvh8_validate_structure(tree);
+    } catch (error) {
+        structure = error.message;
+    }
+
+    // Every slot against the triangles under it, as the vertices stand now: no frame has run since
+    // the tree was read, so there is no slack to allow for.
+    const interior = await verify_leaf_triangles({
+        renderer,
+        target: { node_offset: address, node_count },
+        geometry_index,
+        meshlet_count: geometry_of(scene.dataset, entity).meshlets.count,
+    });
 
-    const agrees = samples.every(sample => sample.disagreement <= tolerance)
-        && union_check.problems.length === 0;
+    const interior_problem = structure !== null ? structure
+        : interior.verdict.startsWith('pass') ? null
+            : interior.verdict;
+
+    // a step, and the rounding of reading a box back out of the grid
+    const agrees = samples.every(sample => sample.fit.short <= tolerance && sample.fit.past <= 1 + tolerance)
+        && interior_problem === null;
 
     // the pose has to have moved for the agreement above to mean anything
     const moved = box_disagreement(samples[0].root, samples[1].root);
@@ -233,18 +310,18 @@ export async function verify_skinned_blas_refit({
         geometry_index,
         address,
         samples,
-        union_check,
+        interior,
         agrees,
         moved,
         // a box that never moves is a box that is not being recomputed, however well it agrees
         verdict: agrees && moved > tolerance
             ? `pass — the tree bounds the deformed mesh and follows it; `
-            + `${union_check.internal} internal nodes are exactly their children's union`
+            + `${interior.triangle_count} triangles and ${interior.child_slots} child nodes sit inside the slots that name them`
             : agrees
                 ? `inconclusive — the boxes agree but neither moved (${moved.toExponential(2)}); is the animation playing?`
-                : union_check.problems.length > 0
-                    ? `FAIL — the interior does not hold together: ${union_check.problems[0]}`
-                    : `FAIL — the tree does not bound the deformed mesh (${samples.map(s => s.disagreement.toExponential(2)).join(', ')})`,
+                : interior_problem !== null
+                    ? `FAIL — the interior does not hold together: ${interior_problem}`
+                    : `FAIL — the tree does not bound the deformed mesh (short ${samples.map(s => s.fit.short.toFixed(3)).join(', ')} steps, past ${samples.map(s => s.fit.past.toFixed(3)).join(', ')})`,
     };
 
     console.log(result.verdict, result);
@@ -253,21 +330,19 @@ export async function verify_skinned_blas_refit({
 }
 
 /**
- * Does each leaf's box belong to the triangle that leaf names?
+ * Does each leaf slot's box belong to the triangles that slot names?
  *
  * The check above cannot see this, and it is worth being explicit about why. Its two properties —
- * root box equals the metadata box, every internal node equals its children's union — are both
- * invariant under *any* permutation of triangles among leaves. Deal the same set of triangle boxes
- * out to the wrong leaves and the union of all of them is unchanged, so the root still matches, and
- * the climb still computes each node from whatever its children hold. A tree that fits every
- * triangle to the wrong leaf passes both and traces garbage: a ray descends into a box, tests the
- * triangle the leaf names, and that triangle is somewhere else entirely.
+ * the root holds the metadata box, every slot holds the child node it names — are both invariant
+ * under *any* permutation of triangles among leaf slots. Deal the same triangles out to the wrong
+ * slots and the union of all of them is unchanged, so the root still matches, and each node is still
+ * fitted to whatever its children hold. A tree that fits every triangle to the wrong slot passes both
+ * and traces garbage: a ray descends into a box, tests the triangles the slot names, and those
+ * triangles are somewhere else entirely.
  *
- * The way to see it is to refit a geometry that is **not** deforming, and hold the result against
- * the tree it was copied from. The CPU builder put each leaf's box there with the correspondence
- * that is correct by construction; the refit recomputes those boxes from the vertex buffer. Nothing
- * moved in between, so the two have to be the same bytes — and a permutation is exactly what stops
- * them being.
+ * The way to see it is to refit a geometry that is **not** deforming, and hold every slot against the
+ * triangles the intersector fetches for it. Nothing moved, so there is no frame of slack to hide
+ * behind: every triangle sits inside the slot that names it or the refit read another one.
  *
  * @param {object} options
  * @param {Renderer} options.renderer
@@ -286,15 +361,10 @@ export async function verify_leaf_correspondence({ renderer, geometry }) {
         throw new Error('that geometry is not registered');
     }
 
-    const target = geometries.blas.get_refit_target(metadata);
-
-    if (target === undefined) {
+    if (geometries.blas.get_refit_target(metadata) === undefined) {
         throw new Error('that geometry has no resident tree');
     }
 
-    const expected = new Float32Array(geometry.bvh);
-    const expected_words = new Uint32Array(geometry.bvh);
-
     const cmd = ShadeGPUCommandContext.create(graphics, 'verify/leaf correspondence');
 
     // a batch of one: the source geometry, refitted from its own undeformed vertices
@@ -310,60 +380,10 @@ export async function verify_leaf_correspondence({ renderer, geometry }) {
 
     batch.destroy();
 
-    const region = new Float32Array(await read_back(
-        device,
-        geometries.blas.buffer_data,
-        target.node_word_offset * Uint32Array.BYTES_PER_ELEMENT,
-        geometry.bvh.byteLength
-    ));
-
-    const node_count = Math.floor(expected.length / BVH_NODE_STRIDE_WORDS);
-
-    const problems = [];
-
-    let leaves = 0;
-    let worst = 0;
-
-    for (let node = 0; node < node_count && problems.length < 8; node++) {
-        const base = node * BVH_NODE_STRIDE_WORDS;
-
-        // only the leaves: an internal node's box comes from the climb, which the union check
-        // already covers, and slots the tree never reaches hold whatever the free list left
-        if (expected_words[base + BVH_NODE_CHILD_1_WORD] !== BVH_NULL_NODE) {
-            continue;
-        }
-
-        leaves += 1;
-
-        for (let i = 0; i < 6; i++) {
-            const want = expected[base + BVH_NODE_BOUNDS_WORD + i];
-            const got = region[base + BVH_NODE_BOUNDS_WORD + i];
-
-            const error = Math.abs(want - got);
-
-            if (error > worst) {
-                worst = error;
-            }
-
-            if (want !== got) {
-                problems.push(
-                    `leaf node ${node} bound ${i}: builder says ${want}, refit says ${got}`
-                );
-            }
-        }
-    }
-
-    const result = {
-        leaves,
-        worst,
-        problems,
-        verdict: problems.length === 0
-            ? `pass — all ${leaves} leaf boxes are the ones the builder put there, so each leaf's `
-            + `box is its own triangle's`
-            : `FAIL — ${problems.length}+ leaf boxes differ from the builder's: ${problems[0]}`,
-    };
-
-    console.log(result.verdict, result);
-
-    return result;
+    return verify_leaf_triangles({
+        renderer,
+        owner: metadata,
+        geometry_index: metadata.index,
+        meshlet_count: geometry.meshlets.count,
+    });
 }

package/src/shade/playground/skinned_blas_refit/verify_traversal_reachability.d.ts

@@ -3,15 +3,15 @@
  * @param {Renderer} options.renderer
  * @param {PerspectiveCamera} options.camera whose position the rays start from
  * @param {Transform64} options.world the instance's world transform, which puts the camera into geometry space
- * @param {object} options.target refit target of the tree to audit
- * @param {number} options.geometry_index
+ * @param {number} options.geometry_index the row whose tree is walked and whose triangles are aimed at
+ * @param {number} options.meshlet_count meshlets of that geometry
  * @returns {Promise<object>}
  */
-export function verify_traversal_reachability({ renderer, camera, world, target, geometry_index, }: {
+export function verify_traversal_reachability({ renderer, camera, world, geometry_index, meshlet_count, }: {
     renderer: Renderer;
     camera: PerspectiveCamera;
     world: Transform64;
-    target: object;
     geometry_index: number;
+    meshlet_count: number;
 }): Promise<object>;
 //# sourceMappingURL=verify_traversal_reachability.d.ts.map

package/src/shade/playground/skinned_blas_refit/verify_traversal_reachability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify_traversal_reachability.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/verify_traversal_reachability.js"],"names":[],"mappings":"AAoHA;;;;;;;;GAQG;AACH;IAP6B,QAAQ;IACC,MAAM;IACZ,KAAK;IACV,MAAM,EAAtB,MAAM;IACU,cAAc,EAA9B,MAAM;IACJ,QAAQ,MAAM,CAAC,CA6H3B"}
+{"version":3,"file":"verify_traversal_reachability.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/verify_traversal_reachability.js"],"names":[],"mappings":"AAqHA;;;;;;;;GAQG;AACH;IAP6B,QAAQ;IACC,MAAM;IACZ,KAAK;IACV,cAAc,EAA9B,MAAM;IACU,aAAa,EAA7B,MAAM;IACJ,QAAQ,MAAM,CAAC,CAkI3B"}