@woosh/meep-engine 3.16.0 → 3.17.1

package/src/engine/sound/simulation/core/OcclusionSolver.js

@@ -1,112 +0,0 @@
-import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
-import { sphere_fibonacci_point } from "../../../../core/geom/3d/sphere/sphere_fibonacci_point.js";
-import { random_orthonormal_basis } from "../../../../core/geom/random/random_orthonormal_basis.js";
-import { v3_matrix3_rotate } from "../../../../core/geom/vec3/v3_matrix3_rotate.js";
-import { RayHit } from "./RayHit.js";
-
-// module-static scratch — reused across calls so a solve allocates nothing. Typed throughout (the
-// vectors carry direction cosines / band ratios, so Float64 native precision is free here).
-const RAY = new Ray3();
-const HIT = new RayHit();
-const FIBONACCI = new Float64Array(3);
-const DIRECTION = new Float64Array(3);
-const ROTATION = new Float64Array(9);
-const TRANSMISSION = new Float64Array(3);
-
-/**
- * Computes per-source occlusion + transmission by shooting rays from the listener toward points spread
- * over the source's sphere and counting how many are blocked by the {@link AcousticOccluderIndex}.
- *
- * - Volumetric (not boolean): occlusion is the FRACTION of blocked rays, so partially-hidden sources
- *   attenuate smoothly instead of popping on/off.
- * - Transmission: blocked rays accumulate their occluder's per-band transmission; the average is the
- *   energy that leaks through.
- * - Temporal: the fibonacci sample set is randomly re-oriented each tick (seeded), and the result is
- *   folded into an {@link AcousticSourceState} via EMA — so a low per-tick ray count integrates over
- *   frames and the output stays frame-stable.
- *
- * Pure: geometry in, numbers out. No WebAudio, no ECS, no allocation.
- */
-export class OcclusionSolver {
-    /**
-     * @param {Vector3} listener listener world position
-     * @param {Vector3} source source world position
-     * @param {number} sourceRadius apparent radius of the source (0 = point source → boolean occlusion)
-     * @param {AcousticOccluderIndex} index
-     * @param {number} rayCount rays shot this tick (≥ 1)
-     * @param {number} smoothing EMA factor in (0, 1] — 1 = no smoothing
-     * @param {function():number} random seeded RNG; decorrelates the sample set per call
-     * @param {AcousticSourceState} state per-source temporal accumulation (mutated)
-     * @param {AcousticSolution} out occlusion + transmission written here (medium untouched)
-     */
-    solve(listener, source, sourceRadius, index, rayCount, smoothing, random, state, out) {
-        // a per-tick random orientation for the fibonacci set (decorrelation over frames)
-        random_orthonormal_basis(ROTATION, 0, random);
-
-        const lx = listener.x;
-        const ly = listener.y;
-        const lz = listener.z;
-
-        const sx = source.x;
-        const sy = source.y;
-        const sz = source.z;
-
-        let blocked = 0;
-        let t0 = 0;
-        let t1 = 0;
-        let t2 = 0;
-
-        for (let i = 0; i < rayCount; i++) {
-            sphere_fibonacci_point(FIBONACCI, 0, i, rayCount);
-            v3_matrix3_rotate(DIRECTION, 0, FIBONACCI[0], FIBONACCI[1], FIBONACCI[2], ROTATION);
-
-            // a sample point spread over the source's sphere
-            const px = sx + DIRECTION[0] * sourceRadius;
-            const py = sy + DIRECTION[1] * sourceRadius;
-            const pz = sz + DIRECTION[2] * sourceRadius;
-
-            const dx = px - lx;
-            const dy = py - ly;
-            const dz = pz - lz;
-
-            const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
-
-            if (distance <= 1e-6) {
-                // listener sitting on the source — treat as unoccluded for this ray
-                continue;
-            }
-
-            const inv = 1 / distance;
-
-            RAY.setOrigin(lx, ly, lz);
-            RAY.setDirection(dx * inv, dy * inv, dz * inv);
-            RAY.tMax = distance;
-
-            if (index.closestHit(RAY, HIT)) {
-                blocked++;
-
-                const transmission = HIT.material.transmission;
-                t0 += transmission[0];
-                t1 += transmission[1];
-                t2 += transmission[2];
-            }
-        }
-
-        const occlusion = blocked / rayCount;
-
-        // instantaneous transmission = average blocker transmission; transparent when nothing blocked
-        if (blocked > 0) {
-            const inv = 1 / blocked;
-            TRANSMISSION[0] = t0 * inv;
-            TRANSMISSION[1] = t1 * inv;
-            TRANSMISSION[2] = t2 * inv;
-        } else {
-            TRANSMISSION[0] = 1;
-            TRANSMISSION[1] = 1;
-            TRANSMISSION[2] = 1;
-        }
-
-        state.integrate(occlusion, TRANSMISSION, smoothing);
-        state.writeTo(out);
-    }
-}

package/src/shade/renderer/buffer/table/gpu_database_emulator_image.d.ts

@@ -1,27 +0,0 @@
-/**
- * Build the `array<u32>` image of a {@link GPUDatabase} — the exact bytes the generated marshalling
- * functions ({@link GPUTypedTableDescriptor#chunk_read} and friends) index: the page address table,
- * then pages at the addresses it names, each page's records past its
- * `[u32 live_count][u32 occupancy_bitmap...]` header.
- *
- * This exists for the WGSL emulator. The production route to those bytes is a compute dispatch
- * ({@link ./gpu_table_element_upload_shader.js}) against a live device, and the software device
- * records dispatches without running them — so a spec that wants to run a database-reading shader
- * on the CPU has no way to obtain a filled buffer. Everything here is derived from the descriptor's
- * own published geometry (`page_lookup_address`, `elements_per_page`, `page_header_words`,
- * `packed_element_size_bytes`), which is the same geometry the upload shader receives as its
- * settings, so the two cannot drift apart silently.
- *
- * Pages are allocated in ascending (table index, page index) order — the addresses therefore differ
- * from what a live database's slot allocator would hand out for the same writes. Nothing reads a
- * page address except through the table, so the layout is equivalent, not identical.
- *
- * @param {GPUDatabaseDefinition} definition
- * @param {Object<string, Iterable<[number, *]>>} contents records per table name, as
- *        `[element_index, value]` pairs (a `Map`, or an array of pairs)
- * @returns {Uint32Array}
- */
-export function gpu_database_emulator_image(definition: GPUDatabaseDefinition, contents: {
-    [x: string]: Iterable<[number, any]>;
-}): Uint32Array;
-//# sourceMappingURL=gpu_database_emulator_image.d.ts.map

package/src/shade/renderer/buffer/table/gpu_database_emulator_image.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gpu_database_emulator_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/gpu_database_emulator_image.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;QAJkB,MAAM,GAAE,SAAS,CAAC,MAAM,MAAI,CAAC;IAElC,WAAW,CAwFvB"}

package/src/shade/renderer/particles/cull/chunk_particle_cull.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_particle_cull.d.ts.map

package/src/shade/renderer/particles/cull/chunk_particle_cull.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_particle_cull.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/cull/chunk_particle_cull.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,kCAFU,SAAS,CA0BhB;0BArCuB,oCAAoC"}

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