@woosh/meep-engine 3.69.0 → 3.70.0

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

@@ -1,95 +1,95 @@
-import { f32, u32, vec3f } from "../../renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../renderer/shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../renderer/shader/type/WebGPUStruct.js";
-import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../renderer/shader/resource/ShaderResourceSetDescriptor.js";
-import { BVH2_NODE_STRUCT } from "../../renderer/shader/chunk/bvh/BVH2_NODE_STRUCT.js";
-import { BVH_TRAVERSAL_STACK_SIZE } from "../../renderer/shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
-import {
-    chunk_ray_query_blas_nearest
-} from "../../renderer/shader/chunk/geometry/ray/chunk_ray_query_blas_nearest.js";
-import { RAY_STRUCT } from "../../renderer/shader/chunk/geometry/ray/RAY_STRUCT.js";
-import { GEOMETRY_METADATA_STRUCT } from "../../renderer/geometry/GEOMETRY_METADATA_STRUCT.js";
-import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../renderer/geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
-import {
-    MESHLET_METADATA_STRUCT
-} from "../../renderer/geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
-
-export const BLAS_POINTS_WORKGROUP_SIZE = 64;
-
-/**
- * @type {WebGPUStruct}
- */
-export const BLAS_POINTS_SETTINGS_STRUCT = WebGPUStruct.from({
-    origin: vec3f,
-    point_count: u32,
-    geometry_index: u32,
-    tmax: f32,
-}, "BlasPointsSettings");
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-dispatch, 32 bytes, read-only: immediate data rather than a uniform buffer
-resources.setImmediate("settings", BLAS_POINTS_SETTINGS_STRUCT);
-resources.createGroup()
-    // three f32 per point, in the geometry's own space
-    .addStorageBuffer("targets", WebGPUArray.from(f32), false)
-    .addStorageBuffer("blas_lookup", WebGPUArray.from(u32), false)
-    .addStorageBuffer("blas_data", WebGPUArray.from(BVH2_NODE_STRUCT), false)
-    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false)
-    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT), false)
-    .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE, false)
-    .addStorageBuffer("out_t", WebGPUArray.from(f32), true)
-    .addStorageBuffer("out_expected", WebGPUArray.from(f32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${BLAS_POINTS_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let i = gid.x;
-
-    if (i >= settings.point_count) {
-        return;
-    }
-
-    let target = vec3<f32>(targets[i * 3u], targets[i * 3u + 1u], targets[i * 3u + 2u]);
-
-    var ray: ${RAY_STRUCT.wgsl_ref};
-
-    ray.origin = settings.origin;
-    ray.direction = normalize(target - settings.origin);
-    ray.tmax = settings.tmax;
-
-    var stack: array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
-
-    let hit = ray_query_blas_nearest(ray, settings.geometry_index, &stack, 0u);
-
-    out_t[i] = hit.t;
-    out_expected[i] = length(target - settings.origin);
-}
-`, [
-    RAY_STRUCT.declaration_chunk,
-    chunk_ray_query_blas_nearest,
-]);
-
-/**
- * Ask the traversal about points the caller chooses, rather than about triangle centroids.
- *
- * Centroid rays answer "is this triangle reachable at all", and every triangle of a large flat
- * surface can be reachable at its middle while a band of it is not reachable at its edge — which is
- * the shape of failure a centroid audit reports as clean. Sampling the surface on a grid asks the
- * finer question, and answers it in the geometry's own coordinates rather than in pixels, so the
- * region that fails can be pointed at rather than described.
- *
- * A point known to lie on a surface must produce a hit at or before its own distance. Anything
- * further, or nothing at all, is the traversal declining a surface it was aimed at.
- *
- * @type {ComputeShader}
- */
-export const shader_blas_audit_points = ComputeShader.from({
-    label: "BLAS/AuditPoints",
-    resources,
-    body,
-});
+import { f32, u32, vec3f } from "../../renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../renderer/shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../renderer/shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../renderer/shader/resource/ShaderResourceSetDescriptor.js";
+import { BVH8_INODE_STRUCT } from "../../renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_INODE_STRUCT.js";
+import { BVH8_TRAVERSAL_STACK_SIZE } from "../../renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js";
+import {
+    chunk_ray_query_blas_nearest
+} from "../../renderer/shader/chunk/geometry/ray/chunk_ray_query_blas_nearest.js";
+import { RAY_STRUCT } from "../../renderer/shader/chunk/geometry/ray/RAY_STRUCT.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../renderer/geometry/GEOMETRY_METADATA_STRUCT.js";
+import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../renderer/geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
+import {
+    MESHLET_METADATA_STRUCT
+} from "../../renderer/geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+
+export const BLAS_POINTS_WORKGROUP_SIZE = 64;
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const BLAS_POINTS_SETTINGS_STRUCT = WebGPUStruct.from({
+    origin: vec3f,
+    point_count: u32,
+    geometry_index: u32,
+    tmax: f32,
+}, "BlasPointsSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 32 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", BLAS_POINTS_SETTINGS_STRUCT);
+resources.createGroup()
+    // three f32 per point, in the geometry's own space
+    .addStorageBuffer("targets", WebGPUArray.from(f32), false)
+    .addStorageBuffer("blas_lookup", WebGPUArray.from(u32), false)
+    .addStorageBuffer("blas_data", WebGPUArray.from(BVH8_INODE_STRUCT), false)
+    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false)
+    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT), false)
+    .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE, false)
+    .addStorageBuffer("out_t", WebGPUArray.from(f32), true)
+    .addStorageBuffer("out_expected", WebGPUArray.from(f32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${BLAS_POINTS_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+
+    if (i >= settings.point_count) {
+        return;
+    }
+
+    let aim = vec3<f32>(targets[i * 3u], targets[i * 3u + 1u], targets[i * 3u + 2u]);
+
+    var ray: ${RAY_STRUCT.wgsl_ref};
+
+    ray.origin = settings.origin;
+    ray.direction = normalize(aim - settings.origin);
+    ray.tmax = settings.tmax;
+
+    var stack: array<vec2u, ${BVH8_TRAVERSAL_STACK_SIZE}>;
+
+    let hit = ray_query_blas_nearest(ray, settings.geometry_index, &stack, 0u);
+
+    out_t[i] = hit.t;
+    out_expected[i] = length(aim - settings.origin);
+}
+`, [
+    RAY_STRUCT.declaration_chunk,
+    chunk_ray_query_blas_nearest,
+]);
+
+/**
+ * Ask the traversal about points the caller chooses, rather than about triangle centroids.
+ *
+ * Centroid rays answer "is this triangle reachable at all", and every triangle of a large flat
+ * surface can be reachable at its middle while a band of it is not reachable at its edge — which is
+ * the shape of failure a centroid audit reports as clean. Sampling the surface on a grid asks the
+ * finer question, and answers it in the geometry's own coordinates rather than in pixels, so the
+ * region that fails can be pointed at rather than described.
+ *
+ * A point known to lie on a surface must produce a hit at or before its own distance. Anything
+ * further, or nothing at all, is the traversal declining a surface it was aimed at.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_blas_audit_points = ComputeShader.from({
+    label: "BLAS/AuditPoints",
+    resources,
+    body,
+});

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

@@ -1,4 +1,12 @@
 export const BLAS_VISIBILITY_WORKGROUP_SIZE: 64;
+/**
+ * Triangle ids a meshlet can hold, used or not: the audit asks about every one of them, so that a
+ * thread's index says which triangle it is without a table. `(meshlet << 8) | triangle` is the id;
+ * a thread's index is `meshlet * BLAS_VISIBILITY_MESHLET_STRIDE + triangle`.
+ *
+ * @type {number}
+ */
+export const BLAS_VISIBILITY_MESHLET_STRIDE: number;
 /**
  * @type {WebGPUStruct}
  */
@@ -14,7 +22,7 @@ export const BLAS_VISIBILITY_SETTINGS_STRUCT: WebGPUStruct;
  * The ray goes from the camera to a triangle's centroid. That point is inside the triangle, so the
  * ray intersects it, so the query must return a hit — this triangle if nothing is in front, some
  * other one if something is. Only a miss is impossible, and a miss is therefore a traversal that
- * failed to reach a leaf whose box it was inside.
+ * failed to reach a slot whose box it was inside.
  *
  * Which triangles miss, and where they are, is the whole diagnosis.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"shader_blas_audit_visibility.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/shader_blas_audit_visibility.js"],"names":[],"mappings":"AAyBA,gDAAiD;AAEjD;;GAEG;AACH,8CAFU,YAAY,CASO;AA4E7B;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,aAAa,CAMpB;6BApI0B,4CAA4C;8BAE3C,wCAAwC"}
+{"version":3,"file":"shader_blas_audit_visibility.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/shader_blas_audit_visibility.js"],"names":[],"mappings":"AAwBA,gDAAiD;AAEjD;;;;;;GAMG;AACH,6CAFU,MAAM,CAE8D;AAE9E;;GAEG;AACH,8CAFU,YAAY,CAOO;AAiF7B;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,aAAa,CAMpB;6BA/I0B,4CAA4C;8BAE3C,wCAAwC"}

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

@@ -1,135 +1,146 @@
-import { f32, u32, vec3f } from "../../renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../renderer/shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../renderer/shader/type/WebGPUStruct.js";
-import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../renderer/shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    BVH_NODE_CHILD_2_WORD,
-    BVH_NODE_STRIDE_WORDS
-} from "../../renderer/gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js";
-import { BVH2_NODE_STRUCT } from "../../renderer/shader/chunk/bvh/BVH2_NODE_STRUCT.js";
-import { BVH_TRAVERSAL_STACK_SIZE } from "../../renderer/shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
-import {
-    chunk_ray_query_blas_nearest
-} from "../../renderer/shader/chunk/geometry/ray/chunk_ray_query_blas_nearest.js";
-import {
-    chunk_geometry_read_triangle_vertices
-} from "../../renderer/shader/chunk/geometry/format/chunk_geometry_read_triangle_vertices.js";
-import { RAY_STRUCT } from "../../renderer/shader/chunk/geometry/ray/RAY_STRUCT.js";
-import { GEOMETRY_METADATA_STRUCT } from "../../renderer/geometry/GEOMETRY_METADATA_STRUCT.js";
-import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../renderer/geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
-import {
-    MESHLET_METADATA_STRUCT
-} from "../../renderer/geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
-
-export const BLAS_VISIBILITY_WORKGROUP_SIZE = 64;
-
-/**
- * @type {WebGPUStruct}
- */
-export const BLAS_VISIBILITY_SETTINGS_STRUCT = WebGPUStruct.from({
-    origin: vec3f,
-    leaf_count: u32,
-    node_word_offset: u32,
-    leaf_nodes_offset: u32,
-    geometry_index: u32,
-    tmax: f32,
-}, "BlasVisibilitySettings");
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-dispatch, 32 bytes, read-only: immediate data rather than a uniform buffer
-resources.setImmediate("settings", BLAS_VISIBILITY_SETTINGS_STRUCT);
-resources.createGroup()
-    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), false)
-    .addStorageBuffer("blas_lookup", WebGPUArray.from(u32), false)
-    .addStorageBuffer("blas_data", WebGPUArray.from(BVH2_NODE_STRUCT), false)
-    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false)
-    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT), false)
-    .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE, false)
-    .addStorageBuffer("nodes", WebGPUArray.from(f32), false)
-    // per leaf: the parametric t the traversal came back with, negative for a miss
-    .addStorageBuffer("out_t", WebGPUArray.from(f32), true)
-    // per leaf: the triangle the traversal returned, or 0xFFFFFFFF
-    .addStorageBuffer("out_triangle", WebGPUArray.from(u32), true)
-    // per leaf: the distance to the point the ray was aimed at, which the answer cannot exceed
-    .addStorageBuffer("out_expected_t", WebGPUArray.from(f32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const NODE_STRIDE = ${BVH_NODE_STRIDE_WORDS}u;
-const NODE_CHILD_2 = ${BVH_NODE_CHILD_2_WORD}u;
-
-@compute @workgroup_size(${BLAS_VISIBILITY_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let i = gid.x;
-
-    if (i >= settings.leaf_count) {
-        return;
-    }
-
-    let leaf_node = leaf_nodes[settings.leaf_nodes_offset + i];
-
-    let node_word = settings.node_word_offset + leaf_node * NODE_STRIDE;
-
-    let meshlet_triangle_id = bitcast<u32>(nodes[node_word + NODE_CHILD_2]);
-
-    let triangle = geometry_read_triangle_vertices(
-        geometries[settings.geometry_index],
-        meshlet_triangle_id
-    );
-
-    // Aim at the triangle's own centroid, which is strictly inside it. The ray provably intersects
-    // this triangle, so the traversal has to come back with *something* — this one, or something
-    // occluding it. A miss is not a geometric possibility; it is the traversal failing to reach a
-    // leaf whose box, by construction, the ray passes through.
-    let centre = (triangle.a.position + triangle.b.position + triangle.c.position) / 3.0;
-
-    var ray: ${RAY_STRUCT.wgsl_ref};
-
-    ray.origin = settings.origin;
-    ray.direction = normalize(centre - settings.origin);
-    ray.tmax = settings.tmax;
-
-    var stack: array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
-
-    let hit = ray_query_blas_nearest(ray, settings.geometry_index, &stack, 0u);
-
-    out_t[i] = hit.t;
-    out_triangle[i] = select(0xFFFFFFFFu, hit.triangle, hit.t >= 0.0);
-
-    // The ray was aimed at a point on this triangle, so the nearest surface along it is at most
-    // this far. An answer beyond it is not an occlusion and not a miss — it is the traversal
-    // walking past a surface it was pointed at, which is what a hole in the traced image is.
-    out_expected_t[i] = length(centre - settings.origin);
-}
-`, [
-    RAY_STRUCT.declaration_chunk,
-    chunk_geometry_read_triangle_vertices,
-    chunk_ray_query_blas_nearest,
-]);
-
-/**
- * Ask the traversal, once per triangle, whether it can find that triangle.
- *
- * Every structural check on the tree has passed, which narrows the fault to the traversal itself —
- * and traversal is the one thing no readback of the tree can exercise. So this runs the real
- * `ray_query_blas_nearest`, the same function the path tracer calls, along a ray whose answer is
- * known in advance.
- *
- * The ray goes from the camera to a triangle's centroid. That point is inside the triangle, so the
- * ray intersects it, so the query must return a hit — this triangle if nothing is in front, some
- * other one if something is. Only a miss is impossible, and a miss is therefore a traversal that
- * failed to reach a leaf whose box it was inside.
- *
- * Which triangles miss, and where they are, is the whole diagnosis.
- *
- * @type {ComputeShader}
- */
-export const shader_blas_audit_visibility = ComputeShader.from({
-    label: "BLAS/AuditVisibility",
-    resources,
-    body,
-});
+import { f32, u32, vec3f } from "../../renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../renderer/shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../renderer/shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../renderer/shader/resource/ShaderResourceSetDescriptor.js";
+import { BVH8_INODE_STRUCT } from "../../renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_INODE_STRUCT.js";
+import { BVH8_TRAVERSAL_STACK_SIZE } from "../../renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js";
+import {
+    chunk_ray_query_blas_nearest
+} from "../../renderer/shader/chunk/geometry/ray/chunk_ray_query_blas_nearest.js";
+import {
+    chunk_geometry_read_triangle_positions
+} from "../../renderer/shader/chunk/geometry/format/chunk_geometry_read_triangle_positions.js";
+import { RAY_STRUCT } from "../../renderer/shader/chunk/geometry/ray/RAY_STRUCT.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../renderer/geometry/GEOMETRY_METADATA_STRUCT.js";
+import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../renderer/geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
+import {
+    GEOMETRY_MESHLET_TRIANGLE_LIMIT
+} from "../../renderer/geometry/meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
+import {
+    MESHLET_METADATA_STRUCT
+} from "../../renderer/geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+
+export const BLAS_VISIBILITY_WORKGROUP_SIZE = 64;
+
+/**
+ * Triangle ids a meshlet can hold, used or not: the audit asks about every one of them, so that a
+ * thread's index says which triangle it is without a table. `(meshlet << 8) | triangle` is the id;
+ * a thread's index is `meshlet * BLAS_VISIBILITY_MESHLET_STRIDE + triangle`.
+ *
+ * @type {number}
+ */
+export const BLAS_VISIBILITY_MESHLET_STRIDE = GEOMETRY_MESHLET_TRIANGLE_LIMIT;
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const BLAS_VISIBILITY_SETTINGS_STRUCT = WebGPUStruct.from({
+    origin: vec3f,
+    meshlet_count: u32,
+    geometry_index: u32,
+    tmax: f32,
+}, "BlasVisibilitySettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 24 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", BLAS_VISIBILITY_SETTINGS_STRUCT);
+resources.createGroup()
+    .addStorageBuffer("blas_lookup", WebGPUArray.from(u32), false)
+    .addStorageBuffer("blas_data", WebGPUArray.from(BVH8_INODE_STRUCT), false)
+    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false)
+    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT), false)
+    .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE, false)
+    // per triangle id: the parametric t the traversal came back with, negative for a miss
+    .addStorageBuffer("out_t", WebGPUArray.from(f32), true)
+    // per triangle id: the triangle the traversal returned, or 0xFFFFFFFF
+    .addStorageBuffer("out_triangle", WebGPUArray.from(u32), true)
+    // per triangle id: the distance to the point the ray was aimed at, which the answer cannot exceed;
+    // negative for an id the meshlet does not hold, which no ray was sent for
+    .addStorageBuffer("out_expected_t", WebGPUArray.from(f32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const MESHLET_STRIDE = ${BLAS_VISIBILITY_MESHLET_STRIDE}u;
+
+@compute @workgroup_size(${BLAS_VISIBILITY_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+
+    let meshlet = i / MESHLET_STRIDE;
+    let triangle = i % MESHLET_STRIDE;
+
+    if (meshlet >= settings.meshlet_count) {
+        return;
+    }
+
+    let geometry = geometries[settings.geometry_index];
+
+    if (triangle >= meshlet_metadata[geometry.meshlets_address + meshlet].primitive_count) {
+        // not a triangle
+        out_expected_t[i] = -1.0;
+
+        return;
+    }
+
+    var a: vec3<f32>;
+    var b: vec3<f32>;
+    var c: vec3<f32>;
+
+    geometry_read_triangle_positions(&a, &b, &c, geometry, (meshlet << 8u) | triangle);
+
+    // Aim at the triangle's own centroid, which is strictly inside it. The ray provably intersects
+    // this triangle, so the traversal has to come back with *something* — this one, or something
+    // occluding it. A miss is not a geometric possibility; it is the traversal failing to reach a
+    // slot whose box, by construction, the ray passes through.
+    let centre = (a + b + c) / 3.0;
+
+    var ray: ${RAY_STRUCT.wgsl_ref};
+
+    ray.origin = settings.origin;
+    ray.direction = normalize(centre - settings.origin);
+    ray.tmax = settings.tmax;
+
+    var stack: array<vec2u, ${BVH8_TRAVERSAL_STACK_SIZE}>;
+
+    let hit = ray_query_blas_nearest(ray, settings.geometry_index, &stack, 0u);
+
+    out_t[i] = hit.t;
+    out_triangle[i] = select(0xFFFFFFFFu, hit.triangle, hit.t >= 0.0);
+
+    // The ray was aimed at a point on this triangle, so the nearest surface along it is at most
+    // this far. An answer beyond it is not an occlusion and not a miss — it is the traversal
+    // walking past a surface it was pointed at, which is what a hole in the traced image is.
+    out_expected_t[i] = length(centre - settings.origin);
+}
+`, [
+    RAY_STRUCT.declaration_chunk,
+    chunk_geometry_read_triangle_positions,
+    chunk_ray_query_blas_nearest,
+]);
+
+/**
+ * Ask the traversal, once per triangle, whether it can find that triangle.
+ *
+ * Every structural check on the tree has passed, which narrows the fault to the traversal itself —
+ * and traversal is the one thing no readback of the tree can exercise. So this runs the real
+ * `ray_query_blas_nearest`, the same function the path tracer calls, along a ray whose answer is
+ * known in advance.
+ *
+ * The ray goes from the camera to a triangle's centroid. That point is inside the triangle, so the
+ * ray intersects it, so the query must return a hit — this triangle if nothing is in front, some
+ * other one if something is. Only a miss is impossible, and a miss is therefore a traversal that
+ * failed to reach a slot whose box it was inside.
+ *
+ * Which triangles miss, and where they are, is the whole diagnosis.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_blas_audit_visibility = ComputeShader.from({
+    label: "BLAS/AuditVisibility",
+    resources,
+    body,
+});

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

@@ -1,15 +1,15 @@
 /**
  * The leaf audit, on a skinned clone: its tree as the frame's refit left it, against the deformed
- * triangles the intersector fetches for those leaves now.
+ * triangles the intersector fetches now.
  *
  * `verify_leaf_triangles` needs a target, and a clone's owner handle lives inside the skinning
- * context. Every copy of a geometry shares one shape, so the clone's target is its source's with
- * the clone's own node address substituted — and that address is what the published lookup holds
+ * context. A copy of a geometry has as many nodes as its source, so the clone's target is the
+ * source's count at the clone's own address — and that address is what the published lookup holds
  * for the clone's geometry row.
  *
- * The refit and this audit run a frame apart at most, so a leaf may be a little larger than its
- * triangle; a leaf that is *somewhere else* is a leaf the frame did not refit. The pattern of those
- * is the point: reported as runs of leaf ordinals and as the workgroups of 64 they fall in.
+ * The refit and this audit run a frame apart at most, so a slot may be a little larger than its
+ * triangles; a slot that is *somewhere else* is a node the frame did not refit. The pattern of those
+ * is the point: reported as runs of node indices and as the refit's workgroups they fall in.
  *
  * @param {object} options
  * @param {Renderer} options.renderer

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

@@ -1 +1 @@
-{"version":3,"file":"verify_clone_leaves.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/verify_clone_leaves.js"],"names":[],"mappings":"AAuDA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAN6B,QAAQ;IACX,KAAK;IACJ,MAAM,EAAtB,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,QAAQ,MAAM,CAAC,CA4D3B"}
+{"version":3,"file":"verify_clone_leaves.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/verify_clone_leaves.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAN6B,QAAQ;IACX,KAAK;IACJ,MAAM,EAAtB,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,QAAQ,MAAM,CAAC,CAyE3B"}