@woosh/meep-engine 3.17.2 → 3.18.0

package/src/engine/asset/loaders/gltf_test_fixtures.js

@@ -1,359 +0,0 @@
-/**
- * Shared inline glTF fixtures for the loader test suites — one triangle, in both of the containers
- * the format ships in. Test-only; not imported by production code.
- *
- * The point of authoring the bytes here rather than checking a model in is that every field a loader
- * reads is visible in one place: change the accessor and the test that depends on it says so.
- */
-
-import { encode_meshopt_attributes } from "../../../core/binary/meshopt/__meshopt_test_streams.js";
-import { align_4 } from "../../../core/binary/align_4.js";
-
-export const GLTF_FIXTURE_NODE_NAME = 'unit_root';
-export const GLTF_FIXTURE_MESH_NAME = 'unit_body';
-
-/**
- * Byte length of what {@link build_triangle_bin} produces — three positions, three normals, three
- * texture coordinates and three indices, laid out back to back.
- * @type {number}
- */
-export const GLTF_FIXTURE_BIN_BYTE_LENGTH = 102;
-
-/**
- * @returns {ArrayBuffer}
- */
-export function build_triangle_bin() {
-    const buffer = new ArrayBuffer(GLTF_FIXTURE_BIN_BYTE_LENGTH);
-
-    new Float32Array(buffer, 0, 9).set([0, 0, 0, 1, 0, 0, 0, 1, 0]);
-    new Float32Array(buffer, 36, 9).set([0, 0, 1, 0, 0, 1, 0, 0, 1]);
-    new Float32Array(buffer, 72, 6).set([0, 0, 1, 0, 0, 1]);
-    new Uint16Array(buffer, 96, 3).set([0, 1, 2]);
-
-    return buffer;
-}
-
-/**
- * @param {string|undefined} buffer_uri `undefined` for a .glb, whose buffer is the binary chunk
- * @returns {object}
- */
-export function build_triangle_gltf_json(buffer_uri) {
-    return {
-        asset: { version: '2.0' },
-        scene: 0,
-        scenes: [{ nodes: [0] }],
-        nodes: [{ name: GLTF_FIXTURE_NODE_NAME, mesh: 0 }],
-        meshes: [{
-            name: GLTF_FIXTURE_MESH_NAME,
-            primitives: [{ attributes: { POSITION: 0, NORMAL: 1, TEXCOORD_0: 2 }, indices: 3 }]
-        }],
-        accessors: [
-            {
-                bufferView: 0, componentType: 5126, count: 3, type: 'VEC3',
-                min: [0, 0, 0], max: [1, 1, 0]
-            },
-            { bufferView: 1, componentType: 5126, count: 3, type: 'VEC3' },
-            { bufferView: 2, componentType: 5126, count: 3, type: 'VEC2' },
-            { bufferView: 3, componentType: 5123, count: 3, type: 'SCALAR' }
-        ],
-        bufferViews: [
-            { buffer: 0, byteOffset: 0, byteLength: 36 },
-            { buffer: 0, byteOffset: 36, byteLength: 36 },
-            { buffer: 0, byteOffset: 72, byteLength: 24 },
-            { buffer: 0, byteOffset: 96, byteLength: 6 }
-        ],
-        buffers: [buffer_uri === undefined
-            ? { byteLength: GLTF_FIXTURE_BIN_BYTE_LENGTH }
-            : { uri: buffer_uri, byteLength: GLTF_FIXTURE_BIN_BYTE_LENGTH }]
-    };
-}
-
-/**
- * The same model with a base-colour texture on it, so that a test can watch what an image costs.
- *
- * The texture names its image the way the game's own models do — a `source` index into `images`,
- * whose entry carries a relative `uri` — because that is the shape {@link gltf_used_image_indices}
- * decides against a DDS sibling with, and the one whose bytes have to come from somewhere.
- *
- * @param {string} buffer_uri
- * @param {string} image_uri
- * @returns {object}
- */
-export function build_textured_triangle_gltf_json(buffer_uri, image_uri) {
-    const json = build_triangle_gltf_json(buffer_uri);
-
-    json.meshes[0].primitives[0].material = 0;
-
-    json.materials = [{
-        name: 'unit_skin',
-        pbrMetallicRoughness: { baseColorTexture: { index: 0 } }
-    }];
-
-    json.textures = [{ source: 0, sampler: 0 }];
-    json.samplers = [{}];
-    json.images = [{ uri: image_uri, mimeType: 'image/png' }];
-
-    return json;
-}
-
-/**
- * The same model as a .glb — the JSON chunk followed by the binary one.
- *
- * @returns {ArrayBuffer}
- */
-export function build_triangle_glb() {
-    const json_bytes = new TextEncoder().encode(JSON.stringify(build_triangle_gltf_json(undefined)));
-
-    // both chunks are padded to a four byte boundary, per the container's own rule
-    const json_length = align_4(json_bytes.byteLength);
-
-    const bin = new Uint8Array(build_triangle_bin());
-    const bin_length = align_4(bin.byteLength);
-
-    const total = 12 + 8 + json_length + 8 + bin_length;
-
-    const glb = new ArrayBuffer(total);
-    const view = new DataView(glb);
-    const bytes = new Uint8Array(glb);
-
-    view.setUint32(0, 0x46546C67, true);
-    view.setUint32(4, 2, true);
-    view.setUint32(8, total, true);
-
-    view.setUint32(12, json_length, true);
-    view.setUint32(16, 0x4E4F534A, true);
-    bytes.set(json_bytes, 20);
-    bytes.fill(0x20, 20 + json_bytes.byteLength, 20 + json_length);
-
-    const bin_header = 20 + json_length;
-
-    view.setUint32(bin_header, bin_length, true);
-    view.setUint32(bin_header + 4, 0x004E4942, true);
-    bytes.set(bin, bin_header + 8);
-
-    return glb;
-}
-
-/*
- The same triangle, compressed. Both meshopt extensions are bufferView extensions, so the model is
- unchanged above the bufferViews: same nodes, same mesh, same accessors, same uncompressed layout
- declared on the parent views. What differs is where the bytes come from.
-*/
-
-/**
- * Byte length of the placeholder the compressed views point at. It has to be big enough to hold
- * every uncompressed view referencing it, which is the same 102 bytes {@link build_triangle_bin}
- * lays out.
- * @type {number}
- */
-export const GLTF_FIXTURE_FALLBACK_BYTE_LENGTH = GLTF_FIXTURE_BIN_BYTE_LENGTH;
-
-/**
- * YCoCg colour for the three vertices, as the `COLOR` filter takes it: luma, the two chroma
- * differences (signed), and an alpha whose most significant set bit declares the precision.
- * @type {number[]}
- */
-const GLTF_FIXTURE_YCOCG = [
-    100, 50, -20 & 0xff, 0xff,
-    200, 0, 0, 0xff,
-    60, -30 & 0xff, 10, 0xc0
-];
-
-/**
- * What those decode to: R = Y + Co - Cg, G = Y + Cg, B = Y - Co - Cg, with alpha widened by the bit
- * its marker cost it.
- * @type {number[]}
- */
-export const GLTF_FIXTURE_COLOURS = [
-    170, 80, 70, 255,
-    200, 200, 200, 255,
-    20, 70, 80, 128
-];
-
-/**
- * The compressed streams, laid out back to back.
- *
- * Positions, normals and texture coordinates go through the attribute codec; the indices are a
- * hand-written triangle stream, because writing a triangle encoder to test a triangle decoder with
- * would prove nothing. `0xf0` reads entry 0 of the lookup table, which is `0x00` - three fresh
- * vertices, which is exactly (0, 1, 2).
- *
- * At `codec_version` 1 the attribute streams carry a channel mode each - a rotated exclusive-or for
- * the positions, plain byte deltas for the normals, 16-bit deltas for the texture coordinates - and
- * with `colour` there is a `COLOR`-filtered stream too. Either makes a file that only
- * `KHR_meshopt_compression` defines, and that the vendor extension refuses.
- *
- * @param {Object} [options]
- * @param {number} [options.codec_version] 0 or 1
- * @param {boolean} [options.colour] append a `COLOR_0` stream carrying the `COLOR` filter
- * @returns {{buffer: ArrayBuffer, ranges: {byteOffset:number, byteLength:number}[]}}
- */
-export function build_meshopt_triangle_bin({ codec_version = 0, colour = false } = {}) {
-    const bin = build_triangle_bin();
-
-    /**
-     * @param {number[]} modes
-     * @returns {Object}
-     */
-    const attributes = (modes) => codec_version === 1
-        ? { version: 1, channel_modes: modes }
-        : { version: 0 };
-
-    const streams = [
-        encode_meshopt_attributes(new Uint8Array(bin, 0, 36), 3, 12, attributes([
-            2 | (5 << 4), 2 | (5 << 4), 2 | (5 << 4)
-        ])),
-        encode_meshopt_attributes(new Uint8Array(bin, 36, 36), 3, 12, attributes([0, 0, 0])),
-        encode_meshopt_attributes(new Uint8Array(bin, 72, 24), 3, 8, attributes([1, 1])),
-        new Uint8Array([0xe1, 0xf0, ...new Array(16).fill(0)])
-    ];
-
-    if (colour) {
-        streams.push(encode_meshopt_attributes(new Uint8Array(GLTF_FIXTURE_YCOCG), 3, 4, attributes([0])));
-    }
-
-    const total = streams.reduce((sum, stream) => sum + stream.length, 0);
-
-    const bytes = new Uint8Array(total);
-
-    const ranges = [];
-
-    let byteOffset = 0;
-
-    for (const stream of streams) {
-        bytes.set(stream, byteOffset);
-
-        ranges.push({ byteOffset, byteLength: stream.length });
-
-        byteOffset += stream.length;
-    }
-
-    return { buffer: bytes.buffer, ranges };
-}
-
-/**
- * @param {string} extension_name `EXT_meshopt_compression` or `KHR_meshopt_compression`
- * @param {string|undefined} buffer_uri `undefined` for a .glb, whose compressed data is the binary chunk
- * @param {Object} [options] see {@link build_meshopt_triangle_bin}
- * @param {number} [options.codec_version]
- * @param {boolean} [options.colour]
- * @returns {object}
- */
-export function build_meshopt_triangle_gltf_json(extension_name, buffer_uri, options = {}) {
-    const { buffer, ranges } = build_meshopt_triangle_bin(options);
-
-    const json = build_triangle_gltf_json(undefined);
-
-    json.extensionsUsed = [extension_name];
-    json.extensionsRequired = [extension_name];
-
-    /**
-     * @param {number} view the parent view's index
-     * @param {number} byteStride
-     * @param {number} count
-     * @param {string} mode
-     * @returns {object}
-     */
-    function compressed(view, byteStride, count, mode) {
-        return {
-            buffer: 0,
-            byteOffset: ranges[view].byteOffset,
-            byteLength: ranges[view].byteLength,
-            byteStride,
-            count,
-            mode
-        };
-    }
-
-    const shapes = [
-        [12, 3, 'ATTRIBUTES', undefined],
-        [12, 3, 'ATTRIBUTES', undefined],
-        [8, 3, 'ATTRIBUTES', undefined],
-        [2, 3, 'TRIANGLES', undefined]
-    ];
-
-    if (options.colour === true) {
-        // an unsigned normalised VEC4, which is what the COLOR filter decodes to
-        json.bufferViews.push({ buffer: 0, byteOffset: 102, byteLength: 12 });
-
-        json.accessors.push({
-            bufferView: 4, componentType: 5121, count: 3, type: 'VEC4', normalized: true
-        });
-
-        json.meshes[0].primitives[0].attributes.COLOR_0 = 4;
-
-        shapes.push([4, 3, 'ATTRIBUTES', 'COLOR']);
-    }
-
-    json.bufferViews = json.bufferViews.map((view, i) => {
-        const [byteStride, count, mode, filter] = shapes[i];
-
-        return {
-            ...view,
-            // the placeholder, which nothing reads once the views below are decoded
-            buffer: 1,
-            // index views are forbidden a stride by the base format, whatever the extension needs
-            ...(mode === 'ATTRIBUTES' ? { byteStride } : {}),
-            extensions: {
-                [extension_name]: {
-                    ...compressed(i, byteStride, count, mode),
-                    ...(filter === undefined ? {} : { filter })
-                }
-            }
-        };
-    });
-
-    json.buffers = [
-        buffer_uri === undefined
-            ? { byteLength: buffer.byteLength }
-            : { uri: buffer_uri, byteLength: buffer.byteLength },
-        {
-            // big enough for every uncompressed view over it, which is what both specs require
-            byteLength: GLTF_FIXTURE_FALLBACK_BYTE_LENGTH + (options.colour === true ? 12 : 0),
-            extensions: { [extension_name]: { fallback: true } }
-        }
-    ];
-
-    return json;
-}
-
-/**
- * The compressed model as a .glb: the JSON chunk, then the compressed data as the binary one.
- *
- * @param {string} extension_name
- * @param {Object} [options] see {@link build_meshopt_triangle_bin}
- * @returns {ArrayBuffer}
- */
-export function build_meshopt_triangle_glb(extension_name, options = {}) {
-    const json_bytes = new TextEncoder().encode(
-        JSON.stringify(build_meshopt_triangle_gltf_json(extension_name, undefined, options))
-    );
-
-    const json_length = align_4(json_bytes.byteLength);
-
-    const bin = new Uint8Array(build_meshopt_triangle_bin(options).buffer);
-    const bin_length = align_4(bin.byteLength);
-
-    const total = 12 + 8 + json_length + 8 + bin_length;
-
-    const glb = new ArrayBuffer(total);
-    const view = new DataView(glb);
-    const bytes = new Uint8Array(glb);
-
-    view.setUint32(0, 0x46546C67, true);
-    view.setUint32(4, 2, true);
-    view.setUint32(8, total, true);
-
-    view.setUint32(12, json_length, true);
-    view.setUint32(16, 0x4E4F534A, true);
-    bytes.set(json_bytes, 20);
-    bytes.fill(0x20, 20 + json_bytes.byteLength, 20 + json_length);
-
-    const bin_header = 20 + json_length;
-
-    view.setUint32(bin_header, bin_length, true);
-    view.setUint32(bin_header + 4, 0x004E4942, true);
-    bytes.set(bin, bin_header + 8);
-
-    return glb;
-}

package/src/shade/renderer/animation/skin_test_fixtures.d.ts

@@ -1,86 +0,0 @@
-/**
- * A rigged character in one of the two shapes.
- *
- * The rest pose **is** the bind pose, which is what a well-formed file has. The bind matrices are
- * taken off the skeleton itself rather than composed by hand: the fixture walks the hierarchy once
- * with the root's conversion in place and once without, and the two snapshots *are* the two bind
- * spaces. Nothing here can drift from the hierarchy it describes, because it is read from it.
- *
- * The placement node goes on last, after the bind matrices are settled — which is what happens for
- * real, and is what makes "the correction does not depend on where the character stands" a fact this
- * fixture can be asked about rather than an assumption.
- *
- * @param {object} options
- * @param {BindSpace} options.bind_space
- * @param {number} [options.scale] the root's uniform conversion
- * @param {boolean} [options.up_axis_rotation] whether the root also carries the −90° about x that an
- *        FBX-derived file pairs with its conversion. On by default: a correction that handles only
- *        the scale passes without it.
- * @param {number[]} [options.placement] a translation applied above the whole character
- * @returns {{
- *     placement: Node3D,
- *     root: Node3D,
- *     mesh: SkinnedMesh,
- *     skin: Skin,
- *     joints: Node3D[],
- * }}
- */
-export function make_character({ bind_space, scale, up_axis_rotation, placement, }: {
-    bind_space: BindSpace;
-    scale?: number;
-    up_axis_rotation?: boolean;
-    placement?: number[];
-}): {
-    placement: Node3D;
-    root: Node3D;
-    mesh: SkinnedMesh;
-    skin: Skin;
-    joints: Node3D[];
-};
-/**
- * The two shapes a glTF character actually arrives in, built as scene graphs.
- *
- * Both are legal glTF and both are in the wild; the difference is only the space the file's author
- * wrote the inverse-bind matrices in, and it decides whether `inverse(mesh.global) × joint.global ×
- * inverse_bind` — the matrix the skinning pass converts to a dual quaternion — comes out rigid. See
- * `SKINNING_FRAME_PLAN.md`.
- *
- * One hierarchy serves both, because the difference is not in the hierarchy:
- *
- * ```
- * "placement"      added at runtime, above the file's own roots
- * └── "Character"  the file's unit conversion and up-axis rotation
- *     ├── "Mesh"   the skinned mesh, no local transform of its own
- *     └── "Joint0" the joint root — the mesh node's *sibling*, as every rigged glTF has it
- *         └── "Joint1"
- *             └── "Joint2"
- * ```
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-/**
- * What every one of this game's creature models puts on its glTF root node — an FBX unit
- * conversion, uniform, and inherited by the joints and the mesh node alike.
- *
- * @type {number}
- */
-export const EXPORT_SCALE: number;
-/**
- * The centimetre→metre conversion `Michelle.glb` carries on hers.
- *
- * @type {number}
- */
-export const MICHELLE_SCALE: number;
-/**
- * Where the file's author wrote the inverse-bind matrices.
- */
-export type BindSpace = string;
-export namespace BindSpace {
-    let PreScale: string;
-    let World: string;
-}
-import { Node3D } from "../scene/Node3D.js";
-import { SkinnedMesh } from "../scene/SkinnedMesh.js";
-import { Skin } from "./Skin.js";
-//# sourceMappingURL=skin_test_fixtures.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"skin_test_fixtures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/skin_test_fixtures.js"],"names":[],"mappings":"AAsFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAd8B,UAAU,EAA7B,SAAS;IACQ,KAAK,GAAtB,MAAM;IACY,gBAAgB,GAAlC,OAAO;IAGY,SAAS,GAA5B,MAAM,EAAE;;eAED,MAAM;UACX,MAAM;UACN,WAAW;UACX,IAAI;YACF,MAAM,EAAE;EAgFtB;AAjLD;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;GAKG;AACH,2BAFU,MAAM,CAEiB;AAEjC;;;;GAIG;AACH,6BAFU,MAAM,CAEmB;;;;wBAKzB,MAAM;;;;;uBA7CO,oBAAoB;4BACf,yBAAyB;qBAChC,WAAW"}

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

@@ -1,250 +0,0 @@
-import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
-import { platform_compute_endianness } from "../../../core/binary/platform_compute_endianness.js";
-import { m4_invert } from "../../../core/geom/3d/mat4/m4_invert.js";
-import { MeshletGeometry } from "../geometry/MeshletGeometry.js";
-import {
-    MESHLET_METADATA_STRUCT
-} from "../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
-import { StandardShadeMaterial } from "../material/StandardShadeMaterial.js";
-import { write_wgsl_type_value } from "../shader/type/serde/write_gpu_typed_buffer.js";
-import { Node3D } from "../scene/Node3D.js";
-import { SkinnedMesh } from "../scene/SkinnedMesh.js";
-import { Skin } from "./Skin.js";
-
-/**
- * The two shapes a glTF character actually arrives in, built as scene graphs.
- *
- * Both are legal glTF and both are in the wild; the difference is only the space the file's author
- * wrote the inverse-bind matrices in, and it decides whether `inverse(mesh.global) × joint.global ×
- * inverse_bind` — the matrix the skinning pass converts to a dual quaternion — comes out rigid. See
- * `SKINNING_FRAME_PLAN.md`.
- *
- * One hierarchy serves both, because the difference is not in the hierarchy:
- *
- * ```
- * "placement"      added at runtime, above the file's own roots
- * └── "Character"  the file's unit conversion and up-axis rotation
- *     ├── "Mesh"   the skinned mesh, no local transform of its own
- *     └── "Joint0" the joint root — the mesh node's *sibling*, as every rigged glTF has it
- *         └── "Joint1"
- *             └── "Joint2"
- * ```
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-/**
- * What every one of this game's creature models puts on its glTF root node — an FBX unit
- * conversion, uniform, and inherited by the joints and the mesh node alike.
- *
- * @type {number}
- */
-export const EXPORT_SCALE = 0.35;
-
-/**
- * The centimetre→metre conversion `Michelle.glb` carries on hers.
- *
- * @type {number}
- */
-export const MICHELLE_SCALE = 0.01;
-
-/**
- * Where the file's author wrote the inverse-bind matrices.
- *
- * @enum {string}
- */
-export const BindSpace = {
-    /**
-     * Before the root's conversion — the matrices invert the joints' transforms in the mesh's own
-     * pre-conversion space, so `joint.global × inverse_bind` carries the conversion and equals the
-     * mesh node's world transform. This is the arrangement `chunk_skin_blend_mesh_local` was written
-     * for, and the one where the fold cancels.
-     */
-    PreScale: 'pre-scale',
-
-    /**
-     * After it — the matrices invert the joints' world transforms as the file leaves them, so
-     * `joint.global × inverse_bind` is the **identity** and the geometry's positions are already in
-     * converted units. `Michelle.glb` is this shape, and the fold leaves a bare `1 / scale` behind.
-     */
-    World: 'world',
-};
-
-/**
- * Rest offsets down the joint chain, in the space the geometry's positions live in — a hip, a knee
- * and an ankle rather than three copies of the origin, so that a defect which only shows on a joint
- * away from the origin cannot pass.
- *
- * @type {number[][]}
- */
-const REST_OFFSETS = [
-    [0, 1, 0],
-    [0.25, -0.5, 0.1],
-    [-0.1, -0.45, 0],
-];
-
-/**
- * A rigged character in one of the two shapes.
- *
- * The rest pose **is** the bind pose, which is what a well-formed file has. The bind matrices are
- * taken off the skeleton itself rather than composed by hand: the fixture walks the hierarchy once
- * with the root's conversion in place and once without, and the two snapshots *are* the two bind
- * spaces. Nothing here can drift from the hierarchy it describes, because it is read from it.
- *
- * The placement node goes on last, after the bind matrices are settled — which is what happens for
- * real, and is what makes "the correction does not depend on where the character stands" a fact this
- * fixture can be asked about rather than an assumption.
- *
- * @param {object} options
- * @param {BindSpace} options.bind_space
- * @param {number} [options.scale] the root's uniform conversion
- * @param {boolean} [options.up_axis_rotation] whether the root also carries the −90° about x that an
- *        FBX-derived file pairs with its conversion. On by default: a correction that handles only
- *        the scale passes without it.
- * @param {number[]} [options.placement] a translation applied above the whole character
- * @returns {{
- *     placement: Node3D,
- *     root: Node3D,
- *     mesh: SkinnedMesh,
- *     skin: Skin,
- *     joints: Node3D[],
- * }}
- */
-export function make_character({
-                                   bind_space,
-                                   scale = EXPORT_SCALE,
-                                   up_axis_rotation = true,
-                                   placement = [0, 0, 0],
-                               }) {
-
-    const root = new Node3D();
-
-    root.name = 'Character';
-
-    const mesh = new SkinnedMesh();
-
-    mesh.name = 'Mesh';
-    mesh.geometry = make_geometry();
-    mesh.material = new StandardShadeMaterial();
-
-    const joints = REST_OFFSETS.map((offset, i) => {
-        const joint = new Node3D();
-
-        joint.name = `Joint${i}`;
-        joint.transform_local.setTranslation(offset[0], offset[1], offset[2]);
-
-        return joint;
-    });
-
-    for (let i = 1; i < joints.length; i++) {
-        joints[i - 1].addChild(joints[i]);
-    }
-
-    root.addChildren([mesh, joints[0]]);
-
-    /*
-     Pass one: the root at the identity, so the joints stand in the pre-conversion space an exporter
-     writing `PreScale` bind matrices was working in. Pass two adds the conversion, and the joints
-     stand where the file leaves them — the space a `World` exporter inverts.
-    */
-    root.updateMatrices();
-
-    const bind = bind_space === BindSpace.PreScale ? snapshot_joint_globals(joints) : null;
-
-    root.transform_local.setScale(scale, scale, scale);
-
-    if (up_axis_rotation) {
-        // −90° about x, as a quaternion: the Z-up of the file into the renderer's Y-up
-        root.transform_local.setRotation(-Math.SQRT1_2, 0, 0, Math.SQRT1_2);
-    }
-
-    root.updateMatrices();
-
-    const inverse_bind_matrices = new Float32Array(joints.length * 16);
-
-    const source = bind ?? snapshot_joint_globals(joints);
-
-    const inverse = new Float64Array(16);
-
-    for (let i = 0; i < joints.length; i++) {
-        m4_invert(inverse, source[i]);
-
-        inverse_bind_matrices.set(inverse, i * 16);
-    }
-
-    const skin = Skin.from({
-        name: 'fixture',
-        joints,
-        inverse_bind_matrices,
-        meshes: [mesh],
-    });
-
-    const placement_node = new Node3D();
-
-    placement_node.name = 'placement';
-    placement_node.transform_local.setTranslation(placement[0], placement[1], placement[2]);
-    placement_node.addChild(root);
-    placement_node.updateMatrices();
-
-    return { placement: placement_node, root, mesh, skin, joints };
-}
-
-/**
- * Every joint's world matrix as it stands, copied out — a `Transform64` is live, and these are read
- * after the hierarchy has been walked again.
- *
- * @param {Node3D[]} joints
- * @returns {Float64Array[]}
- */
-function snapshot_joint_globals(joints) {
-    return joints.map(joint => {
-        const copy = new Float64Array(16);
-
-        // a Transform64's matrix starts at element 0
-        for (let i = 0; i < 16; i++) {
-            copy[i] = joint.transform_global[i];
-        }
-
-        return copy;
-    });
-}
-
-/**
- * One triangle in one meshlet, with enough metadata behind it to be cloned.
- *
- * A bare {@link MeshletGeometry} is enough for the frame arithmetic, which only ever reads bounds —
- * but `register_skin` reaches `GPUMeshSkinningContext#bind`, which allocates a per-instance vertex
- * clone and refuses a batch of no meshlets. A fixture that stops short of that cannot be handed to
- * the manager at all, and the manager is where half of what this fixture is for gets tested.
- *
- * @returns {MeshletGeometry}
- */
-function make_geometry() {
-    const box = [-1, 0, -1, 1, 2, 1];
-
-    const geometry = new MeshletGeometry();
-
-    geometry.name = 'fixture';
-    geometry.primitive_count = 1;
-    geometry.bounding_box.set(box);
-    geometry.bounding_sphere.set([0, 1, 0, 1.8]);
-
-    const writer = BinaryBuffer.fromEndianness(platform_compute_endianness());
-
-    writer.setCapacity(MESHLET_METADATA_STRUCT.size);
-
-    write_wgsl_type_value({
-        bounds_box: box,
-        address: 0,
-        primitive_count: 1,
-        vertex_count: 3,
-        flags: 0,
-    }, writer, MESHLET_METADATA_STRUCT);
-
-    geometry.meshlets.count = 1;
-    geometry.meshlets.data_buffer = new ArrayBuffer(3 * 3 * 4);
-    geometry.meshlets.metadata_buffer = writer.data.slice(0, MESHLET_METADATA_STRUCT.size);
-
-    return geometry;
-}