@woosh/meep-engine 3.23.0 → 3.25.0

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

@@ -0,0 +1,372 @@
+import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import { GPUDatabase } from "../../renderer/buffer/table/GPUDatabase.js";
+import { GPUDatabaseDefinition } from "../../renderer/buffer/table/GPUDatabaseDefinition.js";
+import { GPUDatabaseReadback } from "../../renderer/buffer/table/GPUDatabaseReadback.js";
+import { GraphicsContext } from "../../renderer/GraphicsContext.js";
+import { mat4x4f, vec4f } from "../../renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../renderer/shader/type/WebGPUStruct.js";
+
+/**
+ * The shape the decision is about: `NODE3D_STRUCT`'s 176 bytes, of which a world matrix is 64. The
+ * batch reads 64 of the 176, because packing a range rather than a record is what makes a gather
+ * worth encoding at all.
+ */
+const ROW = WebGPUStruct.from({
+    global: mat4x4f,
+    prev_global: mat4x4f,
+    local_translation: vec4f,
+    local_rotation: vec4f,
+    local_scale: vec4f,
+}, "BenchRow");
+
+const SIZES = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512];
+
+/**
+ * Batches per timed block, and blocks per point.
+ *
+ * **A block, rather than a batch, because the browser's clock is deliberately blunt.** Chrome
+ * coarsens `performance.now()` to 100 µs outside a cross-origin-isolated context, and one batch of
+ * this costs single-digit microseconds — timed one at a time, every sample reads as exactly zero.
+ * A block of a hundred is milliseconds, where a 100 µs quantum is a rounding error.
+ *
+ * @type {number}
+ */
+const BLOCK = 100;
+
+const BLOCKS = 5;
+
+const ROW_COUNT = 1024;
+
+const MATRIX_BYTES = 64;
+
+/**
+ * @param {string} id
+ * @returns {HTMLElement}
+ */
+function element(id) {
+    return document.getElementById(id);
+}
+
+/**
+ * @param {string} text
+ * @param {string} [kind]
+ */
+function set_status(text, kind = '') {
+    const node = element('status');
+
+    node.textContent = text;
+    node.className = kind;
+}
+
+/**
+ * Least-squares fit of `y = fixed + marginal * x`.
+ *
+ * @param {number[]} xs
+ * @param {number[]} ys
+ * @returns {{fixed: number, marginal: number}}
+ */
+function fit(xs, ys) {
+    const n = xs.length;
+
+    let sum_x = 0;
+    let sum_y = 0;
+    let sum_xy = 0;
+    let sum_xx = 0;
+
+    for (let i = 0; i < n; i++) {
+        sum_x += xs[i];
+        sum_y += ys[i];
+        sum_xy += xs[i] * ys[i];
+        sum_xx += xs[i] * xs[i];
+    }
+
+    const marginal = (n * sum_xy - sum_x * sum_y) / (n * sum_xx - sum_x * sum_x);
+
+    return { fixed: (sum_y - marginal * sum_x) / n, marginal };
+}
+
+/**
+ * A database of 176-byte rows over enough 4 KiB pages that the rows of a batch really are scattered.
+ *
+ * @param {GPUDevice} device
+ * @param {GraphicsContext} graphics
+ * @returns {{db: GPUDatabase, rows: number[]}}
+ */
+function build_database(device, graphics) {
+    const db = new GPUDatabase({
+        definition: new GPUDatabaseDefinition({ rows: ROW }, 4096),
+        device,
+    });
+
+    const table = db.get('rows');
+
+    const identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+    const rows = [];
+
+    for (let i = 0; i < ROW_COUNT; i++) {
+        rows.push(table.add({
+            global: identity,
+            prev_global: identity,
+            local_translation: [i, 0, 0, 1],
+            local_rotation: [0, 0, 0, 1],
+            local_scale: [1, 1, 1, 0],
+        }));
+    }
+
+    const cmd = ShadeGPUCommandContext.create(graphics, 'readback_crossover/publish');
+
+    db.update(cmd);
+    cmd.finish();
+
+    return { db, rows };
+}
+
+/**
+ * Microseconds of CPU to ask for and encode one batch of `size` rows on one path — the best of
+ * {@link BLOCKS} blocks, each averaged over {@link BLOCK} batches.
+ *
+ * Command contexts are created and finished outside the timed region, because creating one is the
+ * same work on both paths and finishing one submits. `request` is inside it, and harmlessly: it
+ * costs the same per row on both paths, so it raises both slopes by the same amount and leaves the
+ * crossover exactly where it was.
+ *
+ * @param {GPUDevice} device
+ * @param {GraphicsContext} graphics
+ * @param {number} size
+ * @param {boolean} gather
+ * @returns {number} microseconds per batch
+ */
+function measure(device, graphics, size, gather) {
+    const { db, rows } = build_database(device, graphics);
+
+    const readback = new GPUDatabaseReadback({
+        database: db,
+        device,
+        // nothing is applied here, so every batch stays in flight: room for all of them, so the
+        // measurement never times a refusal
+        max_in_flight: BLOCK * BLOCKS + 1,
+        gather_threshold: gather ? 0 : Number.MAX_SAFE_INTEGER,
+    });
+
+    const rows_table = readback.table('rows');
+    const target = new Uint8Array(size * MATRIX_BYTES);
+
+    const contexts = new Array(BLOCK);
+    const samples = [];
+
+    let counter = 0;
+
+    for (let block = 0; block < BLOCKS; block++) {
+        for (let i = 0; i < BLOCK; i++) {
+            contexts[i] = ShadeGPUCommandContext.create(graphics, 'readback_crossover/encode');
+        }
+
+        const start = performance.now();
+
+        for (let i = 0; i < BLOCK; i++) {
+            for (let j = 0; j < size; j++) {
+                // stride through the table so consecutive requests are not consecutive rows
+                readback.request(rows_table, rows[(j * 7 + counter) % rows.length], 0, MATRIX_BYTES, target, j * MATRIX_BYTES);
+            }
+
+            readback.encode(contexts[i]);
+
+            counter++;
+        }
+
+        const end = performance.now();
+
+        for (let i = 0; i < BLOCK; i++) {
+            contexts[i].finish();
+        }
+
+        samples.push((end - start) * 1000 / BLOCK);
+    }
+
+    readback.destroy();
+    db.destroy();
+
+    // the best block, not the median of them: a block the scheduler interrupted measures the
+    // interruption, and no block can be faster than the work actually takes
+    return Math.min(...samples);
+}
+
+/**
+ * Microseconds of wall clock per batch for the whole round trip: encode, submit, and wait for the
+ * device to finish.
+ *
+ * The encode measurement above is only the CPU's half. A direct path submits one copy command per
+ * row and the gather submits a dispatch and one copy, and what those cost the driver and the device
+ * is not visible from the encode at all. This is the crude version of that question — no timestamp
+ * queries, just how long the work takes to be done — and it is crude on purpose: the quantity that
+ * decides the threshold is the wall time a frame loses, not the occupancy of a copy engine.
+ *
+ * @param {GPUDevice} device
+ * @param {GraphicsContext} graphics
+ * @param {number} size
+ * @param {boolean} gather
+ * @returns {Promise<number>} microseconds per batch
+ */
+async function measure_round_trip(device, graphics, size, gather) {
+    const { db, rows } = build_database(device, graphics);
+
+    const readback = new GPUDatabaseReadback({
+        database: db,
+        device,
+        max_in_flight: BLOCK * BLOCKS + 1,
+        gather_threshold: gather ? 0 : Number.MAX_SAFE_INTEGER,
+    });
+
+    const rows_table = readback.table('rows');
+    const target = new Uint8Array(size * MATRIX_BYTES);
+
+    const samples = [];
+
+    let counter = 0;
+
+    for (let block = 0; block < BLOCKS; block++) {
+        await device.queue.onSubmittedWorkDone();
+
+        const start = performance.now();
+
+        for (let i = 0; i < BLOCK; i++) {
+            for (let j = 0; j < size; j++) {
+                readback.request(rows_table, rows[(j * 7 + counter) % rows.length], 0, MATRIX_BYTES, target, j * MATRIX_BYTES);
+            }
+
+            const cmd = ShadeGPUCommandContext.create(graphics, 'readback_crossover/round_trip');
+
+            readback.encode(cmd);
+
+            cmd.finish();
+
+            counter++;
+        }
+
+        await device.queue.onSubmittedWorkDone();
+
+        const end = performance.now();
+
+        samples.push((end - start) * 1000 / BLOCK);
+    }
+
+    readback.destroy();
+    db.destroy();
+
+    return Math.min(...samples);
+}
+
+async function main() {
+    if (navigator.gpu === undefined) {
+        set_status('no WebGPU in this browser', 'fail');
+
+        return;
+    }
+
+    const adapter = await navigator.gpu.requestAdapter();
+
+    if (adapter === null) {
+        set_status('no WebGPU adapter', 'fail');
+
+        return;
+    }
+
+    const device = await adapter.requestDevice();
+
+    element('device').textContent = `${adapter.info?.vendor ?? '?'} ${adapter.info?.architecture ?? ''} ${adapter.info?.description ?? ''}`;
+
+    const graphics = new GraphicsContext(device);
+
+    device.addEventListener('uncapturederror', event => {
+        set_status(`device error: ${event.error.message}`, 'fail');
+    });
+
+    set_status('warming up…');
+
+    // The first dispatch a page encodes pays for compiling everything that encodes it — pipeline,
+    // layouts, the JIT's view of the whole path. Without this the size measured first carries that
+    // cost, which reads as a fixed cost that falls with batch size.
+    for (const size of [1, 16, 128]) {
+        measure(device, graphics, size, false);
+        measure(device, graphics, size, true);
+    }
+
+    set_status('measuring…');
+
+    // wait a frame so the warm-up's submissions are not still landing while the first size is timed
+    await new Promise(resolve => requestAnimationFrame(resolve));
+
+    const descending = SIZES.slice().reverse();
+
+    // Two passes, the second walking the sizes the other way, taking the smaller of each pair: any
+    // residual drift correlates with size in opposite directions in the two.
+    const copies_up = SIZES.map(size => measure(device, graphics, size, false));
+    const gathers_up = SIZES.map(size => measure(device, graphics, size, true));
+    const gathers_down = descending.map(size => measure(device, graphics, size, true)).reverse();
+    const copies_down = descending.map(size => measure(device, graphics, size, false)).reverse();
+
+    const copies = SIZES.map((_, i) => Math.min(copies_up[i], copies_down[i]));
+    const gathers = SIZES.map((_, i) => Math.min(gathers_up[i], gathers_down[i]));
+
+    const copy_fit = fit(SIZES, copies);
+    const gather_fit = fit(SIZES, gathers);
+
+    const crossover = (gather_fit.fixed - copy_fit.fixed) / (copy_fit.marginal - gather_fit.marginal);
+
+    set_status('measuring round trips…');
+
+    const round_trip_copies = [];
+    const round_trip_gathers = [];
+
+    for (const size of SIZES) {
+        round_trip_copies.push(await measure_round_trip(device, graphics, size, false));
+        round_trip_gathers.push(await measure_round_trip(device, graphics, size, true));
+    }
+
+    const rt_copy_fit = fit(SIZES, round_trip_copies);
+    const rt_gather_fit = fit(SIZES, round_trip_gathers);
+
+    const rt_crossover = (rt_gather_fit.fixed - rt_copy_fit.fixed) / (rt_copy_fit.marginal - rt_gather_fit.marginal);
+
+    const table = element('results');
+
+    table.innerHTML = '<tr><th>rows</th><th>encode copies</th><th>encode gather</th><th>round trip copies</th><th>round trip gather</th></tr>'
+        + SIZES.map((size, i) => `<tr><td>${size}</td><td>${copies[i].toFixed(2)}</td><td>${gathers[i].toFixed(2)}</td><td>${round_trip_copies[i].toFixed(2)}</td><td>${round_trip_gathers[i].toFixed(2)}</td></tr>`).join('');
+
+    const summary = [
+        'encode only, µs per batch',
+        `  copies: ${copy_fit.fixed.toFixed(2)} + ${copy_fit.marginal.toFixed(3)} per row`,
+        `  gather: ${gather_fit.fixed.toFixed(2)} + ${gather_fit.marginal.toFixed(3)} per row`,
+        `  crossover: ${crossover.toFixed(1)} rows`,
+        '',
+        'encode + submit + work done, µs per batch',
+        `  copies: ${rt_copy_fit.fixed.toFixed(2)} + ${rt_copy_fit.marginal.toFixed(3)} per row`,
+        `  gather: ${rt_gather_fit.fixed.toFixed(2)} + ${rt_gather_fit.marginal.toFixed(3)} per row`,
+        `  crossover: ${rt_crossover.toFixed(1)} rows`,
+    ].join('\n');
+
+    element('summary').textContent = summary;
+
+    set_status(`done — best of ${BLOCKS} blocks of ${BLOCK} batches per point`, 'ok');
+
+    globalThis.__READBACK_CROSSOVER = {
+        adapter: element('device').textContent,
+        sizes: SIZES,
+        copies,
+        gathers,
+        copy_fit,
+        gather_fit,
+        crossover,
+        round_trip_copies,
+        round_trip_gathers,
+        rt_copy_fit,
+        rt_gather_fit,
+        rt_crossover,
+    };
+}
+
+main().catch(error => {
+    set_status(`${error}`, 'fail');
+
+    globalThis.__READBACK_CROSSOVER = { error: `${error}` };
+});

package/src/shade/playground/skinned_blas_refit/README.md

@@ -71,6 +71,10 @@ union, and each clone at its own arena address on a uniform stride.
 
 ## What the floor disagreement turned out to be
 
+The floor is a primitive at an entity's row now — `add_floor` places it with `place_primitive`, and
+one transform writes both of its rows — so what follows cannot recur. It is kept because the
+reasoning is still worth having.
+
 For a while the two images disagreed about where the floor ends: a smooth band along its far edge
 that the rasterizer drew and the tracer did not, several thousand pixels at an ordinary camera and
 growing as the camera approached the edge. It read like a hole in a tree, and it was not one.
@@ -111,16 +115,16 @@ mesh.global × inverse(mesh.global) × joint.global × inverse_bind × v
 ```
 
 — `chunk_skin_blend_mesh_local` folds the leftmost inverse into each joint matrix and the rasterizer
-re-applies `mesh.global`, so the mesh node's transform **cancels exactly**, and
-`compute_skin_world_bounds` composes the published box out of joints without reading it either.
+re-applies `mesh.global`, so the mesh node's transform **cancels exactly**, and the published box is
+refreshed on the GPU from the deformed vertices without reading it either.
 Michelle's file makes the point structurally: her mesh node `Ch03` carries no local transform, the
 0.01 centimetre scale and the up-axis rotation sit on the root above it, and the joint root
 `mixamorig:Hips` is the mesh node's *sibling*. Nothing under `Ch03` drives a joint.
 
-`place_character` therefore hangs each character's roots under a fresh parent whose whole transform
-is the grid offset. That reaches the joints, leaves the file's own transform untouched below it, and
-— because the offset is a *local* transform — survives the walk that recomputes `transform_global`.
+`place_character` therefore spawns each character as a prefab instance under a placement entity
+whose whole transform is the grid offset. That reaches the joints — every one an entity whose row
+the GPU composes under its parent's — and leaves the file's own transform where the prefab put it.
 
 `place_character.spec.js` holds the invariant the floor's cannot see: **published bounds must move
-by the offset the character was placed at.** Its negative control is the bug itself — writing either
-transform on the mesh node and watching the box not move.
+by the offset the character was placed at**, and it holds it on the rows themselves: which row
+hangs under which, and the box the mesh row carries.

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

@@ -1,47 +1,16 @@
 /**
- * A floor, so the traced image has something for the character to cast onto.
- *
- * Shadows are the loudest reading of a stale BLAS: a body in the wrong pose still shades roughly
- * like a body, but the shadow it throws is unmistakably a different shape from the one standing
- * over it.
- *
- * ## Where it is placed, and why that is the whole of it
- *
- * The slab is placed by its **local** transform. `Node3D.transform_global` is derived — the doc
- * comment on it says so — and the two consumers of a mesh's placement take it from opposite ends:
- *
- * - `Mesh.updateBoundsBasic` reads `transform_global`, and its result is the box published to the
- *   `meshes` table, which is the TLAS leaf the path tracer tests a ray against before it reaches
- *   any triangle;
- * - the GPU's `transforms` row carries the node's local TRS, and the hierarchy pass composes
- *   `node.global` from it — which is the matrix *both* the rasterizer's vertex stage and the ray
- *   query's geometry-space transform use.
- *
- * Setting `transform_global` and nothing else satisfies the first and leaves the second at
- * identity, which is exactly what this function used to do. The result is a mesh whose published
- * box is around one place and whose geometry is drawn in another, 0.208 m apart here:
- *
- * - the **rasterizer** drew the slab at the geometry's own origin, its far edge ten rows higher up
- *   the screen than the floor actually ends;
- * - the **path tracer** tested each ray against the translated box first and only then traversed
- *   the untranslated geometry, so rays that would have struck the slab near its far edge were
- *   turned away by a box that was not around it — a smooth band of floor the rasterizer drew and
- *   the tracer did not, growing as the camera approached the edge.
- *
- * Neither renderer was wrong about the data it was given; the two halves of the record disagreed.
- * Padding the published box (the old `?inflate=1` handle) shrank the band because it widened the
- * interval the TLAS test allows — which is why a 5% pad did what a 1e-5 rounding slack could not,
- * and it was never evidence of tangency.
- *
- * The invariant that catches this without a GPU or a picture: a mesh's published bounds must
- * survive `updateMatrices`, because that is the walk which recomputes `transform_global` from the
- * local transform. `add_floor.spec.js` holds it to that.
- *
- * @param {Scene} scene
- * @param {number} extent width of the slab
- * @param {number} top world height its upper face sits at
- * @returns {Mesh}
+ * @typedef {import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ */
+/**
+ * A slab for the dancers to stand on: a box `extent` wide and deep, its upper face at `top`, at a
+ * row of the scene. The box the renderer culls and traces it by is the GPU's to derive from the
+ * geometry under the row's transform — this side writes the placement, and nothing else.
+ *
+ * @param {GPUSceneContext} scene_context the scene's context — its rows are where the floor goes
+ * @param {number} extent edge length of the slab
+ * @param {number} top the `y` of its upper face
+ * @returns {number} the floor's entity
  */
-export function add_floor(scene: Scene, extent: number, top: number): Mesh;
-import { Mesh } from "../../renderer/scene/Mesh.js";
+export function add_floor(scene_context: GPUSceneContext, extent: number, top: number): number;
+export type GPUSceneContext = import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext;
 //# sourceMappingURL=add_floor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"add_floor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/add_floor.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,gDAJW,MAAM,OACN,MAAM,GACJ,IAAI,CAwBhB;qBApEoB,8BAA8B"}
+{"version":3,"file":"add_floor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/add_floor.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;;;;;;;GASG;AACH,yCALW,eAAe,UACf,MAAM,OACN,MAAM,GACJ,MAAM,CAalB;8BAxBY,OAAO,yCAAyC,EAAE,eAAe"}

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

@@ -1,71 +1,31 @@
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
 import { BoxGeometry } from "../../renderer/geometry/BoxGeometry.js";
 import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
-import { Mesh } from "../../renderer/scene/Mesh.js";
+import { place_primitive } from "../../renderer/scene/rows/place_primitive.js";
 
 /**
- * A floor, so the traced image has something for the character to cast onto.
- *
- * Shadows are the loudest reading of a stale BLAS: a body in the wrong pose still shades roughly
- * like a body, but the shadow it throws is unmistakably a different shape from the one standing
- * over it.
- *
- * ## Where it is placed, and why that is the whole of it
- *
- * The slab is placed by its **local** transform. `Node3D.transform_global` is derived — the doc
- * comment on it says so — and the two consumers of a mesh's placement take it from opposite ends:
- *
- * - `Mesh.updateBoundsBasic` reads `transform_global`, and its result is the box published to the
- *   `meshes` table, which is the TLAS leaf the path tracer tests a ray against before it reaches
- *   any triangle;
- * - the GPU's `transforms` row carries the node's local TRS, and the hierarchy pass composes
- *   `node.global` from it — which is the matrix *both* the rasterizer's vertex stage and the ray
- *   query's geometry-space transform use.
- *
- * Setting `transform_global` and nothing else satisfies the first and leaves the second at
- * identity, which is exactly what this function used to do. The result is a mesh whose published
- * box is around one place and whose geometry is drawn in another, 0.208 m apart here:
- *
- * - the **rasterizer** drew the slab at the geometry's own origin, its far edge ten rows higher up
- *   the screen than the floor actually ends;
- * - the **path tracer** tested each ray against the translated box first and only then traversed
- *   the untranslated geometry, so rays that would have struck the slab near its far edge were
- *   turned away by a box that was not around it — a smooth band of floor the rasterizer drew and
- *   the tracer did not, growing as the camera approached the edge.
- *
- * Neither renderer was wrong about the data it was given; the two halves of the record disagreed.
- * Padding the published box (the old `?inflate=1` handle) shrank the band because it widened the
- * interval the TLAS test allows — which is why a 5% pad did what a 1e-5 rounding slack could not,
- * and it was never evidence of tangency.
- *
- * The invariant that catches this without a GPU or a picture: a mesh's published bounds must
- * survive `updateMatrices`, because that is the walk which recomputes `transform_global` from the
- * local transform. `add_floor.spec.js` holds it to that.
- *
- * @param {Scene} scene
- * @param {number} extent width of the slab
- * @param {number} top world height its upper face sits at
- * @returns {Mesh}
+ * @typedef {import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
  */
-export function add_floor(scene, extent, top) {
-    const thickness = extent * 0.02;
 
-    const floor = new Mesh();
+/**
+ * A slab for the dancers to stand on: a box `extent` wide and deep, its upper face at `top`, at a
+ * row of the scene. The box the renderer culls and traces it by is the GPU's to derive from the
+ * geometry under the row's transform — this side writes the placement, and nothing else.
+ *
+ * @param {GPUSceneContext} scene_context the scene's context — its rows are where the floor goes
+ * @param {number} extent edge length of the slab
+ * @param {number} top the `y` of its upper face
+ * @returns {number} the floor's entity
+ */
+export function add_floor(scene_context, extent, top) {
+    const thickness = extent * 0.02;
 
-    floor.geometry = new BoxGeometry(extent, thickness, extent);
-    floor.material = new StandardShadeMaterial();
+    const transform = new Transform64();
 
     // `Transform64` keeps its matrix by hand: setting a component leaves the matrix holding what it
     // held before, so the write is only real after `updateMatrix`.
-    floor.transform_local.setTranslation(0, top - thickness * 0.5, 0);
-    floor.transform_local.updateMatrix();
-
-    // Derive `transform_global` from the local transform, and the world bounds from that. Nothing
-    // else will: the scene's pre-order walk updates bounds for nodes it visits as part of a
-    // hierarchy, and a mesh added on its own is never visited that way — so the row it seeds the
-    // `meshes` table with would stay the default, which is a zero-sized box at the origin.
-    floor.updateMatrices();
-
-    scene.add(floor);
+    transform.setTranslation(0, top - thickness * 0.5, 0);
+    transform.updateMatrix();
 
-    return floor;
+    return place_primitive(scene_context, new BoxGeometry(extent, thickness, extent), new StandardShadeMaterial(), transform, { name: 'floor' });
 }

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/main.js"],"names":[],"mappings":"AA4QA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAqjBzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/main.js"],"names":[],"mappings":"AAwQA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAkkBzB"}