@woosh/meep-engine 3.17.2 → 3.18.0

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

package/src/shade/renderer/particles/shaders/chunk_particle_emitter_world_sphere.js

@@ -1,23 +0,0 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { chunk_particle_emitter } from "../data/chunk_particle_emitter.js";
-
-/**
- * An emitter's bounds sphere in world space: the centre through the node's matrix, the radius
- * scaled by the largest axis scale the matrix carries.
- *
- * The axes are read as transformed unit vectors rather than as matrix columns — the same numbers,
- * in a form the WGSL emulator also evaluates. Shared by the tick pass (frustum culling of spawning)
- * and the AVBOIT occupancy pass (which depth slices the emitter's particles can reach), so both
- * test the same sphere.
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_emitter_world_sphere = CodeChunk.from(/* language=wgsl */ `
-fn particle_emitter_world_sphere(em : ParticleEmitter, transform : mat4x4<f32>) -> vec4<f32> {
-    let center = (transform * vec4<f32>(em.bounds_center, 1.0)).xyz;
-    let sx = length((transform * vec4<f32>(1.0, 0.0, 0.0, 0.0)).xyz);
-    let sy = length((transform * vec4<f32>(0.0, 1.0, 0.0, 0.0)).xyz);
-    let sz = length((transform * vec4<f32>(0.0, 0.0, 1.0, 0.0)).xyz);
-    return vec4<f32>(center, em.bounds_radius * max(sx, max(sy, sz)));
-}
-`, [chunk_particle_emitter]);