@woosh/meep-engine 3.17.1 → 3.18.0

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;
-}

package/src/shade/renderer/geometry/virtual/format/attribute/vgeo_layers_test_fixtures.d.ts

@@ -1,16 +0,0 @@
-/**
- * A topology of `vertex_count` vertices carrying exactly the channels named.
- *
- * @param {number} vertex_count
- * @param {number[]} carried_attributes indices into {@link VGEO_ATTRIBUTES}
- * @returns {{topology: BinaryTopology, layers: (BinaryDataLayer|null)[]}}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_test_layers(vertex_count: number, carried_attributes: number[]): {
-    topology: BinaryTopology;
-    layers: (BinaryDataLayer | null)[];
-};
-import { BinaryTopology } from "../../../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
-//# sourceMappingURL=vgeo_layers_test_fixtures.d.ts.map

package/src/shade/renderer/geometry/virtual/format/attribute/vgeo_layers_test_fixtures.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_layers_test_fixtures.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/attribute/vgeo_layers_test_fixtures.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,+CAPW,MAAM,sBACN,MAAM,EAAE;cACK,cAAc;YAAU,CAAC,kBAAgB,IAAI,CAAC,EAAE;EAiBvE;+BA1B8B,yEAAyE"}

package/src/shade/renderer/geometry/virtual/format/attribute/vgeo_layers_test_fixtures.js

@@ -1,27 +0,0 @@
-import { BinaryTopology } from "../../../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
-import { VGEO_ATTRIBUTES } from "./VGEO_ATTRIBUTES.js";
-import { vgeo_layers_declare } from "./vgeo_layers_declare.js";
-
-/**
- * A topology of `vertex_count` vertices carrying exactly the channels named.
- *
- * @param {number} vertex_count
- * @param {number[]} carried_attributes indices into {@link VGEO_ATTRIBUTES}
- * @returns {{topology: BinaryTopology, layers: (BinaryDataLayer|null)[]}}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_test_layers(vertex_count, carried_attributes) {
-    const topology = new BinaryTopology();
-
-    topology.vertices_create_continuous(vertex_count);
-
-    const carried = new Array(VGEO_ATTRIBUTES.length).fill(false);
-
-    for (const attribute of carried_attributes) {
-        carried[attribute] = true;
-    }
-
-    return { topology, layers: vgeo_layers_declare(topology, carried) };
-}

package/src/shade/renderer/particles/particle_test_fixtures.d.ts

@@ -1,151 +0,0 @@
-/**
- * Shared scaffolding for the particle specs that run shaders under the WGSL emulator.
- *
- * An emitter is a scene node, so a shader that reads one needs two databases laid out the way the
- * GPU would hold them: the scene's (for the node's world matrix) and the particle system's (for the
- * emitter row). Both are real `GPUDatabase`s on the software device, filled through the real
- * {@link GPUSceneContext} and {@link EmitterRegistry}, and serialised by
- * {@link gpu_database_words} — so a spec exercises the actual writers, and the only thing standing
- * in for the GPU is the upload.
- */
-/**
- * @typedef {object} ParticleSceneFixture
- * @property {SoftwareGPUDevice} device
- * @property {GraphicsContext} graphics
- * @property {Scene} scene
- * @property {import("../scene/GPUSceneContext.js").GPUSceneContext} scene_context
- * @property {EmitterRegistry} registry
- */
-/**
- * A scene with a GPU context and an emitter registry, both on a fresh software device.
- *
- * @returns {ParticleSceneFixture}
- */
-export function particle_scene_fixture(): ParticleSceneFixture;
-/**
- * Put an emitter in the scene and register it, the way the system does: the node gets its
- * `transforms` row from the scene context's sweep, and the emitter record points at that row.
- *
- * @param {ParticleSceneFixture} fixture
- * @param {ParticleEmitter|object} config a {@link ParticleEmitter}, or what {@link ParticleEmitter.from} accepts
- * @param {import("../scene/Node3D.js").Node3D} [parent] node to hang the emitter under, itself already in the scene
- * @returns {ParticleEmitter}
- */
-export function place_emitter(fixture: ParticleSceneFixture, config: ParticleEmitter | object, parent?: import("../scene/Node3D.js").Node3D): ParticleEmitter;
-/**
- * What the fixture's registry assigned an emitter: its table row, its generation, the heap
- * placement of its program, the atlas patch. The emitter carries none of it — see
- * {@link ./runtime/GPUParticleEmitterContext.js} — so a spec that wants the row a particle header
- * should carry asks the registry, the way the passes' own callers do.
- *
- * @param {ParticleSceneFixture} fixture
- * @param {ParticleEmitter} emitter
- * @returns {import("./runtime/GPUParticleEmitterContext.js").GPUParticleEmitterContext}
- */
-export function emitter_context(fixture: ParticleSceneFixture, emitter: ParticleEmitter): import("./runtime/GPUParticleEmitterContext.js").GPUParticleEmitterContext;
-/**
- * The emitter table row an emitter was given — {@link emitter_context}`.row`, which specs index
- * per-emitter buffers with often enough to be worth naming.
- *
- * @param {ParticleSceneFixture} fixture
- * @param {ParticleEmitter} emitter
- * @returns {number}
- */
-export function emitter_row(fixture: ParticleSceneFixture, emitter: ParticleEmitter): number;
-/**
- * The two databases as the `array<u32>` buffers the particle shaders bind. Call after the last
- * change to either; it flushes both.
- *
- * @param {ParticleSceneFixture} fixture
- * @returns {{scene_database: Uint32Array, emitter_database: Uint32Array}}
- */
-export function particle_database_words(fixture: ParticleSceneFixture): {
-    scene_database: Uint32Array;
-    emitter_database: Uint32Array;
-};
-/**
- * An `array<atomic<u32>>` the way the emulator models one: a `{value}` object per word.
- *
- * @param {number} length
- * @param {number} [fill]
- * @returns {{value: number}[]}
- */
-export function atomic_words(length: number, fill?: number): {
-    value: number;
-}[];
-/**
- * A counters buffer, every slot zero.
- *
- * @returns {{value: number}[]}
- */
-export function particle_counters(): {
-    value: number;
-}[];
-/**
- * One emitter's GPU-owned state, read back out of the serialised database.
- *
- * @param {Uint32Array} emitter_database
- * @param {number} row
- * @returns {{generation: number, accumulator: number, age: number, sleep: number, pending: number}}
- */
-export function emitter_state_read(emitter_database: Uint32Array, row: number): {
-    generation: number;
-    accumulator: number;
-    age: number;
-    sleep: number;
-    pending: number;
-};
-/**
- * Overwrite some of one emitter's state fields in the serialised database — what a previous tick
- * would have left there.
- *
- * @param {Uint32Array} emitter_database
- * @param {number} row
- * @param {{generation?: number, accumulator?: number, age?: number, sleep?: number, pending?: number}} fields
- */
-export function emitter_state_write(emitter_database: Uint32Array, row: number, fields: {
-    generation?: number;
-    accumulator?: number;
-    age?: number;
-    sleep?: number;
-    pending?: number;
-}): void;
-/**
- * A `{count, elements}` collection as the emulator binds one — the shape both the emitter tick's
- * output and the emit pass's input take.
- *
- * @param {number} count
- * @param {ArrayLike<number>} [elements] defaults to `count` zeros
- * @returns {{count: number, elements: Uint32Array}}
- */
-export function u32_collection(count: number, elements?: ArrayLike<number>): {
-    count: number;
-    elements: Uint32Array;
-};
-/**
- * The CSDLDF scan's stand-in: inclusive prefix sums over a collection's elements, in place, the
- * count left alone.
- *
- * @param {{count: number, elements: Uint32Array}} collection
- * @returns {{count: number, elements: Uint32Array}} the same object
- */
-export function inclusive_scan(collection: {
-    count: number;
-    elements: Uint32Array;
-}): {
-    count: number;
-    elements: Uint32Array;
-};
-export type ParticleSceneFixture = {
-    device: SoftwareGPUDevice;
-    graphics: GraphicsContext;
-    scene: Scene;
-    scene_context: import("../scene/GPUSceneContext.js").GPUSceneContext;
-    registry: EmitterRegistry;
-};
-import { ParticleEmitter } from "./runtime/ParticleEmitter.js";
-import { SoftwareGPUDevice } from "../../device/mock/SoftwareGPUDevice.js";
-import { GraphicsContext } from "../GraphicsContext.js";
-import { Scene } from "../scene/Scene.js";
-import { EmitterRegistry } from "./runtime/EmitterRegistry.js";
-//# sourceMappingURL=particle_test_fixtures.d.ts.map

package/src/shade/renderer/particles/particle_test_fixtures.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"particle_test_fixtures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/particle_test_fixtures.js"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AAEH;;;;GAIG;AACH,0CAFa,oBAAoB,CAUhC;AAED;;;;;;;;GAQG;AACH,uCALW,oBAAoB,UACpB,eAAe,GAAC,MAAM,WACtB,OAAO,oBAAoB,EAAE,MAAM,GACjC,eAAe,CAkB3B;AAED;;;;;;;;;GASG;AACH,yCAJW,oBAAoB,WACpB,eAAe,GACb,OAAO,wCAAwC,EAAE,yBAAyB,CAItF;AAED;;;;;;;GAOG;AACH,qCAJW,oBAAoB,WACpB,eAAe,GACb,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,iDAHW,oBAAoB,GAClB;IAAC,cAAc,EAAE,WAAW,CAAC;IAAC,gBAAgB,EAAE,WAAW,CAAA;CAAC,CAUxE;AAED;;;;;;GAMG;AACH,qCAJW,MAAM,SACN,MAAM,GACJ;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,EAAE,CAI7B;AAED;;;;GAIG;AACH,qCAFa;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,EAAE,CAI7B;AA2BD;;;;;;GAMG;AACH,qDAJW,WAAW,OACX,MAAM,GACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAalG;AAED;;;;;;;GAOG;AACH,sDAJW,WAAW,OACX,MAAM,UACN;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC,QAWrG;AAED;;;;;;;GAOG;AACH,sCAJW,MAAM,aACN,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAC,CAIlD;AAED;;;;;;GAMG;AACH,2CAHW;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAC,GACpC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAC,CAWlD;;YA5Ma,iBAAiB;cACjB,eAAe;WACf,KAAK;mBACL,OAAO,6BAA6B,EAAE,eAAe;cACrD,eAAe;;gCAnBG,8BAA8B;kCAT5B,wCAAwC;gCAC1C,uBAAuB;sBAEjC,mBAAmB;gCAKT,8BAA8B"}

package/src/shade/renderer/particles/particle_test_fixtures.js

@@ -1,229 +0,0 @@
-import { SoftwareGPUDevice } from "../../device/mock/SoftwareGPUDevice.js";
-import { GraphicsContext } from "../GraphicsContext.js";
-import { gpu_database_words } from "../buffer/table/gpu_database_words.js";
-import { Scene } from "../scene/Scene.js";
-import { SceneManager } from "../scene/SceneManager.js";
-import { PARTICLE_COUNTER_COUNT } from "./data/PARTICLE_COUNTERS.js";
-import { PARTICLE_EMITTER_STATE_DESCRIPTOR } from "./data/PARTICLE_DATABASE_SPEC.js";
-import { PARTICLE_EMITTER_STATE_STRUCT } from "./data/PARTICLE_EMITTER_STATE.js";
-import { EmitterRegistry } from "./runtime/EmitterRegistry.js";
-import { ParticleEmitter } from "./runtime/ParticleEmitter.js";
-
-/**
- * Shared scaffolding for the particle specs that run shaders under the WGSL emulator.
- *
- * An emitter is a scene node, so a shader that reads one needs two databases laid out the way the
- * GPU would hold them: the scene's (for the node's world matrix) and the particle system's (for the
- * emitter row). Both are real `GPUDatabase`s on the software device, filled through the real
- * {@link GPUSceneContext} and {@link EmitterRegistry}, and serialised by
- * {@link gpu_database_words} — so a spec exercises the actual writers, and the only thing standing
- * in for the GPU is the upload.
- */
-
-/**
- * @typedef {object} ParticleSceneFixture
- * @property {SoftwareGPUDevice} device
- * @property {GraphicsContext} graphics
- * @property {Scene} scene
- * @property {import("../scene/GPUSceneContext.js").GPUSceneContext} scene_context
- * @property {EmitterRegistry} registry
- */
-
-/**
- * A scene with a GPU context and an emitter registry, both on a fresh software device.
- *
- * @returns {ParticleSceneFixture}
- */
-export function particle_scene_fixture() {
-    const device = new SoftwareGPUDevice({ requiredFeatures: ["subgroups"] });
-    const graphics = new GraphicsContext(device);
-    const scene = new Scene();
-    const scene_context = new SceneManager(graphics).obtain(scene);
-    const registry = new EmitterRegistry(device);
-
-    return { device, graphics, scene, scene_context, registry };
-}
-
-/**
- * Put an emitter in the scene and register it, the way the system does: the node gets its
- * `transforms` row from the scene context's sweep, and the emitter record points at that row.
- *
- * @param {ParticleSceneFixture} fixture
- * @param {ParticleEmitter|object} config a {@link ParticleEmitter}, or what {@link ParticleEmitter.from} accepts
- * @param {import("../scene/Node3D.js").Node3D} [parent] node to hang the emitter under, itself already in the scene
- * @returns {ParticleEmitter}
- */
-export function place_emitter(fixture, config, parent) {
-    const emitter = config.isParticleEmitter === true ? config : ParticleEmitter.from(config);
-
-    if (parent !== undefined) {
-        parent.addChild(emitter);
-        parent.updateMatrices();
-    }
-
-    fixture.scene.add(emitter);
-    fixture.scene_context.build();
-
-    const transform_row = fixture.scene_context.id_mapping.get(emitter.id);
-
-    fixture.registry.add(emitter, transform_row);
-
-    return emitter;
-}
-
-/**
- * What the fixture's registry assigned an emitter: its table row, its generation, the heap
- * placement of its program, the atlas patch. The emitter carries none of it — see
- * {@link ./runtime/GPUParticleEmitterContext.js} — so a spec that wants the row a particle header
- * should carry asks the registry, the way the passes' own callers do.
- *
- * @param {ParticleSceneFixture} fixture
- * @param {ParticleEmitter} emitter
- * @returns {import("./runtime/GPUParticleEmitterContext.js").GPUParticleEmitterContext}
- */
-export function emitter_context(fixture, emitter) {
-    return fixture.registry.context(emitter);
-}
-
-/**
- * The emitter table row an emitter was given — {@link emitter_context}`.row`, which specs index
- * per-emitter buffers with often enough to be worth naming.
- *
- * @param {ParticleSceneFixture} fixture
- * @param {ParticleEmitter} emitter
- * @returns {number}
- */
-export function emitter_row(fixture, emitter) {
-    return emitter_context(fixture, emitter).row;
-}
-
-/**
- * The two databases as the `array<u32>` buffers the particle shaders bind. Call after the last
- * change to either; it flushes both.
- *
- * @param {ParticleSceneFixture} fixture
- * @returns {{scene_database: Uint32Array, emitter_database: Uint32Array}}
- */
-export function particle_database_words(fixture) {
-    fixture.scene_context.build();
-    fixture.registry.flush();
-
-    return {
-        scene_database: gpu_database_words(fixture.scene_context.scene_database, fixture.graphics),
-        emitter_database: gpu_database_words(fixture.registry.database, fixture.graphics),
-    };
-}
-
-/**
- * An `array<atomic<u32>>` the way the emulator models one: a `{value}` object per word.
- *
- * @param {number} length
- * @param {number} [fill]
- * @returns {{value: number}[]}
- */
-export function atomic_words(length, fill = 0) {
-    return Array.from({ length }, () => ({ value: fill }));
-}
-
-/**
- * A counters buffer, every slot zero.
- *
- * @returns {{value: number}[]}
- */
-export function particle_counters() {
-    return atomic_words(PARTICLE_COUNTER_COUNT);
-}
-
-/**
- * Where a row of the `emitter_state` table sits in the serialised database, in words — the same
- * arithmetic the table's generated readers do.
- *
- * @param {Uint32Array} emitter_database the database as {@link particle_database_words} lays it out
- * @param {number} row
- * @returns {number}
- */
-function emitter_state_base(emitter_database, row) {
-    const descriptor = PARTICLE_EMITTER_STATE_DESCRIPTOR;
-    const per_page = descriptor.elements_per_page;
-    const page_address = emitter_database[descriptor.page_lookup_address + Math.floor(row / per_page)];
-
-    if (page_address === 0xffffffff) {
-        throw new Error(`emitter state row ${row} is on a page the database has not allocated`);
-    }
-
-    return page_address + descriptor.page_header_words + (row % per_page) * (descriptor.packed_element_size_bytes / 4);
-}
-
-/** @type {Object<string, number>} word offset of each state field within its row */
-const STATE_FIELD_WORD = Object.fromEntries(
-    PARTICLE_EMITTER_STATE_STRUCT.fields.map((field) => [field.name, field.offset / 4]),
-);
-
-/**
- * One emitter's GPU-owned state, read back out of the serialised database.
- *
- * @param {Uint32Array} emitter_database
- * @param {number} row
- * @returns {{generation: number, accumulator: number, age: number, sleep: number, pending: number}}
- */
-export function emitter_state_read(emitter_database, row) {
-    const base = emitter_state_base(emitter_database, row);
-    const floats = new Float32Array(emitter_database.buffer, emitter_database.byteOffset, emitter_database.length);
-
-    return {
-        generation: emitter_database[base + STATE_FIELD_WORD.generation],
-        accumulator: floats[base + STATE_FIELD_WORD.accumulator],
-        age: floats[base + STATE_FIELD_WORD.age],
-        sleep: floats[base + STATE_FIELD_WORD.sleep],
-        pending: emitter_database[base + STATE_FIELD_WORD.pending],
-    };
-}
-
-/**
- * Overwrite some of one emitter's state fields in the serialised database — what a previous tick
- * would have left there.
- *
- * @param {Uint32Array} emitter_database
- * @param {number} row
- * @param {{generation?: number, accumulator?: number, age?: number, sleep?: number, pending?: number}} fields
- */
-export function emitter_state_write(emitter_database, row, fields) {
-    const base = emitter_state_base(emitter_database, row);
-    const floats = new Float32Array(emitter_database.buffer, emitter_database.byteOffset, emitter_database.length);
-
-    if (fields.generation !== undefined) emitter_database[base + STATE_FIELD_WORD.generation] = fields.generation;
-    if (fields.accumulator !== undefined) floats[base + STATE_FIELD_WORD.accumulator] = fields.accumulator;
-    if (fields.age !== undefined) floats[base + STATE_FIELD_WORD.age] = fields.age;
-    if (fields.sleep !== undefined) floats[base + STATE_FIELD_WORD.sleep] = fields.sleep;
-    if (fields.pending !== undefined) emitter_database[base + STATE_FIELD_WORD.pending] = fields.pending;
-}
-
-/**
- * A `{count, elements}` collection as the emulator binds one — the shape both the emitter tick's
- * output and the emit pass's input take.
- *
- * @param {number} count
- * @param {ArrayLike<number>} [elements] defaults to `count` zeros
- * @returns {{count: number, elements: Uint32Array}}
- */
-export function u32_collection(count, elements) {
-    return { count, elements: elements === undefined ? new Uint32Array(count) : Uint32Array.from(elements) };
-}
-
-/**
- * The CSDLDF scan's stand-in: inclusive prefix sums over a collection's elements, in place, the
- * count left alone.
- *
- * @param {{count: number, elements: Uint32Array}} collection
- * @returns {{count: number, elements: Uint32Array}} the same object
- */
-export function inclusive_scan(collection) {
-    let running = 0;
-
-    for (let i = 0; i < collection.count; i++) {
-        running += collection.elements[i];
-        collection.elements[i] = running;
-    }
-
-    return collection;
-}