@woosh/meep-engine 3.69.0 → 3.70.0

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

@@ -1,249 +1,255 @@
-import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
-import {
-    BLAS_VISIBILITY_SETTINGS_STRUCT,
-    shader_blas_audit_visibility
-} from "./shader_blas_audit_visibility.js";
-
-/**
- * Can the traversal reach every triangle in the tree?
- *
- * The last unexercised link. Everything about the tree itself checks out — leaf boxes contain the
- * triangles the intersector fetches, internal nodes are their children's union, the root matches an
- * independently computed box, the instance's world AABB contains the geometry, and the stack does
- * not overflow. None of that runs `ray_query_blas_nearest`, and that function is what the picture
- * is made of.
- *
- * So: one ray per triangle, from the camera to that triangle's own centroid. The centroid is inside
- * the triangle, so the ray intersects it, so a hit is guaranteed — this triangle, or whatever
- * occludes it. A miss cannot happen geometrically. Every miss is the traversal declining to enter a
- * box the ray is inside.
- *
- * Run it from a view that the picture disagrees at and from one it agrees at; the difference
- * between the two counts is the fault, expressed as triangles rather than pixels.
- */
-
-/**
- * @param {GPUDevice} device
- * @param {GPUBuffer} buffer
- * @param {number} size
- * @returns {Promise<ArrayBuffer>}
- */
-async function read_back(device, buffer, size) {
-    const staging = device.createBuffer({
-        label: 'reachability/readback',
-        size,
-        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-    });
-
-    const encoder = device.createCommandEncoder({ label: 'reachability/readback' });
-
-    encoder.copyBufferToBuffer(buffer, 0, staging, 0, size);
-
-    device.queue.submit([encoder.finish()]);
-
-    await staging.mapAsync(GPUMapMode.READ);
-
-    const copy = staging.getMappedRange().slice(0);
-
-    staging.unmap();
-    staging.destroy();
-
-    return copy;
-}
-
-/**
- * Apply the inverse of a mesh's transform to a world point — the same trip `chunk_ray_query_nearest`
- * makes to put a ray into geometry space.
- *
- * Done on the host with a full inverse rather than by transposing a rotation, because the transform
- * carries the asset's centimetre scale and a shortcut that assumes orthonormality would silently be
- * a hundred times wrong here.
- *
- * @param {ArrayLike<number>} m column-major 4x4
- * @param {number[]} point
- * @returns {number[]}
- */
-function inverse_transform_point(m, point) {
-    const a = [
-        [m[0], m[4], m[8], m[12]],
-        [m[1], m[5], m[9], m[13]],
-        [m[2], m[6], m[10], m[14]],
-        [m[3], m[7], m[11], m[15]],
-    ];
-
-    const b = [point[0], point[1], point[2], 1];
-
-    // Gaussian elimination on the 4x4 — small, and clearer than an inlined cofactor expansion
-    for (let column = 0; column < 4; column++) {
-        let pivot = column;
-
-        for (let row = column + 1; row < 4; row++) {
-            if (Math.abs(a[row][column]) > Math.abs(a[pivot][column])) {
-                pivot = row;
-            }
-        }
-
-        [a[column], a[pivot]] = [a[pivot], a[column]];
-        [b[column], b[pivot]] = [b[pivot], b[column]];
-
-        const divisor = a[column][column];
-
-        for (let k = column; k < 4; k++) {
-            a[column][k] /= divisor;
-        }
-
-        b[column] /= divisor;
-
-        for (let row = 0; row < 4; row++) {
-            if (row === column) {
-                continue;
-            }
-
-            const factor = a[row][column];
-
-            for (let k = column; k < 4; k++) {
-                a[row][k] -= factor * a[column][k];
-            }
-
-            b[row] -= factor * b[column];
-        }
-    }
-
-    const w = b[3] === 0 ? 1 : b[3];
-
-    return [b[0] / w, b[1] / w, b[2] / w];
-}
-
-/**
- * @param {object} options
- * @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
- * @returns {Promise<object>}
- */
-export async function verify_traversal_reachability({
-                                                        renderer,
-                                                        camera,
-                                                        world,
-                                                        target,
-                                                        geometry_index,
-                                                    }) {
-    const graphics = renderer.graphics;
-    const device = graphics.device;
-
-    const geometries = graphics.geometries;
-    const blas = geometries.blas;
-    const meshlets = geometries.meshlets;
-
-    const { leaf_count, node_word_offset, leaf_nodes_offset } = target;
-
-    const origin = inverse_transform_point(
-        world,
-        [...camera.transform.translation]
-    );
-
-    const t_bytes = leaf_count * Float32Array.BYTES_PER_ELEMENT;
-
-    const out_t = device.createBuffer({
-        label: 'reachability/t',
-        size: t_bytes,
-        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
-    });
-
-    const out_triangle = device.createBuffer({
-        label: 'reachability/triangle',
-        size: t_bytes,
-        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
-    });
-
-    const out_expected_t = device.createBuffer({
-        label: 'reachability/expected t',
-        size: t_bytes,
-        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
-    });
-
-    const cmd = ShadeGPUCommandContext.create(graphics, 'audit/reachability');
-
-    shader_blas_audit_visibility.dispatchThreads({
-        encoder: cmd,
-        thread_count_x: leaf_count,
-        bindings: {
-            settings: {
-                origin,
-                leaf_count,
-                node_word_offset,
-                leaf_nodes_offset,
-                geometry_index,
-                tmax: 1e12,
-            },
-            leaf_nodes: blas.buffer_leaf_nodes,
-            blas_lookup: blas.buffer_metadata,
-            blas_data: blas.buffer_data,
-            geometries: geometries.buffer_metadata,
-            meshlet_metadata: meshlets.buffer_metadata,
-            meshlet_data: meshlets.buffer_data,
-            nodes: blas.buffer_data,
-            out_t,
-            out_triangle,
-            out_expected_t,
-        },
-    });
-
-    cmd.finish();
-
-    await device.queue.onSubmittedWorkDone();
-
-    const t = new Float32Array(await read_back(device, out_t, t_bytes));
-    const expected = new Float32Array(await read_back(device, out_expected_t, t_bytes));
-
-    out_t.destroy();
-    out_triangle.destroy();
-    out_expected_t.destroy();
-
-    let missed = 0;
-    let overshot = 0;
-    let worst_overshoot = 0;
-
-    for (let i = 0; i < leaf_count; i++) {
-        if (!(t[i] >= 0)) {
-            missed += 1;
-
-            continue;
-        }
-
-        // 1e-3 of the aimed distance, which is far above float error on these magnitudes and far
-        // below the gap between one surface and the next
-        const overshoot = (t[i] - expected[i]) / Math.max(1e-9, expected[i]);
-
-        if (overshoot > 1e-3) {
-            overshot += 1;
-
-            worst_overshoot = Math.max(worst_overshoot, overshoot);
-        }
-    }
-
-    const lost = missed + overshot;
-
-    const result = {
-        leaf_count,
-        missed,
-        overshot,
-        worst_overshoot: +worst_overshoot.toFixed(4),
-        lost,
-        lost_pct: +(lost / leaf_count * 100).toFixed(3),
-        origin: origin.map(v => +v.toFixed(3)),
-        verdict: lost === 0
-            ? `pass — the traversal returns a surface at or before every one of ${leaf_count} `
-            + `triangles it was aimed at`
-            : `FAIL — ${lost} of ${leaf_count} (${(lost / leaf_count * 100).toFixed(2)}%) rays aimed `
-            + `at a triangle came back with nothing (${missed}) or with something behind it `
-            + `(${overshot}). Neither is geometrically possible, so the traversal is walking past `
-            + `surfaces it was pointed at — which is the hole in the traced image.`,
-    };
-
-    console.log(result.verdict, result);
-
-    return result;
-}
+import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import {
+    BLAS_VISIBILITY_MESHLET_STRIDE,
+    BLAS_VISIBILITY_SETTINGS_STRUCT,
+    shader_blas_audit_visibility
+} from "./shader_blas_audit_visibility.js";
+
+/**
+ * Can the traversal reach every triangle in the tree?
+ *
+ * The last unexercised link. Everything about the tree itself checks out — leaf boxes contain the
+ * triangles the intersector fetches, internal nodes are their children's union, the root matches an
+ * independently computed box, the instance's world AABB contains the geometry, and the stack does
+ * not overflow. None of that runs `ray_query_blas_nearest`, and that function is what the picture
+ * is made of.
+ *
+ * So: one ray per triangle, from the camera to that triangle's own centroid. The centroid is inside
+ * the triangle, so the ray intersects it, so a hit is guaranteed — this triangle, or whatever
+ * occludes it. A miss cannot happen geometrically. Every miss is the traversal declining to enter a
+ * box the ray is inside.
+ *
+ * Run it from a view that the picture disagrees at and from one it agrees at; the difference
+ * between the two counts is the fault, expressed as triangles rather than pixels.
+ */
+
+/**
+ * @param {GPUDevice} device
+ * @param {GPUBuffer} buffer
+ * @param {number} size
+ * @returns {Promise<ArrayBuffer>}
+ */
+async function read_back(device, buffer, size) {
+    const staging = device.createBuffer({
+        label: 'reachability/readback',
+        size,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+    });
+
+    const encoder = device.createCommandEncoder({ label: 'reachability/readback' });
+
+    encoder.copyBufferToBuffer(buffer, 0, staging, 0, size);
+
+    device.queue.submit([encoder.finish()]);
+
+    await staging.mapAsync(GPUMapMode.READ);
+
+    const copy = staging.getMappedRange().slice(0);
+
+    staging.unmap();
+    staging.destroy();
+
+    return copy;
+}
+
+/**
+ * Apply the inverse of a mesh's transform to a world point — the same trip `chunk_ray_query_nearest`
+ * makes to put a ray into geometry space.
+ *
+ * Done on the host with a full inverse rather than by transposing a rotation, because the transform
+ * carries the asset's centimetre scale and a shortcut that assumes orthonormality would silently be
+ * a hundred times wrong here.
+ *
+ * @param {ArrayLike<number>} m column-major 4x4
+ * @param {number[]} point
+ * @returns {number[]}
+ */
+function inverse_transform_point(m, point) {
+    const a = [
+        [m[0], m[4], m[8], m[12]],
+        [m[1], m[5], m[9], m[13]],
+        [m[2], m[6], m[10], m[14]],
+        [m[3], m[7], m[11], m[15]],
+    ];
+
+    const b = [point[0], point[1], point[2], 1];
+
+    // Gaussian elimination on the 4x4 — small, and clearer than an inlined cofactor expansion
+    for (let column = 0; column < 4; column++) {
+        let pivot = column;
+
+        for (let row = column + 1; row < 4; row++) {
+            if (Math.abs(a[row][column]) > Math.abs(a[pivot][column])) {
+                pivot = row;
+            }
+        }
+
+        [a[column], a[pivot]] = [a[pivot], a[column]];
+        [b[column], b[pivot]] = [b[pivot], b[column]];
+
+        const divisor = a[column][column];
+
+        for (let k = column; k < 4; k++) {
+            a[column][k] /= divisor;
+        }
+
+        b[column] /= divisor;
+
+        for (let row = 0; row < 4; row++) {
+            if (row === column) {
+                continue;
+            }
+
+            const factor = a[row][column];
+
+            for (let k = column; k < 4; k++) {
+                a[row][k] -= factor * a[column][k];
+            }
+
+            b[row] -= factor * b[column];
+        }
+    }
+
+    const w = b[3] === 0 ? 1 : b[3];
+
+    return [b[0] / w, b[1] / w, b[2] / w];
+}
+
+/**
+ * @param {object} options
+ * @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 {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 async function verify_traversal_reachability({
+                                                        renderer,
+                                                        camera,
+                                                        world,
+                                                        geometry_index,
+                                                        meshlet_count,
+                                                    }) {
+    const graphics = renderer.graphics;
+    const device = graphics.device;
+
+    const geometries = graphics.geometries;
+    const blas = geometries.blas;
+    const meshlets = geometries.meshlets;
+
+    // every triangle id the geometry's meshlets could hold; the shader says which of them are triangles
+    const id_count = meshlet_count * BLAS_VISIBILITY_MESHLET_STRIDE;
+
+    const origin = inverse_transform_point(
+        world,
+        [...camera.transform.translation]
+    );
+
+    const t_bytes = id_count * Float32Array.BYTES_PER_ELEMENT;
+
+    const out_t = device.createBuffer({
+        label: 'reachability/t',
+        size: t_bytes,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+    });
+
+    const out_triangle = device.createBuffer({
+        label: 'reachability/triangle',
+        size: t_bytes,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+    });
+
+    const out_expected_t = device.createBuffer({
+        label: 'reachability/expected t',
+        size: t_bytes,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+    });
+
+    const cmd = ShadeGPUCommandContext.create(graphics, 'audit/reachability');
+
+    shader_blas_audit_visibility.dispatchThreads({
+        encoder: cmd,
+        thread_count_x: id_count,
+        bindings: {
+            settings: {
+                origin,
+                meshlet_count,
+                geometry_index,
+                tmax: 1e12,
+            },
+            blas_lookup: blas.buffer_metadata,
+            blas_data: blas.buffer_data,
+            geometries: geometries.buffer_metadata,
+            meshlet_metadata: meshlets.buffer_metadata,
+            meshlet_data: meshlets.buffer_data,
+            out_t,
+            out_triangle,
+            out_expected_t,
+        },
+    });
+
+    cmd.finish();
+
+    await device.queue.onSubmittedWorkDone();
+
+    const t = new Float32Array(await read_back(device, out_t, t_bytes));
+    const expected = new Float32Array(await read_back(device, out_expected_t, t_bytes));
+
+    out_t.destroy();
+    out_triangle.destroy();
+    out_expected_t.destroy();
+
+    let triangle_count = 0;
+    let missed = 0;
+    let overshot = 0;
+    let worst_overshoot = 0;
+
+    for (let i = 0; i < id_count; i++) {
+        if (expected[i] < 0) {
+            // not a triangle
+            continue;
+        }
+
+        triangle_count += 1;
+
+        if (!(t[i] >= 0)) {
+            missed += 1;
+
+            continue;
+        }
+
+        // 1e-3 of the aimed distance, which is far above float error on these magnitudes and far
+        // below the gap between one surface and the next
+        const overshoot = (t[i] - expected[i]) / Math.max(1e-9, expected[i]);
+
+        if (overshoot > 1e-3) {
+            overshot += 1;
+
+            worst_overshoot = Math.max(worst_overshoot, overshoot);
+        }
+    }
+
+    const lost = missed + overshot;
+
+    const result = {
+        triangle_count,
+        missed,
+        overshot,
+        worst_overshoot: +worst_overshoot.toFixed(4),
+        lost,
+        lost_pct: +(lost / Math.max(1, triangle_count) * 100).toFixed(3),
+        origin: origin.map(v => +v.toFixed(3)),
+        verdict: lost === 0
+            ? `pass — the traversal returns a surface at or before every one of ${triangle_count} `
+            + `triangles it was aimed at`
+            : `FAIL — ${lost} of ${triangle_count} (${(lost / Math.max(1, triangle_count) * 100).toFixed(2)}%) rays aimed `
+            + `at a triangle came back with nothing (${missed}) or with something behind it `
+            + `(${overshot}). Neither is geometrically possible, so the traversal is walking past `
+            + `surfaces it was pointed at — which is the hole in the traced image.`,
+    };
+
+    console.log(result.verdict, result);
+
+    return result;
+}

package/src/shade/playground/water_surface/main.js

@@ -62,9 +62,9 @@ async function main() {
     sun_pose.setRotation(rotation.x, rotation.y, rotation.z, rotation.w); sun_pose.updateMatrix();
     new Entity().add(sun).add(sun_pose).build(dataset);
 
-    // the weather: a steady wind the air relaxes to over two seconds, and a gust on top of it
+    // the weather: a steady wind the air relaxes to over two seconds, and turbulence on top of it
     const weather = new GlobalFluidEffector();
-    weather.drag = 0.5; weather.gust_period = 4;
+    weather.drag = 0.5;
     const effectors = new FluidEffectorsComponent(); effectors.addEffector(weather);
     new Entity().add(effectors).build(dataset);
     // the fluid's domain sits on the stop's body, so the wind 10 m above it is the fluid's, not the far field's alone
@@ -86,7 +86,10 @@ async function main() {
     function configure() {
         const heading = number("direction") * Math.PI / 180;
         weather.wind = [number("wind") * Math.cos(heading), 0, number("wind") * Math.sin(heading)];
-        weather.gust = number("gust");
+        // the gust slider is the turbulence's rms; its strongest eddies go by every 4 s
+        const speed = number("wind");
+        weather.turbulence_intensity = speed > 0 ? number("gust") / speed : 0;
+        weather.turbulence_length = speed > 0 ? speed * 4 / 4.05 : weather.turbulence_length;
         describe_wind();
     }
     const far = new Float64Array(3);

package/src/shade/renderer/animation/GPUAnimationManager.js

@@ -1660,7 +1660,7 @@ export class GPUAnimationManager {
 
                 driving.set(target, clips);
 
-                if (!this.#foliage_rigs_driving.has(target)) {
+                if (!this.#foliage_rigs_driving.has(target)) {
                     gpu_authority_declare(dataset, target);
                     /*
                      The first clip to drive a joint takes its offset, and with it the joint's world
@@ -2893,7 +2893,7 @@ export class GPUAnimationManager {
                 this.#scene_context.wind.bind(bindings);
                 const switches = ShaderSwitchSet.EMPTY.with(
                     WIND_FIELD_UNIFORM,
-                    this.#scene_context.wind.cascade_count === 0
+                    this.#scene_context.wind.is_uniform
                 );
                 shader_foliage_wind_apply.variant(switches).dispatch({
                     encoder: ctx.encoder,

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;;;;;;OAaG;IACH,4BAFW,MAAM,QAehB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA+NnB;IAmXD;;;;;;;OAOG;IACH,gBA+BC;;CACJ;qCAzyCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}
+{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;;;;;;OAaG;IACH,4BAFW,MAAM,QAehB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA8NnB;IAmXD;;;;;;;OAOG;IACH,gBA+BC;;CACJ;qCAxyCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js

@@ -108,8 +108,8 @@ const MESHLET_STRIDE_BYTES = MESHLET_METADATA_STRUCT.aligned_size;
  * manager. Resolution happens at upload time via
  * `animation_manager.get_skin_matrix_offset(skin_id)`.
  */
-export class GPUMeshSkinningContext {
-
+export class GPUMeshSkinningContext {
+
     /** @type {GPUDevice} */
     #device;
 
@@ -931,10 +931,9 @@ export class GPUMeshSkinningContext {
         // longer in: rays miss where the mesh now is and hit where it no longer is.
         //
         // Topology is untouched. Refitting a tree whose triangles moved but whose shape did not is
-        // a fraction of the full build's sort-and-emit — which is why a clone gets a copy of the
-        // source's nodes rather than a build of its own. And it is one batch for every clone at
-        // once, not a dispatch per clone: the command count is the same for one skinned mesh as
-        // for three hundred, and each tree's climb overlaps the next's instead of waiting on it.
+        // a fraction of a build — which is why a clone gets a copy of the source's nodes rather
+        // than a build of its own. And it is one batch for every clone at once, not a dispatch per
+        // clone: the command count is the same for one skinned mesh as for three hundred.
         this.#record_blas_refits(cmd_ctx);
 
         // every bound mesh's clone was deformed this frame, so every bound row's bounds moved
@@ -948,8 +947,8 @@ export class GPUMeshSkinningContext {
      * are resident, and where, the batch asks the BLAS manager — and only when the manager says the
      * answer may have moved.
      *
-     * Recorded here and nowhere else, on purpose: the batch binds the manager's arena buffers as
-     * they are at this moment, and those are replaced when an arena grows in the geometry update,
+     * Recorded here and nowhere else, on purpose: the batch binds the manager's arena buffer as
+     * it is at this moment, and that is replaced when the arena grows in the geometry update,
      * which runs before this frame's command context exists. See {@link GPUBLASRefitBatch}.
      *
      * @param {ShadeGPUCommandContext} cmd_ctx