@woosh/meep-engine 3.15.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/data/PARTICLE_EMITTER_LAYOUT.js

@@ -1,214 +0,0 @@
-/**
- * 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 = Object.freeze({
-    SPAWN_OFFSET: 0,      // u32 — first instruction of the SPAWN program (instruction units)
-    SPAWN_COUNT: 1,       // u32 — SPAWN instruction count
-    UPDATE_OFFSET: 2,     // u32 — first instruction of the UPDATE program
-    UPDATE_COUNT: 3,      // u32 — UPDATE instruction count
-    CONSTANT_OFFSET: 4,   // u32 — base into the shared constant pool (vec4 units)
-    SEED: 5,              // u32 — base RNG seed
-    FLAGS: 6,             // u32 — see EMITTER_FLAG
-    SPAWN_RATE: 7,        // f32 — continuous emission rate (particles/second)
-
-    TRANSFORM: 8,         // mat4x4<f32> — emitter local-to-world (16 words, 8..23)
-
-    BOUNDS_CENTER: 24,    // vec3<f32> — local-space bounding sphere centre (24..26)
-    BOUNDS_RADIUS: 27,    // f32 — bounding sphere radius
-
-    RENDER_POSITION: 28,  // u32 — attribute word offset of world position (or ABSENT)
-    RENDER_SIZE: 29,      // u32 — attribute word offset of size
-    RENDER_COLOR: 30,     // u32 — attribute word offset of rgba colour
-    RENDER_ROTATION: 31,  // u32 — attribute word offset of roll angle (radians)
-    RENDER_FRAME: 32,     // u32 — attribute word offset of flipbook frame index
-
-    ATLAS_REGION: 33,     // vec4<f32> — uv offset .xy + uv scale .zw (33..36)
-    FLIPBOOK: 37,         // vec2<f32> — grid columns, rows (37..38)
-
-    RENDER_VELOCITY: 39,  // u32 — attribute word offset of velocity (STRETCHED projection; or ABSENT)
-
-    /**
-     * 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 = 0xffffffff;
-
-/** Sentinel for "not attached to a scene node". */
-export const EMITTER_ATTACH_NONE = 0xffffffff;
-
-/**
- * Emitter flag bits. Blend mode occupies bits [4,6), projection mode bits [6,9).
- */
-export const EMITTER_FLAG = Object.freeze({
-    LIGHTING: 1 << 0,      // forward-shade billboards with scene lighting
-    SOFT_DEPTH: 1 << 1,    // fade against scene depth
-    SORT: 1 << 2,          // depth-sort this emitter's particles for correct transparency
-    CULL: 1 << 3,          // frustum + occlusion simulation culling (sleep when culled)
-});
-
-/** Blend modes (stored in flag bits [4,6)). All expressed by one premultiplied blend pipeline. */
-export const EMITTER_BLEND = Object.freeze({
-    ALPHA: 0,      // premultiplied alpha (normal transparency)
-    ADDITIVE: 1,   // additive (emissive glow)
-    PREMULTIPLIED: 2, // colour already premultiplied by alpha upstream
-});
-
-const BLEND_SHIFT = 4;
-const BLEND_MASK = 0b11 << BLEND_SHIFT;
-
-/** Projection / orientation modes (stored in flag bits [6,9)). */
-export const EMITTER_PROJECTION = Object.freeze({
-    BILLBOARD: 0,          // face the camera
-    STRETCHED: 1,          // billboard stretched along velocity
-    HORIZONTAL: 2,         // lie flat on the ground plane (XZ)
-    VERTICAL: 3,           // axis-locked to world up, yaw toward camera
-    FACING_WORLD: 4,       // oriented by the particle's own rotation attribute in world space
-});
-
-const PROJECTION_SHIFT = 6;
-const PROJECTION_MASK = 0b111 << PROJECTION_SHIFT;
-
-/**
- * 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 = false, soft_depth = false, sort = false, cull = false, blend = EMITTER_BLEND.ALPHA, projection = EMITTER_PROJECTION.BILLBOARD } = {}) {
-    let flags = 0;
-    if (lighting) flags |= EMITTER_FLAG.LIGHTING;
-    if (soft_depth) flags |= EMITTER_FLAG.SOFT_DEPTH;
-    if (sort) flags |= EMITTER_FLAG.SORT;
-    if (cull) flags |= EMITTER_FLAG.CULL;
-    flags |= (blend << BLEND_SHIFT) & BLEND_MASK;
-    flags |= (projection << PROJECTION_SHIFT) & PROJECTION_MASK;
-    return flags >>> 0;
-}
-
-/** @param {number} flags @returns {number} the blend mode */
-export function emitter_flags_blend(flags) {
-    return (flags & BLEND_MASK) >>> BLEND_SHIFT;
-}
-
-/** @param {number} flags @returns {number} the projection mode */
-export function emitter_flags_projection(flags) {
-    return (flags & PROJECTION_MASK) >>> PROJECTION_SHIFT;
-}
-
-/** Shift/mask constants exposed for the WGSL reader to interpolate. */
-export const EMITTER_FLAG_ENCODING = Object.freeze({
-    BLEND_SHIFT, BLEND_MASK, PROJECTION_SHIFT, PROJECTION_MASK,
-});
-
-/**
- * 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, f32, index, def) {
-    const base = index * EMITTER_STRIDE;
-
-    u32[base + EMITTER_FIELD.SPAWN_OFFSET] = def.spawn_offset >>> 0;
-    u32[base + EMITTER_FIELD.SPAWN_COUNT] = def.spawn_count >>> 0;
-    u32[base + EMITTER_FIELD.UPDATE_OFFSET] = def.update_offset >>> 0;
-    u32[base + EMITTER_FIELD.UPDATE_COUNT] = def.update_count >>> 0;
-    u32[base + EMITTER_FIELD.CONSTANT_OFFSET] = def.constant_offset >>> 0;
-    u32[base + EMITTER_FIELD.SEED] = def.seed >>> 0;
-    u32[base + EMITTER_FIELD.FLAGS] = def.flags >>> 0;
-    f32[base + EMITTER_FIELD.SPAWN_RATE] = def.spawn_rate ?? 0;
-
-    const transform = def.transform ?? IDENTITY_MAT4;
-    for (let i = 0; i < 16; i++) {
-        f32[base + EMITTER_FIELD.TRANSFORM + i] = transform[i];
-    }
-
-    const bounds = def.bounds_center ?? [0, 0, 0];
-    f32[base + EMITTER_FIELD.BOUNDS_CENTER] = bounds[0] ?? 0;
-    f32[base + EMITTER_FIELD.BOUNDS_CENTER + 1] = bounds[1] ?? 0;
-    f32[base + EMITTER_FIELD.BOUNDS_CENTER + 2] = bounds[2] ?? 0;
-    f32[base + EMITTER_FIELD.BOUNDS_RADIUS] = def.bounds_radius ?? 1;
-
-    const render = def.render ?? {};
-    u32[base + EMITTER_FIELD.RENDER_POSITION] = (render.position ?? EMITTER_ATTRIBUTE_ABSENT) >>> 0;
-    u32[base + EMITTER_FIELD.RENDER_SIZE] = (render.size ?? EMITTER_ATTRIBUTE_ABSENT) >>> 0;
-    u32[base + EMITTER_FIELD.RENDER_COLOR] = (render.color ?? EMITTER_ATTRIBUTE_ABSENT) >>> 0;
-    u32[base + EMITTER_FIELD.RENDER_ROTATION] = (render.rotation ?? EMITTER_ATTRIBUTE_ABSENT) >>> 0;
-    u32[base + EMITTER_FIELD.RENDER_FRAME] = (render.frame ?? EMITTER_ATTRIBUTE_ABSENT) >>> 0;
-    u32[base + EMITTER_FIELD.RENDER_VELOCITY] = (render.velocity ?? EMITTER_ATTRIBUTE_ABSENT) >>> 0;
-
-    const atlas = def.atlas_region ?? [0, 0, 1, 1];
-    for (let i = 0; i < 4; i++) {
-        f32[base + EMITTER_FIELD.ATLAS_REGION + i] = atlas[i];
-    }
-    const flipbook = def.flipbook ?? [1, 1];
-    f32[base + EMITTER_FIELD.FLIPBOOK] = flipbook[0];
-    f32[base + EMITTER_FIELD.FLIPBOOK + 1] = flipbook[1];
-
-    u32[base + EMITTER_FIELD.PROGRAM_ID] = (def.program_id ?? 0) >>> 0;
-}
-
-/**
- * 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, index, matrix) {
-    const base = index * EMITTER_STRIDE + EMITTER_FIELD.TRANSFORM;
-    for (let i = 0; i < 16; i++) {
-        f32[base + i] = matrix[i];
-    }
-}
-
-const IDENTITY_MAT4 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];

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

@@ -1 +0,0 @@
-{"version":3,"file":"particle_prototype.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/particle_prototype.js"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH;IAL4B,UAAU,GAA3B,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,eAAe,GAAhC,MAAM;;YACK,cAAc;YAAU,MAAM;aAAW,MAAM;EA2GpE;AAED;;;;GAIG;AACH;YAFsB,cAAc;YAAU,MAAM;aAAW,MAAM;EAcpE;AAED;;;;;;;;;;;;;;;GAeG;AACH,0CALW,OAAO,wBAAwB,EAAE,iBAAiB;IAEjC,IAAI,GAArB,MAAM;;UACG,MAAM;WAAS,MAAM;EAWxC;+BAhL8B,4BAA4B"}

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

@@ -1,43 +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 index + 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).
- */
-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;
-    });
-    max_catchup_seconds: number;
-    /** @type {Array<{accumulator: number, sleep_time: number, was_visible: boolean}>} */
-    state: Array<{
-        accumulator: number;
-        sleep_time: number;
-        was_visible: boolean;
-    }>;
-    /** Ensure per-emitter state exists for `count` emitters. */
-    ensure(count: any): void;
-    /**
-     * Produce this frame's spawn requests.
-     *
-     * @param {Array<{spawn_rate: number}>} emitters
-     * @param {number} dt seconds
-     * @param {(index: number) => 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 index + batch fraction),
-     *     one per particle to spawn — see {@link spawn_request_pack}
-     */
-    tick(emitters: Array<{
-        spawn_rate: number;
-    }>, dt: number, is_visible?: (index: number) => boolean, capacity?: number): Uint32Array;
-}
-//# 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":"AAEA;;;;;;;;;;GAUG;AACH;IACI;;;OAGG;IACH;QAF4B,mBAAmB,GAApC,MAAM;OAMhB;IAHG,4BAA8C;IAC9C,qFAAqF;IACrF,OADW,MAAM;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,OAAO,CAAA;KAAC,CAAC,CAClE;IAGnB,4DAA4D;IAC5D,yBAIC;IAED;;;;;;;;;OASG;IACH,eAPW,MAAM;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC,MAC3B,MAAM,uBACE,MAAM,KAAK,OAAO,aAC1B,MAAM,GACJ,WAAW,CA8CvB;CACJ"}

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

@@ -1,86 +0,0 @@
-import { spawn_request_pack } from "./spawn_request_encoding.js";
-
-/**
- * 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 index + 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).
- */
-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 = 1.0 } = {}) {
-        this.max_catchup_seconds = max_catchup_seconds;
-        /** @type {Array<{accumulator: number, sleep_time: number, was_visible: boolean}>} */
-        this.state = [];
-    }
-
-    /** Ensure per-emitter state exists for `count` emitters. */
-    ensure(count) {
-        while (this.state.length < count) {
-            this.state.push({ accumulator: 0, sleep_time: 0, was_visible: true });
-        }
-    }
-
-    /**
-     * Produce this frame's spawn requests.
-     *
-     * @param {Array<{spawn_rate: number}>} emitters
-     * @param {number} dt seconds
-     * @param {(index: number) => 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 index + batch fraction),
-     *     one per particle to spawn — see {@link spawn_request_pack}
-     */
-    tick(emitters, dt, is_visible = () => true, capacity = Infinity) {
-        this.ensure(emitters.length);
-        const requests = [];
-
-        for (let i = 0; i < emitters.length; i++) {
-            const rate = emitters[i].spawn_rate ?? 0;
-            const state = this.state[i];
-
-            if (!is_visible(i)) {
-                state.sleep_time += dt;
-                state.was_visible = false;
-                continue;
-            }
-
-            // Waking up: add a bounded catch-up for the time spent culled.
-            if (!state.was_visible && state.sleep_time > 0) {
-                const catchup = Math.min(state.sleep_time, this.max_catchup_seconds);
-                state.accumulator += rate * catchup;
-                state.sleep_time = 0;
-            }
-            state.was_visible = true;
-
-            state.accumulator += rate * dt;
-            const count = Math.floor(state.accumulator);
-
-            // Emit up to `count`, but stop at the per-frame capacity. Subtract only what was actually
-            // emitted so demand the cap dropped this frame carries over instead of being lost.
-            // The batch size is resolved BEFORE pushing so each request can carry its per-emitter
-            // batch fraction n / spawned (the SPAWN_FRACTION VM builtin's contract).
-            const spawned = Math.min(count, Math.max(0, capacity - requests.length));
-            for (let n = 0; n < spawned; n++) {
-                requests.push(spawn_request_pack(i, n / spawned));
-            }
-            state.accumulator -= spawned;
-
-            // Bound the carry-over so a permanently over-subscribed emitter can't grow the
-            // accumulator without limit (the GPU emit pass also drops spawns when the pool is full).
-            if (state.accumulator > capacity) {
-                state.accumulator = capacity;
-            }
-        }
-
-        return new Uint32Array(requests);
-    }
-}

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

@@ -1,115 +0,0 @@
-import { PARTICLE_VM_INSTRUCTION_WORDS } from "../ParticleConstants.js";
-
-/**
- * Packs many compiled {@link ../isa/ParticleProgram.js} programs into two shared buffers — one of
- * instruction words, one of constant words — and hands back the offsets each emitter records.
- *
- * Because VM instructions carry no absolute code addresses (control flow is branchless) and
- * constant references are program-local (the shader adds the emitter's `constant_offset`), programs
- * can be concatenated at any offset. SPAWN and UPDATE sections are laid out back-to-back per program.
- */
-export class ProgramArena {
-    constructor() {
-        /** @type {number[]} flat instruction words */
-        this.instruction_words = [];
-        /** @type {number[]} flat constant words (f32 bit patterns) */
-        this.constant_words = [];
-        /** @type {number} running instruction index (SPAWN/UPDATE offsets are in these units) */
-        this.instruction_count = 0;
-        /** @type {number} running vec4 constant index */
-        this.constant_count = 0;
-        /** @type {Map<string, object>} content key -> the placement the first identical program got */
-        this.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 {{spawn_offset: number, spawn_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 spawn_offset = this.instruction_count;
-        this.#append_instructions(program.spawn);
-        const spawn_count = program.spawn_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_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_count += program.constant_count;
-
-        const placement = {
-            spawn_offset, spawn_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;
-    }
-
-    /** @returns {Uint32Array} the packed instruction buffer (at least length 1) */
-    build_instruction_buffer() {
-        return new Uint32Array(this.instruction_words.length > 0 ? this.instruction_words : [0]);
-    }
-
-    /** @returns {Uint32Array} the packed constant buffer (at least length 4 for one vec4) */
-    build_constant_buffer() {
-        return new Uint32Array(this.constant_words.length > 0 ? this.constant_words : [0, 0, 0, 0]);
-    }
-}
-
-/**
- * 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.spawn.join(",")}|${program.update.join(",")}|${constant_u32.join(",")}`;
-}

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