@woosh/meep-engine 3.16.0 → 3.17.0

package/src/shade/renderer/particles/data/PARTICLE_EMITTER_LAYOUT.d.ts

@@ -1,156 +0,0 @@
-/**
- * Compose the flags word from feature toggles + blend + projection.
- * @param {object} options
- * @param {boolean} [options.lighting]
- * @param {boolean} [options.soft_depth]
- * @param {boolean} [options.sort]
- * @param {boolean} [options.cull]
- * @param {number} [options.blend] see {@link EMITTER_BLEND}
- * @param {number} [options.projection] see {@link EMITTER_PROJECTION}
- * @returns {number}
- */
-export function make_emitter_flags({ lighting, soft_depth, sort, cull, blend, projection }?: {
-    lighting?: boolean;
-    soft_depth?: boolean;
-    sort?: boolean;
-    cull?: boolean;
-    blend?: number;
-    projection?: number;
-}): number;
-/** @param {number} flags @returns {number} the blend mode */
-export function emitter_flags_blend(flags: number): number;
-/** @param {number} flags @returns {number} the projection mode */
-export function emitter_flags_projection(flags: number): number;
-/**
- * Write one emitter record into a shared `u32` view (and its `f32` alias) at record `index`.
- *
- * @param {Uint32Array} u32 view over the emitter buffer
- * @param {Float32Array} f32 f32 alias over the same buffer
- * @param {number} index emitter index
- * @param {object} def emitter definition
- * @param {number} def.spawn_offset
- * @param {number} def.spawn_count
- * @param {number} def.update_offset
- * @param {number} def.update_count
- * @param {number} def.constant_offset
- * @param {number} def.seed
- * @param {number} def.flags
- * @param {number} def.spawn_rate
- * @param {number[]} def.transform 16-element column-major matrix
- * @param {number[]} [def.bounds_center] length-3
- * @param {number} [def.bounds_radius]
- * @param {object} [def.render] { position, size, color, rotation, frame } attribute word offsets
- * @param {number[]} [def.atlas_region] length-4 [uvOffsetX, uvOffsetY, uvScaleX, uvScaleY]
- * @param {number[]} [def.flipbook] length-2 [cols, rows]
- * @param {number} [def.program_id] dense program id, the simulation-order bucket key
- */
-export function pack_emitter(u32: Uint32Array, f32: Float32Array, index: number, def: {
-    spawn_offset: number;
-    spawn_count: number;
-    update_offset: number;
-    update_count: number;
-    constant_offset: number;
-    seed: number;
-    flags: number;
-    spawn_rate: number;
-    transform: number[];
-    bounds_center?: number[];
-    bounds_radius?: number;
-    render?: object;
-    atlas_region?: number[];
-    flipbook?: number[];
-    program_id?: number;
-}): void;
-/**
- * Overwrite just an emitter's world transform in a packed buffer.
- *
- * Used for scene-node / bone attachment: each frame the feature copies the attached `Node3D`'s
- * world matrix (`transform_global`) into the emitter record and re-uploads the changed region, so
- * the emitter spawns and simulates wherever the bone currently is. Cheaper than repacking the whole
- * emitter set.
- *
- * @param {Float32Array} f32 f32 alias over the emitter buffer
- * @param {number} index emitter index
- * @param {ArrayLike<number>} matrix 16-element column-major world matrix
- */
-export function write_emitter_transform(f32: Float32Array, index: number, matrix: ArrayLike<number>): void;
-/**
- * GPU memory layout for a single emitter record, addressed as `u32` words.
- *
- * Emitters are read on the GPU via explicit indexed access into an `array<u32>` (the same strategy
- * GPUDatabase uses on-device) rather than an `array<Struct>` binding — this keeps the simulate/emit
- * shaders trivially testable through the WGSL emulator. The word offsets here are the single source
- * of truth shared by the JS packer ({@link pack_emitter}) and the WGSL reader
- * ({@link ../data/chunk_particle_emitter.js}, which interpolates them).
- *
- * f32 fields are stored as their bit pattern and read back with `bitcast<f32>`.
- */
-/** Word offsets within an emitter record. */
-export const EMITTER_FIELD: Readonly<{
-    SPAWN_OFFSET: 0;
-    SPAWN_COUNT: 1;
-    UPDATE_OFFSET: 2;
-    UPDATE_COUNT: 3;
-    CONSTANT_OFFSET: 4;
-    SEED: 5;
-    FLAGS: 6;
-    SPAWN_RATE: 7;
-    TRANSFORM: 8;
-    BOUNDS_CENTER: 24;
-    BOUNDS_RADIUS: 27;
-    RENDER_POSITION: 28;
-    RENDER_SIZE: 29;
-    RENDER_COLOR: 30;
-    RENDER_ROTATION: 31;
-    RENDER_FRAME: 32;
-    ATLAS_REGION: 33;
-    FLIPBOOK: 37;
-    RENDER_VELOCITY: 39;
-    /**
-     * u32 — dense id of the compiled program this emitter runs, assigned by
-     * {@link ../runtime/ProgramArena.js}. Emitters sharing a program share an id.
-     *
-     * The simulation-order bucketing (`coherence/`) histograms on this: it needs a small dense
-     * integer to index a bin with, which neither the emitter index (one bucket per emitter, even
-     * when they run the same code) nor `UPDATE_OFFSET` (an arena word offset, arbitrarily large
-     * and sparse) gives it.
-     */
-    PROGRAM_ID: 40;
-}>;
-/** Number of `u32` words per emitter record. */
-export const EMITTER_STRIDE: 41;
-/** Sentinel for an absent render-attribute binding. */
-export const EMITTER_ATTRIBUTE_ABSENT: 4294967295;
-/** Sentinel for "not attached to a scene node". */
-export const EMITTER_ATTACH_NONE: 4294967295;
-/**
- * Emitter flag bits. Blend mode occupies bits [4,6), projection mode bits [6,9).
- */
-export const EMITTER_FLAG: Readonly<{
-    LIGHTING: number;
-    SOFT_DEPTH: number;
-    SORT: number;
-    CULL: number;
-}>;
-/** Blend modes (stored in flag bits [4,6)). All expressed by one premultiplied blend pipeline. */
-export const EMITTER_BLEND: Readonly<{
-    ALPHA: 0;
-    ADDITIVE: 1;
-    PREMULTIPLIED: 2;
-}>;
-/** Projection / orientation modes (stored in flag bits [6,9)). */
-export const EMITTER_PROJECTION: Readonly<{
-    BILLBOARD: 0;
-    STRETCHED: 1;
-    HORIZONTAL: 2;
-    VERTICAL: 3;
-    FACING_WORLD: 4;
-}>;
-/** Shift/mask constants exposed for the WGSL reader to interpolate. */
-export const EMITTER_FLAG_ENCODING: Readonly<{
-    BLEND_SHIFT: 4;
-    BLEND_MASK: number;
-    PROJECTION_SHIFT: 6;
-    PROJECTION_MASK: number;
-}>;
-//# sourceMappingURL=PARTICLE_EMITTER_LAYOUT.d.ts.map

package/src/shade/renderer/particles/data/PARTICLE_EMITTER_LAYOUT.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PARTICLE_EMITTER_LAYOUT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/data/PARTICLE_EMITTER_LAYOUT.js"],"names":[],"mappings":"AA4FA;;;;;;;;;;GAUG;AACH;IAR6B,QAAQ,GAA1B,OAAO;IACW,UAAU,GAA5B,OAAO;IACW,IAAI,GAAtB,OAAO;IACW,IAAI,GAAtB,OAAO;IACU,KAAK,GAAtB,MAAM;IACW,UAAU,GAA3B,MAAM;IACJ,MAAM,CAWlB;AAED,6DAA6D;AAC7D,2CADY,MAAM,GAAkB,MAAM,CAGzC;AAED,kEAAkE;AAClE,gDADY,MAAM,GAAkB,MAAM,CAGzC;AAOD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,kCApBW,WAAW,OACX,YAAY,SACZ,MAAM;IAEM,YAAY,EAAxB,MAAM;IACM,WAAW,EAAvB,MAAM;IACM,aAAa,EAAzB,MAAM;IACM,YAAY,EAAxB,MAAM;IACM,eAAe,EAA3B,MAAM;IACM,IAAI,EAAhB,MAAM;IACM,KAAK,EAAjB,MAAM;IACM,UAAU,EAAtB,MAAM;IACQ,SAAS,EAAvB,MAAM,EAAE;IACO,aAAa,GAA5B,MAAM,EAAE;IACK,aAAa,GAA1B,MAAM;IACO,MAAM,GAAnB,MAAM;IACS,YAAY,GAA3B,MAAM,EAAE;IACO,QAAQ,GAAvB,MAAM,EAAE;IACK,UAAU,GAAvB,MAAM;SA0ChB;AAED;;;;;;;;;;;GAWG;AACH,6CAJW,YAAY,SACZ,MAAM,UACN,UAAU,MAAM,CAAC,QAO3B;AAnND;;;;;;;;;;GAUG;AAEH,6CAA6C;AAC7C;;;;;;;;;;;;;;;;;;;;IA0BI;;;;;;;;OAQG;;GAEJ;AAEH,gDAAgD;AAChD,gCAAiC;AAEjC,uDAAuD;AACvD,kDAAmD;AAEnD,mDAAmD;AACnD,6CAA8C;AAE9C;;GAEG;AACH;;;;;GAKG;AAEH,kGAAkG;AAClG;;;;GAIG;AAKH,kEAAkE;AAClE;;;;;;GAMG;AAqCH,uEAAuE;AACvE;;;;;GAEG"}

package/src/shade/renderer/particles/runtime/Emitter.d.ts

@@ -1,219 +0,0 @@
-/**
- * Render channels an emitter can bind to one of its effect's per-particle attributes. The names
- * match the `render_*` fields of {@link ../data/PARTICLE_EMITTER_STRUCT.js}.
- *
- * @type {string[]}
- */
-export const EMITTER_RENDER_CHANNELS: string[];
-/**
- * One emitter: a compiled effect bound to instance parameters — world transform, spawn rate,
- * blend / projection / feature flags, bounds sphere, render-attribute bindings, atlas region and
- * flipbook grid.
- *
- * This is the CPU model of exactly one row of the emitter table
- * ({@link ../data/PARTICLE_EMITTER_STRUCT.js}); {@link to_record} is the whole of the translation
- * between the two. Fields are plain data with no setters — after changing any of them, set
- * {@link dirty} so {@link ../runtime/EmitterRegistry.js} restages the row on its next flush. The
- * flag rather than a setter per field because a row is restaged whole either way: one changed field
- * and ten cost the same upload.
- *
- * Instances are created by {@link EmitterRegistry#add}, which assigns {@link id} and resolves the
- * program placement. Constructing one directly gives you an emitter no table knows about.
- */
-export class Emitter {
-    /**
-     * Build an emitter from a plain description. Every parameter is optional except the effect —
-     * an emitter with no program has nothing to run.
-     *
-     * @param {object} config
-     * @param {{layout: object, program: object}} config.effect compiled effect, see
-     *        {@link ./create_particle_effect.js}
-     * @param {ArrayLike<number>} [config.transform] 16-element column-major local-to-world
-     * @param {number} [config.seed]
-     * @param {number} [config.spawn_rate] particles/second
-     * @param {object} [config.flags] passed to {@link make_emitter_flags}
-     * @param {{center?: ArrayLike<number>, radius?: number}} [config.bounds]
-     * @param {Object<string,string>} [config.render] render channel -> attribute name
-     * @param {ArrayLike<number>} [config.atlas_region] [uvOffsetX, uvOffsetY, uvScaleX, uvScaleY]
-     * @param {ArrayLike<number>} [config.flipbook] [cols, rows]
-     * @param {object} [config.node] scene node to follow, see {@link attach_to}
-     * @returns {Emitter}
-     */
-    static from(config: {
-        effect: {
-            layout: object;
-            program: object;
-        };
-        transform?: ArrayLike<number>;
-        seed?: number;
-        spawn_rate?: number;
-        flags?: object;
-        bounds?: {
-            center?: ArrayLike<number>;
-            radius?: number;
-        };
-        render?: {
-            [x: string]: string;
-        };
-        atlas_region?: ArrayLike<number>;
-        flipbook?: ArrayLike<number>;
-        node?: object;
-    }): Emitter;
-    /**
-     * Row this emitter occupies in the emitter table. Stable for the emitter's whole life — it is
-     * what every live particle's record header stores, so it cannot be renumbered while particles
-     * are in flight. `-1` until the registry assigns one.
-     *
-     * @type {number}
-     */
-    id: number;
-    /**
-     * Compiled effect: the per-particle attribute layout plus the SPAWN/UPDATE bytecode.
-     *
-     * @type {{layout: import("../layout/ParticleLayout.js").ParticleLayout, program: import("../isa/ParticleProgram.js").ParticleProgram}}
-     */
-    effect: {
-        layout: import("../layout/ParticleLayout.js").ParticleLayout;
-        program: import("../isa/ParticleProgram.js").ParticleProgram;
-    };
-    /**
-     * Where this emitter's program sits in the shared arena, and the dense program id the
-     * simulation-order bucketing keys on. Assigned by {@link EmitterRegistry#add} from
-     * {@link ../runtime/ProgramArena.js}; emitters compiled from the same graph share one.
-     *
-     * @type {{spawn_offset: number, spawn_count: number, update_offset: number, update_count: number, constant_offset: number, program_id: number}}
-     */
-    placement: {
-        spawn_offset: number;
-        spawn_count: number;
-        update_offset: number;
-        update_count: number;
-        constant_offset: number;
-        program_id: number;
-    };
-    /**
-     * Local-to-world, column-major.
-     * @type {Float32Array}
-     */
-    transform: Float32Array;
-    /**
-     * Base RNG seed.
-     *
-     * Two emitters running one program produce identical particles from identical seeds, so leaving
-     * this at 0 is almost never what an author wants — {@link EmitterRegistry#add} reads 0 as
-     * "unset" and derives one from the row instead.
-     *
-     * @type {number}
-     */
-    seed: number;
-    /**
-     * Continuous emission rate, particles per second. Consumed on the CPU by
-     * {@link ./ParticleSpawnScheduler.js} and carried in the record for shaders that want it.
-     * @type {number}
-     */
-    spawn_rate: number;
-    /**
-     * Packed feature / blend / projection bits — see {@link make_emitter_flags}.
-     * @type {number}
-     */
-    flags: number;
-    /**
-     * Bounding sphere in emitter-local space, used by the optional simulation culling.
-     * @type {Float32Array}
-     */
-    bounds_center: Float32Array;
-    /**
-     * @type {number}
-     */
-    bounds_radius: number;
-    /**
-     * Atlas sub-rect: uv offset `.xy`, uv scale `.zw`. Mirrors meep's `AtlasPatch`.
-     * @type {Float32Array}
-     */
-    atlas_region: Float32Array;
-    /**
-     * Flipbook grid: columns, rows. `[1, 1]` is a single frame.
-     * @type {Float32Array}
-     */
-    flipbook: Float32Array;
-    /** @type {number} record word offset of world position, or {@link EMITTER_ATTRIBUTE_ABSENT} */
-    render_position: number;
-    /** @type {number} record word offset of size */
-    render_size: number;
-    /** @type {number} record word offset of rgba colour */
-    render_color: number;
-    /** @type {number} record word offset of roll angle, radians */
-    render_rotation: number;
-    /** @type {number} record word offset of flipbook frame index */
-    render_frame: number;
-    /** @type {number} record word offset of velocity, read by the STRETCHED projection */
-    render_velocity: number;
-    /**
-     * Scene node (bone) this emitter follows, if any. While set, the system copies the node's world
-     * matrix into {@link transform} every frame, so the emitter spawns and simulates wherever the
-     * bone currently is.
-     *
-     * @type {{transform_global: {matrix: ArrayLike<number>}}|undefined}
-     */
-    node: {
-        transform_global: {
-            matrix: ArrayLike<number>;
-        };
-    } | undefined;
-    /**
-     * Whether the table row is out of step with the fields above. Set it after changing anything;
-     * {@link EmitterRegistry#flush} clears it once the row has been staged for upload.
-     *
-     * @type {boolean}
-     */
-    dirty: boolean;
-    /**
-     * Point the emitter at a scene node, or at nothing.
-     *
-     * @param {{transform_global: {matrix: ArrayLike<number>}}} [node]
-     */
-    attach_to(node?: {
-        transform_global: {
-            matrix: ArrayLike<number>;
-        };
-    }): void;
-    /**
-     * Copy a world matrix into {@link transform} and mark the row for re-upload.
-     *
-     * @param {ArrayLike<number>} matrix 16-element column-major
-     */
-    set_transform(matrix: ArrayLike<number>): void;
-    /**
-     * Bind render channels to per-particle attributes of this emitter's effect, by attribute name.
-     * Channels left out of `channels` keep whatever they had; a channel that was never bound stays
-     * at {@link EMITTER_ATTRIBUTE_ABSENT}, which the passes read as "this emitter has no such
-     * attribute" — the render pass substitutes a default, the sort pass treats the particle as
-     * being at the origin.
-     *
-     * The record stores word offsets rather than names because that is what the render and sort
-     * passes index a particle record with; resolving here is the only place a name is involved.
-     *
-     * @param {Object<string,string>} channels channel name (see {@link EMITTER_RENDER_CHANNELS}) ->
-     *        attribute name in the effect's layout
-     */
-    bind_render(channels: {
-        [x: string]: string;
-    }): void;
-    /**
-     * This emitter as the value the emitter table stores — every field of
-     * {@link ../data/PARTICLE_EMITTER_STRUCT.js}, none omitted.
-     *
-     * Omitting one would not write zeros: the serializer skips absent fields, and table pages are
-     * recycled buffers, so a skipped field keeps whatever the previous tenant of the slot left
-     * there.
-     *
-     * @returns {object}
-     */
-    to_record(): object;
-    /**
-     * @readonly
-     * @type {boolean}
-     */
-    readonly isEmitter: boolean;
-}
-//# sourceMappingURL=Emitter.d.ts.map

package/src/shade/renderer/particles/runtime/Emitter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Emitter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/Emitter.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,sCAFU,MAAM,EAAE,CAIf;AAEH;;;;;;;;;;;;;;GAcG;AACH;IAqNI;;;;;;;;;;;;;;;;;OAiBG;IACH;QAbqD,MAAM,EAAhD;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAC;QAEN,SAAS,GAApC,UAAU,MAAM,CAAC;QACD,IAAI,GAApB,MAAM;QACU,UAAU,GAA1B,MAAM;QACU,KAAK,GAArB,MAAM;QACiD,MAAM,GAA7D;YAAC,MAAM,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAC;QACd,MAAM;gBAA9B,MAAM,GAAC,MAAM;;QACO,YAAY,GAAvC,UAAU,MAAM,CAAC;QACU,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACD,IAAI,GAApB,MAAM;QACJ,OAAO,CAoDnB;IAvRD;;;;;;OAMG;IACH,IAFU,MAAM,CAER;IAER;;;;OAIG;IACH,QAFU;QAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC;QAAC,OAAO,EAAE,OAAO,2BAA2B,EAAE,eAAe,CAAA;KAAC,CAE/H;IAEP;;;;;;OAMG;IACH,WAFU;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAErI;IAEV;;;OAGG;IACH,WAFU,YAAY,CAEiB;IAEvC;;;;;;;;OAQG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,eAFU,YAAY,CAEc;IAEpC;;OAEG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,cAFU,YAAY,CAEwB;IAE9C;;;OAGG;IACH,UAFU,YAAY,CAEc;IAEpC,+FAA+F;IAC/F,iBADW,MAAM,CAC0B;IAC3C,gDAAgD;IAChD,aADW,MAAM,CACsB;IACvC,uDAAuD;IACvD,cADW,MAAM,CACuB;IACxC,+DAA+D;IAC/D,iBADW,MAAM,CAC0B;IAC3C,gEAAgE;IAChE,cADW,MAAM,CACuB;IACxC,sFAAsF;IACtF,iBADW,MAAM,CAC0B;IAE3C;;;;;;OAMG;IACH,MAFU;QAAC,gBAAgB,EAAE;YAAC,MAAM,EAAE,UAAU,MAAM,CAAC,CAAA;SAAC,CAAA;KAAC,GAAC,SAAS,CAE9D;IAEL;;;;;OAKG;IACH,OAFU,OAAO,CAEJ;IAEb;;;;OAIG;IACH,iBAFW;QAAC,gBAAgB,EAAE;YAAC,MAAM,EAAE,UAAU,MAAM,CAAC,CAAA;SAAC,CAAA;KAAC,QAIzD;IAED;;;;OAIG;IACH,sBAFW,UAAU,MAAM,CAAC,QAO3B;IAED;;;;;;;;;;;;OAYG;IACH;YAHkB,MAAM,GAAC,MAAM;aA2B9B;IAED;;;;;;;;;OASG;IACH,aAFa,MAAM,CAiClB;IAyEL;;;OAGG;IACH,oBAFU,OAAO,CAEU;CAN1B"}

package/src/shade/renderer/particles/runtime/ParticleSpawnScheduler.d.ts

@@ -1,77 +0,0 @@
-/**
- * CPU-side spawn scheduling. Each frame it turns per-emitter spawn rates (and the cull/sleep state)
- * into a flat list of spawn requests (packed emitter id + batch fraction per particle to create,
- * see {@link spawn_request_pack}) that the emit pass consumes. Emitters are few and CPU-authored,
- * so deciding *how many* to spawn on the CPU is cheap and keeps the GPU emit pass a simple
- * "one thread per new particle".
- *
- * Sleep-when-culled: a culled emitter accumulates sleep time and spawns nothing. When it becomes
- * visible again it emits a bounded catch-up burst approximating the spawns it missed, mirroring the
- * catch-up in meep's ParticularEngine (but capped so a long occlusion can't spike the pool).
- *
- * State is keyed by {@link Emitter#id}, not by position in the emitter array: ids are stable and
- * sparse, positions are neither, and a positional key would silently hand a new emitter the
- * accumulator and sleep debt of whichever one used to sit at its index.
- */
-export class ParticleSpawnScheduler {
-    /**
-     * @param {object} [options]
-     * @param {number} [options.max_catchup_seconds] cap on how much missed time a wake burst covers
-     */
-    constructor({ max_catchup_seconds }?: {
-        max_catchup_seconds?: number;
-    });
-    /**
-     * Cap on how much missed time a wake-up burst covers, in seconds.
-     * @type {number}
-     */
-    max_catchup_seconds: number;
-    /**
-     * Emitter id -> its bookkeeping.
-     * @type {Map<number, ParticleSpawnState>}
-     */
-    state: Map<number, ParticleSpawnState>;
-    /**
-     * Drop bookkeeping for an emitter that is no longer registered, so a later emitter reusing that
-     * table row starts from zero instead of inheriting a stranger's accumulator.
-     *
-     * @param {number} id
-     */
-    forget(id: number): void;
-    /**
-     * Produce this frame's spawn requests.
-     *
-     * @param {Iterable<import("./Emitter.js").Emitter>} emitters the live emitters
-     * @param {number} dt seconds
-     * @param {(emitter: import("./Emitter.js").Emitter) => boolean} [is_visible] cull predicate
-     *        (default: all visible)
-     * @param {number} [capacity] optional hard cap on total requests this frame
-     * @returns {Uint32Array} flat list of packed spawn requests (emitter id + batch fraction),
-     *     one per particle to spawn — see {@link spawn_request_pack}
-     */
-    tick(emitters: Iterable<import("./Emitter.js").Emitter>, dt: number, is_visible?: (emitter: import("./Emitter.js").Emitter) => boolean, capacity?: number): Uint32Array;
-    #private;
-}
-/**
- * Per-emitter spawn bookkeeping, carried across frames.
- */
-declare class ParticleSpawnState {
-    /**
-     * Fractional particles owed. A rate of 0.5/s at 60fps owes 1/120 of a particle per frame; the
-     * whole part is emitted and the remainder carried, so the emitter fires once every two seconds
-     * rather than never.
-     * @type {number}
-     */
-    accumulator: number;
-    /**
-     * Seconds spent culled since the emitter was last visible.
-     * @type {number}
-     */
-    sleep_time: number;
-    /**
-     * @type {boolean}
-     */
-    was_visible: boolean;
-}
-export {};
-//# sourceMappingURL=ParticleSpawnScheduler.d.ts.map

package/src/shade/renderer/particles/runtime/ParticleSpawnScheduler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ParticleSpawnScheduler.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/ParticleSpawnScheduler.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;GAcG;AACH;IAcI;;;OAGG;IACH;QAF4B,mBAAmB,GAApC,MAAM;OAIhB;IAlBD;;;OAGG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,OAFU,IAAI,MAAM,EAAE,kBAAkB,CAAC,CAEvB;IA2BlB;;;;;OAKG;IACH,WAFW,MAAM,QAIhB;IAED;;;;;;;;;;OAUG;IACH,eARW,SAAS,OAAO,cAAc,EAAE,OAAO,CAAC,MACxC,MAAM,yBACI,OAAO,cAAc,EAAE,OAAO,KAAK,OAAO,aAEpD,MAAM,GACJ,WAAW,CA6CvB;;CACJ;AA9ID;;GAEG;AACH;IACI;;;;;OAKG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;OAEG;IACH,aAFU,OAAO,CAEE;CACtB"}

package/src/shade/renderer/particles/runtime/ProgramArena.js

@@ -1,155 +0,0 @@
-import {
-    PARTICLE_PROGRAM_CODE_BASE_WORD,
-    PARTICLE_PROGRAM_HEADER_WORDS,
-    PARTICLE_VM_INSTRUCTION_WORDS,
-} from "../ParticleConstants.js";
-
-/**
- * Packs many compiled {@link ../isa/ParticleProgram.js} programs into one shared buffer — a header,
- * every program's constant pool, then every program's instruction words — and hands back the
- * offsets each emitter records.
- *
- * Data before code, behind a four-word header whose first word says where the code starts: the VM
- * reads both sections through one binding (a storage buffer per stage is not free, and code and
- * constants are read together), and an emitter's constant pool sits next to the pools of the
- * programs it shares a wave with.
- *
- * Because VM instructions carry no absolute code addresses (control flow is branchless) and
- * constant references are program-local (the VM adds the emitter's `constant_offset`), programs
- * can be concatenated at any offset. INIT and UPDATE sections are laid out back-to-back per program.
- */
-export class ProgramArena {
-
-    /**
-     * Flat instruction words, every program's INIT and UPDATE sections concatenated.
-     * @type {number[]}
-     */
-    instruction_words = [];
-
-    /**
-     * Flat constant words (f32 bit patterns), every program's pool concatenated.
-     * @type {number[]}
-     */
-    constant_words = [];
-
-    /**
-     * Running instruction index — INIT/UPDATE offsets are in these units.
-     * @type {number}
-     */
-    instruction_count = 0;
-
-    /**
-     * Running constant word index — the pool is addressed by word, so a scalar literal costs one
-     * rather than the four a `vec4` entry used to.
-     * @type {number}
-     */
-    constant_word_count = 0;
-
-    /**
-     * Content key -> the placement the first identical program got.
-     * @type {Map<string, {init_offset: number, init_count: number, update_offset: number, update_count: number, constant_offset: number, program_id: number}>}
-     */
-    programs = new Map();
-
-    /**
-     * Number of distinct programs in the arena — and therefore the number of buckets the
-     * simulation-order pass histograms into. Program ids are dense in `[0, program_count)`.
-     * @returns {number}
-     */
-    get program_count() {
-        return this.programs.size;
-    }
-
-    /**
-     * Append a program, or hand back the placement an identical one already has.
-     *
-     * Deduplication is by CONTENT, not object identity: two emitters that authored the same graph
-     * separately compile to distinct {@link ParticleProgram} objects holding the same bytecode, and
-     * they should still land in one simulation bucket. Emitters are few and long-lived, so hashing
-     * the words is not a cost worth avoiding.
-     *
-     * The `program_id` it returns is what the emitter record carries and what the coherence pass
-     * buckets on. Keying on the emitter index instead would be simpler but strictly worse: N
-     * emitters running one shared effect would become N buckets, each padded to a whole workgroup,
-     * which both wastes lanes and splits a run that was already program-coherent.
-     *
-     * @param {import("../isa/ParticleProgram.js").ParticleProgram} program
-     * @returns {{init_offset: number, init_count: number, update_offset: number, update_count: number, constant_offset: number, program_id: number}}
-     */
-    add(program) {
-        const key = program_content_key(program);
-
-        const existing = this.programs.get(key);
-        if (existing !== undefined) {
-            return existing;
-        }
-
-        const init_offset = this.instruction_count;
-        this.#append_instructions(program.init);
-        const init_count = program.init_instruction_count;
-
-        const update_offset = this.instruction_count;
-        this.#append_instructions(program.update);
-        const update_count = program.update_instruction_count;
-
-        const constant_offset = this.constant_word_count;
-        const constant_u32 = new Uint32Array(program.constants.buffer, program.constants.byteOffset, program.constants.length);
-        for (let i = 0; i < constant_u32.length; i++) {
-            this.constant_words.push(constant_u32[i]);
-        }
-        this.constant_word_count += program.constant_word_count;
-
-        const placement = {
-            init_offset, init_count, update_offset, update_count, constant_offset,
-            program_id: this.programs.size,
-        };
-        this.programs.set(key, placement);
-
-        return placement;
-    }
-
-    /** @param {Uint32Array} words */
-    #append_instructions(words) {
-        for (let i = 0; i < words.length; i++) {
-            this.instruction_words.push(words[i]);
-        }
-        this.instruction_count += words.length / PARTICLE_VM_INSTRUCTION_WORDS;
-    }
-
-    /**
-     * The packed buffer: `[header][constants][code]`. Word {@link PARTICLE_PROGRAM_CODE_BASE_WORD} of
-     * the header is the word index the code starts at, which moves every time a program's constants
-     * are appended — the emitter records never carry it, they carry offsets into each section.
-     *
-     * @returns {Uint32Array}
-     */
-    build_program_buffer() {
-        const constants = this.constant_words;
-        const code = this.instruction_words;
-
-        const code_base = PARTICLE_PROGRAM_HEADER_WORDS + constants.length;
-        const buffer = new Uint32Array(code_base + code.length);
-
-        buffer[PARTICLE_PROGRAM_CODE_BASE_WORD] = code_base;
-        buffer.set(constants, PARTICLE_PROGRAM_HEADER_WORDS);
-        buffer.set(code, code_base);
-
-        return buffer;
-    }
-}
-
-/**
- * A key that is equal exactly when two programs would execute identically.
- *
- * Constants are keyed by their `u32` bit patterns rather than their float values, so `-0` and `0`
- * — which stringify the same but differ in the buffer the shader reads — stay distinct.
- *
- * @param {import("../isa/ParticleProgram.js").ParticleProgram} program
- * @returns {string}
- */
-function program_content_key(program) {
-    const constants = program.constants;
-    const constant_u32 = new Uint32Array(constants.buffer, constants.byteOffset, constants.length);
-
-    return `${program.register_count}|${program.init.join(",")}|${program.update.join(",")}|${constant_u32.join(",")}`;
-}

package/src/shade/renderer/particles/runtime/emitter_database_image.d.ts

@@ -1,15 +0,0 @@
-/**
- * The emitter table as the `array<u32>` a shader binds, built on the CPU.
- *
- * For the WGSL emulator: on a device the rows get there through the database's upload dispatch, and
- * the software device records dispatches without running them, so a spec that wants to run
- * `shader_particle_emit` (or simulate, or sort, or the bucket histogram) over real emitters has no
- * other way to hand it their bytes. See
- * {@link ../../buffer/table/gpu_database_emulator_image.js}.
- *
- * @param {Iterable<import("./Emitter.js").Emitter>} emitters registered emitters — each one's
- *        {@link Emitter#id} is the row it lands on, so the layout matches what the shaders index
- * @returns {Uint32Array}
- */
-export function emitter_database_image(emitters: Iterable<import("./Emitter.js").Emitter>): Uint32Array;
-//# sourceMappingURL=emitter_database_image.d.ts.map

package/src/shade/renderer/particles/runtime/emitter_database_image.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"emitter_database_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/emitter_database_image.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,iDAJW,SAAS,OAAO,cAAc,EAAE,OAAO,CAAC,GAEtC,WAAW,CAMvB"}

package/src/shade/renderer/particles/runtime/spawn_request_encoding.d.ts

@@ -1,34 +0,0 @@
-/**
- * @param {number} emitter_index
- * @param {number} fraction in [0, 1]
- * @returns {number} packed u32
- */
-export function spawn_request_pack(emitter_index: number, fraction: number): number;
-/**
- * @param {number} packed
- * @returns {number} emitter index
- */
-export function spawn_request_emitter(packed: number): number;
-/**
- * @param {number} packed
- * @returns {number} batch fraction in [0, 1]
- */
-export function spawn_request_fraction(packed: number): number;
-/**
- * Encoding of one spawn request as a single `u32`.
- *
- * The emit pass needs two things per request: which emitter owns the new particle, and the
- * particle's fraction within its emitter's batch this frame (`i / spawn_count`, the SPAWN_FRACTION
- * VM builtin — used to spread a batch along spawn curves). Packing both into the one `u32` keeps
- * the request stream a single buffer with unchanged upload paths.
- *
- * Layout: low 16 bits = emitter index, high 16 bits = batch fraction quantized to [0, 0xFFFF].
- * The WGSL emit shader mirrors this exactly (shader_particle_emit).
- */
-/** @type {number} */
-export const SPAWN_REQUEST_EMITTER_MASK: number;
-/** @type {number} */
-export const SPAWN_REQUEST_FRACTION_SHIFT: number;
-/** @type {number} */
-export const SPAWN_REQUEST_FRACTION_MAX: number;
-//# sourceMappingURL=spawn_request_encoding.d.ts.map

package/src/shade/renderer/particles/runtime/spawn_request_encoding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spawn_request_encoding.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/spawn_request_encoding.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AACH,kDAJW,MAAM,YACN,MAAM,GACJ,MAAM,CASlB;AAED;;;GAGG;AACH,8CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;GAGG;AACH,+CAHW,MAAM,GACJ,MAAM,CAIlB;AAjDD;;;;;;;;;;GAUG;AAEH,qBAAqB;AACrB,yCADW,MAAM,CACgC;AAEjD,qBAAqB;AACrB,2CADW,MAAM,CAC8B;AAE/C,qBAAqB;AACrB,yCADW,MAAM,CACgC"}