@woosh/meep-engine 3.11.3 → 3.13.0

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

@@ -1,249 +1,249 @@
-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 {Mesh} options.mesh the instance whose transform 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,
-                                                        mesh,
-                                                        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(
-        mesh.transform_global.matrix,
-        [...camera.transform.position]
-    );
-
-    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.dispatchLinear({
-        encoder: cmd,
-        element_count: leaf_count,
-        bindings: {
-            settings: cmd.allocateTransientValueBuffer(BLAS_VISIBILITY_SETTINGS_STRUCT, {
-                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_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 {Mesh} options.mesh the instance whose transform 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,
+                                                        mesh,
+                                                        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(
+        mesh.transform_global.matrix,
+        [...camera.transform.position]
+    );
+
+    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;
+}

package/src/shade/renderer/Renderer.d.ts

@@ -198,11 +198,6 @@ export class Renderer {
      */
     onDeviceFailure: any;
     onFrameFinished: Signal;
-    /**
-     * First argument is frame index, second is table of debug data
-     * @type {Signal<number, Object[]>}
-     */
-    onFrameDebug: any;
     /**
      *
      * @param {number} v
@@ -296,7 +291,6 @@ export class Renderer {
      * @returns {number} how many extensions are registered on `phase`
      */
     extension_count(phase: FramePhase): number;
-    add_debug_frame(count?: number): void;
     /**
      *
      * @param {Scene} scene

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA4FA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,0CAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAkB1C,uCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,sCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAE/B;;;OAGG;IACH,kBAA4B;IAiB5B;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,6BAcC;IA1BD;;;OAGG;IACH,0BAEC;IA4BD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,oBAAkB,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAGD,sCAIC;IAeD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EA0NC;IAED;;OAEG;IACH,gBAGC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8EAJW,MAAM,UACN,iBAAiB,GACf,OAAO,CAi3BnB;;CACJ;6BA16E4B,yBAAyB;0CACZ,gCAAgC;2BApB/C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAiC7C,uBAAuB;gCAtCnB,sBAAsB;mBArCnC,oCAAoC;oBACnC,4BAA4B;kCAuEd,gCAAgC;2BApDvC,2BAA2B;iCAkDrB,0CAA0C;4CApC/B,+DAA+D;yBA6BlF,yBAAyB;kCAMhB,wBAAwB;oBAvBtC,0BAA0B;uCAPP,sDAAsD"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA4FA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,0CAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAkB1C,uCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,sCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAgB/B;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,6BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,oBAAkB,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EA0NC;IAED;;OAEG;IACH,gBAGC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8EAJW,MAAM,UACN,iBAAiB,GACf,OAAO,CAu2BnB;;CACJ;6BA74E4B,yBAAyB;0CACZ,gCAAgC;2BApB/C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAiC7C,uBAAuB;gCAtCnB,sBAAsB;mBArCnC,oCAAoC;oBACnC,4BAA4B;kCAuEd,gCAAgC;2BApDvC,2BAA2B;iCAkDrB,0CAA0C;4CApC/B,+DAA+D;yBA6BlF,yBAAyB;kCAMhB,wBAAwB;oBAvBtC,0BAA0B;uCAPP,sDAAsD"}

package/src/shade/renderer/Renderer.js

@@ -424,13 +424,6 @@ export class Renderer {
 
     onFrameFinished = new Signal();
 
-    /**
-     * First argument is frame index, second is table of debug data
-     * @type {Signal<number, Object[]>}
-     */
-    onFrameDebug = new Signal();
-
-
     /**
      * Fraction of the output resolution.
      * Controls {@link #internal_resolution}.
@@ -599,12 +592,6 @@ export class Renderer {
         this.#update_resolution();
     }
 
-    /**
-     * How many future frames should be debugged
-     * @type {number}
-     */
-    #debug_frame_count = 0;
-
     /**
      * The profile recording to feed, or null.
      *
@@ -668,12 +655,6 @@ export class Renderer {
     }
 
 
-    add_debug_frame(count = 1) {
-        assert.isNonNegativeInteger(count, 'count');
-
-        this.#debug_frame_count += count;
-    }
-
     /**
      *
      * @type {Map<Scene, GPULightProbeVolumeRenderer>}
@@ -1733,16 +1714,6 @@ export class Renderer {
             "Renderer/main-0"
         );
 
-        if (this.#debug_frame_count > 0) {
-            this.#debug_frame_count--;
-
-            const current_frame = this.#frame_count;
-
-            command_ctx.enable_debug_timers((table) => {
-                this.onFrameDebug.send2(current_frame, table);
-            });
-        }
-
         /**
          * The frame recorder for this frame, or null when nothing is profiling.
          * @type {GPUFrameRecorder|null}

package/src/shade/renderer/STATIC_GRAPHICS_ENGINE_ASSETS.js

@@ -23,7 +23,7 @@ export class StaticGraphicsEngineAssets {
         // Spatio-Temporal Blue Noise (NVIDIA 2020-ish)
 
         // vendored alongside the engine rather than at the repo root, so `src/shade` stays one
-        // directory that can be diffed against upstream (MEEP3 §4.1)
+        // directory that can be diffed against upstream (../../../SHADE_ORIGIN.md)
         const asset_url = (name) => new URL(`../assets/textures/${name}`, import.meta.url).href;
 
         const [

package/src/shade/renderer/animation/GPUAnimationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AA6HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAyMI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA4ElB;IA8ED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAyDlB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAkChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA2ChB;IA0FD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kDAFW,MAAM,QAgChB;IA+FD,gBAYC;;CACJ;4BAttD2B,gCAAgC"}
+{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AA4HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAyMI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA4ElB;IA8ED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAyDlB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAkChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA2ChB;IA0FD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kDAFW,MAAM,QAgChB;IA8FD,gBAYC;;CACJ;4BArtD2B,gCAAgC"}

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

@@ -1,6 +1,5 @@
 import { assert } from "../../../core/assert.js";
 import { FrameGraph } from "../../../engine/graphics/render/frame_graph/FrameGraph.js";
-import { f32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
 import {
     graph_scene_update_transform_hierarchy
@@ -1663,12 +1662,11 @@ export class GPUAnimationManager {
             .get('animation_clips')
             .dispatch_group_count(ANIMATION_TICK_WORKGROUP_SIZE);
         if (tick_groups > 0) {
-            const dt_buffer = cmd_ctx.allocateTransientValueBuffer(f32, dt);
             shader_animation_tick.dispatch({
                 encoder: cmd_ctx,
                 group_count_x: tick_groups,
                 bindings: {
-                    dt: dt_buffer,
+                    dt,
                     animation_database: this.#database.buffer,
                 },
             });

package/src/shade/renderer/animation/pose/PosePlayback.d.ts

@@ -5,7 +5,8 @@
  * Gameplay poses — a socket, an effect anchor, the muzzle a projectile leaves from — are a **pure
  * function of (clip set, time, weights)**, evaluated on demand at query time. They are never read
  * back from the GPU: readback is asynchronous and a frame late, which would make a projectile's
- * origin depend on frame pacing and poison determinism and replay (`EXECUTION.md` I-4).
+ * origin depend on frame pacing and poison determinism and replay — no GPU readback on a
+ * gameplay-affecting path.
  */
 export class PosePlayback {
     /**

package/src/shade/renderer/animation/pose/PosePlayback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PosePlayback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/pose/PosePlayback.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IAwBI;;;;;OAKG;IACH,4CAJW,MAAM,UACN,MAAM,GACJ,YAAY,CAcxB;IAzCD;;OAEG;IACH,yBAAY;IAEZ;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;OAQG;IACH,QAFU,MAAM,CAEL;CAqBd"}
+{"version":3,"file":"PosePlayback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/pose/PosePlayback.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IAwBI;;;;;OAKG;IACH,4CAJW,MAAM,UACN,MAAM,GACJ,YAAY,CAcxB;IAzCD;;OAEG;IACH,yBAAY;IAEZ;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;OAQG;IACH,QAFU,MAAM,CAEL;CAqBd"}

package/src/shade/renderer/animation/pose/PosePlayback.js

@@ -7,7 +7,8 @@ import { assert } from "../../../../core/assert.js";
  * Gameplay poses — a socket, an effect anchor, the muzzle a projectile leaves from — are a **pure
  * function of (clip set, time, weights)**, evaluated on demand at query time. They are never read
  * back from the GPU: readback is asynchronous and a frame late, which would make a projectile's
- * origin depend on frame pacing and poison determinism and replay (`EXECUTION.md` I-4).
+ * origin depend on frame pacing and poison determinism and replay — no GPU readback on a
+ * gameplay-affecting path.
  */
 export class PosePlayback {
     /**

package/src/shade/renderer/animation/shader_animation_apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_animation_apply.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/shader_animation_apply.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,gCAAiC;AAoFjC;;;;;;;;;;;;;;;;;;GAkBG;AACH,mDAKG;8BA3H2B,4BAA4B"}
+{"version":3,"file":"shader_animation_apply.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/shader_animation_apply.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,gCAAiC;AAoFjC;;;;;;;;;;;;;;;;;;GAkBG;AACH,mDAIG;8BA1H2B,4BAA4B"}