@woosh/meep-engine 3.14.6 → 3.16.0

package/src/core/model/node-graph/visual/layout/ConnectionEndpointLayoutSpec.js

@@ -1,40 +0,0 @@
-export class ConnectionEndpointLayoutSpec {
-
-    /**
-     *
-     * @type {BoxLayoutSpec}
-     */
-    box = null;
-
-    /**
-     * Local offset inside the box where connection is attached
-     * @type {Vector2}
-     */
-    point = null;
-
-
-    /**
-     *
-     * @param {Vector2} result
-     */
-    computePosition(result) {
-        result.set(
-            this.point.x + this.box.x0,
-            this.point.y + this.box.y0
-        );
-    }
-
-    /**
-     * @param {AABB2} box
-     * @param {Vector2} point
-     * @returns {ConnectionEndpointLayoutSpec}
-     */
-    static from(box, point) {
-        const r = new ConnectionEndpointLayoutSpec();
-
-        r.box = box;
-        r.point = point;
-
-        return r;
-    }
-}

package/src/core/model/node-graph/visual/layout/ConnectionLayoutSpec.js

@@ -1,28 +0,0 @@
-export class ConnectionLayoutSpec {
-
-    /**
-     *
-     * @type {ConnectionEndpointLayoutSpec}
-     */
-    source = null;
-    /**
-     *
-     * @type {ConnectionEndpointLayoutSpec}
-     */
-    target = null;
-
-
-    /**
-     * @param {ConnectionEndpointLayoutSpec} source
-     * @param {ConnectionEndpointLayoutSpec} target
-     * @returns {ConnectionLayoutSpec}
-     */
-    static from(source, target) {
-        const r = new ConnectionLayoutSpec();
-
-        r.source = source;
-        r.target = target;
-
-        return r;
-    }
-}

package/src/engine/ecs/util/hideEntityGracefully.js

@@ -1,196 +0,0 @@
-import {
-    TransitionPropertyVectorXBehavior
-} from "../../../../../model/game/story/behaviors/generic/TransitionPropertyVectorXBehavior.js";
-import { TweenVector1Behavior } from "../../../../../model/game/util/behavior/TweenVector1Behavior.js";
-import { TweenVector3Behavior } from "../../../../../model/game/util/behavior/TweenVector3Behavior.js";
-import { max2 } from "../../../core/math/max2.js";
-import { min2 } from "../../../core/math/min2.js";
-import { Light } from "../../graphics/ecs/light/Light.js";
-import { SGMesh, SGMeshFlags } from "../../graphics/ecs/mesh-v2/aggregate/SGMesh.js";
-import Trail2D from "../../graphics/ecs/trail2d/Trail2D.js";
-import { Trail2DFlags } from "../../graphics/ecs/trail2d/Trail2DFlags.js";
-import { ParticleEmitter } from "../../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
-import { ParticleEmitterFlag } from "../../graphics/particles/particular/engine/emitter/ParticleEmitterFlag.js";
-import { SequenceBehavior } from "../../intelligence/behavior/composite/SequenceBehavior.js";
-import { BehaviorComponent } from "../../intelligence/behavior/ecs/BehaviorComponent.js";
-import { DieBehavior } from "../../intelligence/behavior/ecs/DieBehavior.js";
-import { DelayBehavior } from "../../intelligence/behavior/util/DelayBehavior.js";
-import { AudioEmitter } from "../../sound/ecs/audio/AudioEmitter.js";
-import { Transform } from "../transform/Transform.js";
-
-/**
- * @readonly
- * @type {number}
- */
-const SHUTDOWN_GRACE_PERIOD = 60;
-
-/**
- *
- * @type {Map<Class|function, (component: T, entity?: Entity, createEntity?: function, createEntityContext?: *) => number>}
- */
-const component_shutdown = new Map();
-
-/**
- * @template T
- * @param {Class<T>} type
- * @param {(component: T, entity?: Entity, createEntity?: function, createEntityContext?: *) => number} method
- */
-function addShutdown(type, method) {
-    component_shutdown.set(type, method);
-}
-
-addShutdown(ParticleEmitter, emitter => {
-
-    //stop emission
-    emitter.clearFlag(ParticleEmitterFlag.Emitting);
-
-    //figure out how long the emitter should stay alive
-    const maxLife = emitter.computeMaxEmittingParticleLife(SHUTDOWN_GRACE_PERIOD);
-
-    return maxLife;
-});
-
-addShutdown(Trail2D, trail => {
-    trail.clearFlag(Trail2DFlags.Spawning);
-
-    return trail.maxAge;
-});
-
-addShutdown(SGMesh, (mesh, builder, createEntity, createEntityThisArg) => {
-
-    /**
-     *
-     * @type {Transform}
-     */
-    const transform = builder.getComponent(Transform);
-
-    let delay = 0;
-
-    if (mesh !== null && transform !== null) {
-
-        /*
-         Loaded only. The component this used to read carried an `InView` flag a CPU culling pass
-         wrote, and §4.5 retires that pass — nothing on either renderer can say whether an entity is
-         on screen now, so what is left is whether there is a model to shrink at all.
-        */
-        if (mesh.getFlag(SGMeshFlags.Loaded) && !transform.scale.isZero()) {
-            const scale = new TweenVector3Behavior();
-
-            scale.startValue.copy(transform.scale);
-            scale.targetValue.set(0, 0, 0);
-            scale.target = transform.scale;
-
-            scale.duration = 0.2;
-
-            delay = max2(scale.duration, delay);
-
-            const eb = createEntity.call(createEntityThisArg);
-
-            eb.add(BehaviorComponent.from(SequenceBehavior.from([
-                scale,
-                DieBehavior.create()
-            ])));
-
-        } else {
-            transform.scale.set(0, 0, 0);
-        }
-
-    }
-
-
-    return delay;
-});
-
-addShutdown(Light, (light, builder, createEntity, createEntityThisArg) => {
-
-
-    let delay = 0.2;
-
-
-    const eb = createEntity.call(createEntityThisArg);
-
-    eb.add(BehaviorComponent.from(SequenceBehavior.from([
-        TransitionPropertyVectorXBehavior.from({
-            component: 'Light',
-            path: 'intensity',
-            target: [0],
-            duration: delay,
-            entity: builder.id
-        }),
-        DieBehavior.create()
-    ])));
-
-    return delay;
-});
-
-addShutdown(AudioEmitter, (audioEmitter, builder, createEntity, createEntityThisArg) => {
-    // `autoplay` is the "is anything actually sounding" test: a non-autoplay emitter is inert —
-    // AudioEmitterSystem never played it — so there is nothing to fade out. A live `volume` write
-    // reaches the instance gain on both play routes, managed and direct, so tweening the component is
-    // all this has to do.
-    if (audioEmitter.volume.getValue() <= 0 || !audioEmitter.autoplay) {
-        return 0;
-    }
-
-    const setVolume = new TweenVector1Behavior();
-
-    setVolume.startValue = audioEmitter.volume.getValue();
-    setVolume.targetValue = 0;
-
-    setVolume.target = audioEmitter.volume;
-
-    // the sound keeps playing through the grace period and fades over its last 2.7 seconds
-    setVolume.duration = 2.7;
-
-    const eb = createEntity.call(createEntityThisArg);
-
-    eb.add(BehaviorComponent.from(SequenceBehavior.from([
-        DelayBehavior.from(SHUTDOWN_GRACE_PERIOD - setVolume.duration),
-        setVolume,
-        DieBehavior.create()
-    ])));
-
-    return SHUTDOWN_GRACE_PERIOD;
-});
-
-/**
- *
- * @param {Entity} builder
- * @param {function():Entity} createEntity
- * @param {*} [createEntityThisArg]
- * @return {number} duration in seconds until the entity is completely hidden
- */
-export function hideEntityGracefully(builder, createEntity, createEntityThisArg) {
-    if (!builder.isBuilt) {
-        // already destroyed
-        return 0;
-    }
-
-    let delay = 0;
-
-    const components = builder.components;
-
-    const component_count = components.length;
-
-    for (let i = 0; i < component_count; i++) {
-        const component = components[i];
-
-        const shutdown_method = component_shutdown.get(Object.getPrototypeOf(component).constructor);
-
-        if (shutdown_method === undefined) {
-            continue;
-        }
-
-        const sd = shutdown_method(component, builder, createEntity, createEntityThisArg);
-
-        if (Number.isNaN(sd) || !Number.isFinite(sd)) {
-            continue;
-        }
-
-        delay = max2(sd, delay);
-    }
-
-    delay = min2(delay, SHUTDOWN_GRACE_PERIOD);
-
-    return delay;
-}

package/src/shade/renderer/particles/cull/chunk_particle_cull.js

@@ -1,38 +0,0 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-/**
- * Frustum culling math for emitter simulation culling (the optional, flagged "sleep when culled"
- * feature). A bounding sphere is visible unless it lies fully outside any frustum plane. Planes
- * follow the engine's Gribb-Hartmann convention (world space, `dot(n, p) + d >= 0` inside).
- *
- * The occlusion half of the test reuses the engine's HiZ query
- * (`src/webgpu/renderer/shader/chunk/depth/chunk_query_depth_from_screen_space_bb.js`) in the cull pass;
- * this chunk holds the emulator-testable frustum math.
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_cull = CodeChunk.from(
-    /* language=wgsl */
-    `
-// A sphere is on the inside (or straddling) a plane if its centre is no more than 'radius' behind it.
-fn particle_plane_sphere_visible(plane : vec4<f32>, center : vec3<f32>, radius : f32) -> bool {
-    return dot(plane.xyz, center) + plane.w >= -radius;
-}
-
-// Branch-free 6-plane frustum test against a bounding sphere.
-fn particle_sphere_in_frustum(
-    center : vec3<f32>,
-    radius : f32,
-    p0 : vec4<f32>, p1 : vec4<f32>, p2 : vec4<f32>,
-    p3 : vec4<f32>, p4 : vec4<f32>, p5 : vec4<f32>,
-) -> bool {
-    var inside = true;
-    inside = inside && particle_plane_sphere_visible(p0, center, radius);
-    inside = inside && particle_plane_sphere_visible(p1, center, radius);
-    inside = inside && particle_plane_sphere_visible(p2, center, radius);
-    inside = inside && particle_plane_sphere_visible(p3, center, radius);
-    inside = inside && particle_plane_sphere_visible(p4, center, radius);
-    inside = inside && particle_plane_sphere_visible(p5, center, radius);
-    return inside;
-}
-`);

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.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/spawn_request_encoding.js

@@ -1,52 +0,0 @@
-import { assert } from "../../../../core/assert.js";
-
-/**
- * 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 = 0xFFFF;
-
-/** @type {number} */
-export const SPAWN_REQUEST_FRACTION_SHIFT = 16;
-
-/** @type {number} */
-export const SPAWN_REQUEST_FRACTION_MAX = 0xFFFF;
-
-/**
- * @param {number} emitter_index
- * @param {number} fraction in [0, 1]
- * @returns {number} packed u32
- */
-export function spawn_request_pack(emitter_index, fraction) {
-    assert.isNonNegativeInteger(emitter_index, 'emitter_index');
-    assert.lessThanOrEqual(emitter_index, SPAWN_REQUEST_EMITTER_MASK, 'emitter_index');
-
-    const q = Math.round(fraction * SPAWN_REQUEST_FRACTION_MAX);
-
-    return ((q << SPAWN_REQUEST_FRACTION_SHIFT) | emitter_index) >>> 0;
-}
-
-/**
- * @param {number} packed
- * @returns {number} emitter index
- */
-export function spawn_request_emitter(packed) {
-    return packed & SPAWN_REQUEST_EMITTER_MASK;
-}
-
-/**
- * @param {number} packed
- * @returns {number} batch fraction in [0, 1]
- */
-export function spawn_request_fraction(packed) {
-    return (packed >>> SPAWN_REQUEST_FRACTION_SHIFT) / SPAWN_REQUEST_FRACTION_MAX;
-}