@nodetool-ai/game-renderer 0.8.1 → 0.8.2

package/dist/particles/render2d.js

@@ -0,0 +1,70 @@
+import { ParticleSimulator, particleSourcesFromFrame } from "./simulator.js";
+/** Asset id of the built-in soft round dot that particles without a sprite draw with. */
+export const PARTICLE_DOT_ASSET = "nodetool:particle-dot";
+export const PARTICLE_DOT_SIZE = 32;
+/**
+ * Visible particles the Canvas2D fallback draws. Canvas2D composites each particle separately, so it stops at a
+ * lower count than WebGPU, which draws every particle the simulator holds as one instanced batch per texture.
+ */
+export const CANVAS2D_MAX_PARTICLES = 1024;
+/** White RGBA pixels whose alpha falls smoothly from the centre to zero at the edge. */
+export function particleDotPixels(size = PARTICLE_DOT_SIZE) {
+    const pixels = new Uint8ClampedArray(size * size * 4);
+    const half = size / 2;
+    for (let y = 0; y < size; y += 1) {
+        for (let x = 0; x < size; x += 1) {
+            const distance = Math.hypot(x + 0.5 - half, y + 0.5 - half) / half;
+            const falloff = Math.max(0, 1 - distance);
+            const offset = (y * size + x) * 4;
+            pixels[offset] = 255;
+            pixels[offset + 1] = 255;
+            pixels[offset + 2] = 255;
+            pixels[offset + 3] = Math.round(255 * falloff * falloff * (3 - 2 * falloff));
+        }
+    }
+    return pixels;
+}
+/** The sheet cell a particle shows at normalized age `life`. */
+export function particleCell(sprite, life) {
+    const cells = sprite.columns * sprite.rows;
+    if (cells <= 1) {
+        return undefined;
+    }
+    const frames = Math.min(sprite.frameCount ?? cells, cells);
+    const steps = frames * sprite.cycles;
+    // Life 1 is the last moment of the last cycle, not the start of another.
+    const index = Math.min(steps - 1, Math.floor(Math.max(0, Math.min(1, life)) * steps)) % frames;
+    return { index, columns: sprite.columns, rows: sprite.rows };
+}
+/**
+ * Runs 2D particles beside a game session. Call `tick` after every session step with that step's frame and
+ * the session's presentation events, and pass the instance to the renderer. It reads the session and never
+ * writes to it, so particles stay out of snapshots and replay.
+ */
+export class GameParticles2D {
+    simulator;
+    tickSeconds;
+    constructor(tickRate, maxSceneParticles) {
+        if (!(tickRate > 0)) {
+            throw new Error("Particle tick rate must be positive");
+        }
+        this.tickSeconds = 1 / tickRate;
+        this.simulator = new ParticleSimulator({ dimension: "2d", maxSceneParticles });
+    }
+    /** Live particles, for the frame budget. */
+    get count() {
+        return this.simulator.count;
+    }
+    tick(frame, events) {
+        this.simulator.sync(particleSourcesFromFrame(frame));
+        this.simulator.emit(events);
+        this.simulator.step(this.tickSeconds);
+    }
+    forEachParticle(visit) {
+        this.simulator.forEachParticle(visit);
+    }
+    clear() {
+        this.simulator.clear();
+    }
+}
+//# sourceMappingURL=render2d.js.map

package/dist/particles/render2d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render2d.js","sourceRoot":"","sources":["../../src/particles/render2d.ts"],"names":[],"mappings":"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"}

package/dist/particles/shapes.d.ts

@@ -0,0 +1,18 @@
+import type { GameParticleShape } from "@nodetool-ai/protocol";
+import type { ParticleRandom } from "./random.js";
+export type ParticleDimension = "2d" | "3d";
+/** Spawn position and unit direction in emitter space. */
+export interface ParticleShapeSample {
+    px: number;
+    py: number;
+    pz: number;
+    dx: number;
+    dy: number;
+    dz: number;
+}
+/**
+ * Samples a spawn point and direction. Shapes lie in the XY plane except sphere, cone and box in 3D.
+ * Box, edge and cone emit along +Y. Point, circle and sphere emit outward.
+ */
+export declare function sampleParticleShape(shape: GameParticleShape, dimension: ParticleDimension, random: ParticleRandom, out: ParticleShapeSample): ParticleShapeSample;
+//# sourceMappingURL=shapes.d.ts.map

package/dist/particles/shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapes.d.ts","sourceRoot":"","sources":["../../src/particles/shapes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,MAAM,iBAAiB,GAAG,IAAI,GAAG,IAAI,CAAC;AAE5C,0DAA0D;AAC1D,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAID;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,EAAE,mBAAmB,GAAG,mBAAmB,CAqEjK"}

package/dist/particles/shapes.js

@@ -0,0 +1,92 @@
+const DEGREES = Math.PI / 180;
+/**
+ * Samples a spawn point and direction. Shapes lie in the XY plane except sphere, cone and box in 3D.
+ * Box, edge and cone emit along +Y. Point, circle and sphere emit outward.
+ */
+export function sampleParticleShape(shape, dimension, random, out) {
+    out.px = 0;
+    out.py = 0;
+    out.pz = 0;
+    out.dx = 0;
+    out.dy = 1;
+    out.dz = 0;
+    const flat = dimension === "2d";
+    switch (shape.kind) {
+        case "point":
+            if (flat) {
+                circleDirection(random.next() * Math.PI * 2, out);
+            }
+            else {
+                sphereDirection(random, out);
+            }
+            break;
+        case "circle": {
+            const angle = random.next() * shape.arc * DEGREES;
+            const radius = shape.fromEdge ? shape.radius : shape.radius * Math.sqrt(random.next());
+            circleDirection(angle, out);
+            out.px = out.dx * radius;
+            out.py = out.dy * radius;
+            break;
+        }
+        case "sphere": {
+            if (flat) {
+                circleDirection(random.next() * Math.PI * 2, out);
+            }
+            else {
+                sphereDirection(random, out);
+            }
+            const unit = random.next();
+            const radius = shape.fromSurface ? shape.radius : shape.radius * (flat ? Math.sqrt(unit) : Math.cbrt(unit));
+            out.px = out.dx * radius;
+            out.py = out.dy * radius;
+            out.pz = out.dz * radius;
+            break;
+        }
+        case "cone": {
+            const spread = shape.angle * DEGREES;
+            if (flat) {
+                const angle = (random.next() * 2 - 1) * spread;
+                out.dx = -Math.sin(angle);
+                out.dy = Math.cos(angle);
+                out.px = (random.next() * 2 - 1) * shape.radius;
+            }
+            else {
+                // Uniform over the cap's solid angle, around +Y, from a disc of the given radius in XZ.
+                const cosine = 1 - random.next() * (1 - Math.cos(spread));
+                const sine = Math.sqrt(Math.max(0, 1 - cosine * cosine));
+                const turn = random.next() * Math.PI * 2;
+                out.dx = sine * Math.cos(turn);
+                out.dy = cosine;
+                out.dz = sine * Math.sin(turn);
+                const radius = shape.radius * Math.sqrt(random.next());
+                const baseTurn = random.next() * Math.PI * 2;
+                out.px = radius * Math.cos(baseTurn);
+                out.pz = radius * Math.sin(baseTurn);
+            }
+            break;
+        }
+        case "box":
+            out.px = (random.next() - 0.5) * shape.size.x;
+            out.py = (random.next() - 0.5) * shape.size.y;
+            out.pz = flat ? 0 : (random.next() - 0.5) * shape.size.z;
+            break;
+        case "edge":
+            out.px = (random.next() - 0.5) * shape.length;
+            break;
+    }
+    return out;
+}
+function circleDirection(angle, out) {
+    out.dx = Math.cos(angle);
+    out.dy = Math.sin(angle);
+    out.dz = 0;
+}
+function sphereDirection(random, out) {
+    const z = random.next() * 2 - 1;
+    const turn = random.next() * Math.PI * 2;
+    const ring = Math.sqrt(Math.max(0, 1 - z * z));
+    out.dx = ring * Math.cos(turn);
+    out.dy = ring * Math.sin(turn);
+    out.dz = z;
+}
+//# sourceMappingURL=shapes.js.map

package/dist/particles/shapes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapes.js","sourceRoot":"","sources":["../../src/particles/shapes.ts"],"names":[],"mappings":"AAgBA,MAAM,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC;AAE9B;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAwB,EAAE,SAA4B,EAAE,MAAsB,EAAE,GAAwB;IAC1I,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;IACX,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;IACX,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;IACX,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;IACX,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;IACX,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;IACX,MAAM,IAAI,GAAG,SAAS,KAAK,IAAI,CAAC;IAChC,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,OAAO;YACV,IAAI,IAAI,EAAE,CAAC;gBACT,eAAe,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;YACpD,CAAC;iBAAM,CAAC;gBACN,eAAe,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;YAC/B,CAAC;YACD,MAAM;QACR,KAAK,QAAQ,EAAE,CAAC;YACd,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,GAAG,OAAO,CAAC;YAClD,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;YACvF,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YAC5B,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC;YACzB,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC;YACzB,MAAM;QACR,CAAC;QACD,KAAK,QAAQ,EAAE,CAAC;YACd,IAAI,IAAI,EAAE,CAAC;gBACT,eAAe,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;YACpD,CAAC;iBAAM,CAAC;gBACN,eAAe,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;YAC/B,CAAC;YACD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;YAC3B,MAAM,MAAM,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YAC5G,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC;YACzB,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC;YACzB,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC;YACzB,MAAM;QACR,CAAC;QACD,KAAK,MAAM,EAAE,CAAC;YACZ,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,GAAG,OAAO,CAAC;YACrC,IAAI,IAAI,EAAE,CAAC;gBACT,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC;gBAC/C,GAAG,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBAC1B,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBACzB,GAAG,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;YAClD,CAAC;iBAAM,CAAC;gBACN,wFAAwF;gBACxF,MAAM,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC1D,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC;gBACzD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;gBACzC,GAAG,CAAC,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBAC/B,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC;gBAChB,GAAG,CAAC,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBAC/B,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;gBACvD,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;gBAC7C,GAAG,CAAC,EAAE,GAAG,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBACrC,GAAG,CAAC,EAAE,GAAG,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACvC,CAAC;YACD,MAAM;QACR,CAAC;QACD,KAAK,KAAK;YACR,GAAG,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;YAC9C,GAAG,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;YAC9C,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;YACzD,MAAM;QACR,KAAK,MAAM;YACT,GAAG,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;YAC9C,MAAM;IACV,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,eAAe,CAAC,KAAa,EAAE,GAAwB;IAC9D,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACzB,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACzB,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;AACb,CAAC;AAED,SAAS,eAAe,CAAC,MAAsB,EAAE,GAAwB;IACvE,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IAChC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;IACzC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC/C,GAAG,CAAC,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC/B,GAAG,CAAC,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC/B,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;AACb,CAAC"}

package/dist/particles/simulator.d.ts

@@ -0,0 +1,88 @@
+import type { GameParticleEmitter, GameParticles, GameRenderFrame, GameRenderFrame3D } from "@nodetool-ai/protocol";
+import { type ParticleDimension } from "./shapes.js";
+export interface ParticleVector {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+/** Unit quaternion as `[x, y, z, w]`, matching `gameQuaternion3D`. */
+export type ParticleQuaternion = readonly [number, number, number, number];
+/** One entity's particles component and its current world transform. */
+export interface ParticleEmitterSource {
+    readonly entityId: string;
+    readonly position: ParticleVector;
+    readonly rotation: ParticleQuaternion;
+    readonly particles: GameParticles;
+}
+export interface ParticleSimulatorOptions {
+    readonly dimension: ParticleDimension;
+    /** Live particles across every emitter. Emission stops at this cap until particles die. */
+    readonly maxSceneParticles?: number;
+}
+/** A live particle in world space. The object is reused between callbacks of one emitter, so copy what you keep. */
+export interface ParticleView {
+    entityId: string;
+    emitterId: string;
+    /** The emitter definition, for render settings such as blend and sprite. */
+    emitter: GameParticleEmitter;
+    x: number;
+    y: number;
+    z: number;
+    size: number;
+    rotation: number;
+    r: number;
+    g: number;
+    b: number;
+    opacity: number;
+    /** Normalized age: 0 at birth, 1 at death. */
+    life: number;
+}
+export declare const DEFAULT_MAX_SCENE_PARTICLES = 8192;
+/** Longest interval one `step` simulates, so a long pause cannot turn into thousands of emission cycles. */
+export declare const MAX_PARTICLE_STEP_SECONDS = 0.25;
+/**
+ * CPU particle simulation for the renderers. It is presentation state: it reads render frames and
+ * presentation events, owns its own random streams, and has no snapshot or path back into a session.
+ */
+export declare class ParticleSimulator {
+    readonly dimension: ParticleDimension;
+    readonly maxSceneParticles: number;
+    private readonly instances;
+    /** Emitter ids of each entity in the last sync, in document order. */
+    private readonly emitterOrder;
+    private total;
+    private readonly sample;
+    private readonly color;
+    constructor(options: ParticleSimulatorOptions);
+    /** Live particles across every emitter. */
+    get count(): number;
+    /** Live particles of one emitter. */
+    countOf(entityId: string, emitterId: string): number;
+    /**
+     * Updates emitters from the current frame. An emitter missing from `sources` stops emitting. Its world-space
+     * particles finish their lives and its local-space particles disappear with the entity.
+     */
+    sync(sources: readonly ParticleEmitterSource[]): void;
+    /** Applies `particles` presentation events from a session. Other event kinds are ignored. */
+    emit(events: readonly {
+        readonly kind: string;
+    }[]): void;
+    /**
+     * Advances every particle, then emits new particles for the same interval. A step longer than
+     * {@link MAX_PARTICLE_STEP_SECONDS}, such as the first frame after a paused tab, is clamped to it.
+     */
+    step(seconds: number): void;
+    /** Visits every live particle in world space. */
+    forEachParticle(visit: (particle: Readonly<ParticleView>) => void): void;
+    /** Removes every emitter and particle. */
+    clear(): void;
+    private findInstance;
+    private advance;
+    /** Emits the rate and bursts that fall in [time, time + dt), wrapping looping cycles, plus pending counts. */
+    private schedule;
+    /** Spawns one particle at the emitter, or at `origin` (a world point) for a death emitter. */
+    private spawn;
+}
+/** Emitter sources from a 2D or 3D render frame. 2D rotation turns about Z. */
+export declare function particleSourcesFromFrame(frame: GameRenderFrame | GameRenderFrame3D): ParticleEmitterSource[];
+//# sourceMappingURL=simulator.d.ts.map

package/dist/particles/simulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulator.d.ts","sourceRoot":"","sources":["../../src/particles/simulator.ts"],"names":[],"mappings":"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"}

package/dist/particles/simulator.js

@@ -0,0 +1,371 @@
+import { evaluateParticleCurve, evaluateParticleGradient, parseParticleColor, sampleParticleRange } from "./curves.js";
+import { ParticleRandom, particleSeed } from "./random.js";
+import { sampleParticleShape } from "./shapes.js";
+export const DEFAULT_MAX_SCENE_PARTICLES = 8192;
+/** Longest interval one `step` simulates, so a long pause cannot turn into thousands of emission cycles. */
+export const MAX_PARTICLE_STEP_SECONDS = 0.25;
+const STRIDE = 14;
+const PX = 0, PY = 1, PZ = 2, VX = 3, VY = 4, VZ = 5, AGE = 6, LIFE = 7, SIZE = 8, ROT = 9, SPIN = 10, CR = 11, CG = 12, CB = 13;
+const SAME_TIME = 1e-9;
+const IDENTITY = [0, 0, 0, 1];
+/**
+ * CPU particle simulation for the renderers. It is presentation state: it reads render frames and
+ * presentation events, owns its own random streams, and has no snapshot or path back into a session.
+ */
+export class ParticleSimulator {
+    dimension;
+    maxSceneParticles;
+    instances = new Map();
+    /** Emitter ids of each entity in the last sync, in document order. */
+    emitterOrder = new Map();
+    total = 0;
+    sample = { px: 0, py: 0, pz: 0, dx: 0, dy: 1, dz: 0 };
+    color = { r: 0, g: 0, b: 0 };
+    constructor(options) {
+        this.dimension = options.dimension;
+        this.maxSceneParticles = options.maxSceneParticles ?? DEFAULT_MAX_SCENE_PARTICLES;
+    }
+    /** Live particles across every emitter. */
+    get count() {
+        return this.total;
+    }
+    /** Live particles of one emitter. */
+    countOf(entityId, emitterId) {
+        return this.instances.get(instanceKey(entityId, emitterId))?.count ?? 0;
+    }
+    /**
+     * Updates emitters from the current frame. An emitter missing from `sources` stops emitting. Its world-space
+     * particles finish their lives and its local-space particles disappear with the entity.
+     */
+    sync(sources) {
+        for (const instance of this.instances.values()) {
+            instance.attached = false;
+        }
+        this.emitterOrder.clear();
+        for (const source of sources) {
+            this.emitterOrder.set(source.entityId, source.particles.emitters.map((emitter) => emitter.id));
+            for (const definition of source.particles.emitters) {
+                const key = instanceKey(source.entityId, definition.id);
+                let instance = this.instances.get(key);
+                if (!instance) {
+                    instance = {
+                        entityId: source.entityId,
+                        definition,
+                        random: new ParticleRandom(particleSeed(source.entityId, definition.id)),
+                        data: new Float64Array(definition.maxParticles * STRIDE),
+                        count: 0,
+                        time: 0,
+                        playing: definition.playOnStart,
+                        accumulator: 0,
+                        pending: 0,
+                        attached: true,
+                        position: source.position,
+                        rotation: source.rotation
+                    };
+                    this.instances.set(key, instance);
+                }
+                if (definition.maxParticles !== instance.definition.maxParticles) {
+                    const data = new Float64Array(definition.maxParticles * STRIDE);
+                    const kept = Math.min(instance.count, definition.maxParticles);
+                    data.set(instance.data.subarray(0, kept * STRIDE));
+                    this.total -= instance.count - kept;
+                    instance.data = data;
+                    instance.count = kept;
+                }
+                instance.definition = definition;
+                instance.position = source.position;
+                instance.rotation = source.rotation;
+                instance.attached = true;
+            }
+        }
+        for (const [key, instance] of this.instances) {
+            if (!instance.attached && (instance.definition.space === "local" || instance.count === 0)) {
+                this.total -= instance.count;
+                this.instances.delete(key);
+            }
+        }
+    }
+    /** Applies `particles` presentation events from a session. Other event kinds are ignored. */
+    emit(events) {
+        for (const event of events) {
+            if (!isParticleEmission(event)) {
+                continue;
+            }
+            const instance = this.findInstance(event.entityId, event.emitter);
+            if (!instance || !instance.attached) {
+                continue;
+            }
+            if (event.count === undefined) {
+                instance.time = 0;
+                instance.accumulator = 0;
+                instance.playing = true;
+            }
+            else {
+                instance.pending += event.count;
+            }
+        }
+    }
+    /**
+     * Advances every particle, then emits new particles for the same interval. A step longer than
+     * {@link MAX_PARTICLE_STEP_SECONDS}, such as the first frame after a paused tab, is clamped to it.
+     */
+    step(seconds) {
+        if (!(seconds > 0)) {
+            return;
+        }
+        const dt = Math.min(seconds, MAX_PARTICLE_STEP_SECONDS);
+        const deaths = [];
+        for (const instance of this.instances.values()) {
+            this.advance(instance, dt, deaths);
+        }
+        for (const death of deaths) {
+            const instance = this.instances.get(instanceKey(death.entityId, death.emitter));
+            if (instance && (instance.attached || instance.definition.space === "world")) {
+                for (let index = 0; index < death.count; index += 1) {
+                    if (!this.spawn(instance, death)) {
+                        break;
+                    }
+                }
+            }
+        }
+        for (const instance of this.instances.values()) {
+            if (instance.attached) {
+                this.schedule(instance, dt);
+            }
+        }
+        for (const [key, instance] of this.instances) {
+            if (!instance.attached && instance.count === 0) {
+                this.instances.delete(key);
+            }
+        }
+    }
+    /** Visits every live particle in world space. */
+    forEachParticle(visit) {
+        for (const instance of this.instances.values()) {
+            const definition = instance.definition;
+            const data = instance.data;
+            const view = { entityId: instance.entityId, emitterId: definition.id, emitter: definition,
+                x: 0, y: 0, z: 0, size: 0, rotation: 0, r: 0, g: 0, b: 0, opacity: 0, life: 0 };
+            for (let index = 0; index < instance.count; index += 1) {
+                const base = index * STRIDE;
+                const life = Math.min(1, data[base + AGE] / data[base + LIFE]);
+                if (definition.space === "local") {
+                    const point = transformPoint(instance.rotation, instance.position, data[base + PX], data[base + PY], data[base + PZ]);
+                    view.x = point.x;
+                    view.y = point.y;
+                    view.z = point.z;
+                }
+                else {
+                    view.x = data[base + PX];
+                    view.y = data[base + PY];
+                    view.z = data[base + PZ];
+                }
+                view.size = data[base + SIZE] * (definition.sizeOverLifetime ? evaluateParticleCurve(definition.sizeOverLifetime, life) : 1);
+                view.rotation = data[base + ROT];
+                view.r = data[base + CR];
+                view.g = data[base + CG];
+                view.b = data[base + CB];
+                if (definition.colorOverLifetime) {
+                    const tint = evaluateParticleGradient(definition.colorOverLifetime, life, this.color);
+                    view.r *= tint.r;
+                    view.g *= tint.g;
+                    view.b *= tint.b;
+                }
+                view.opacity = definition.opacity * (definition.opacityOverLifetime ? evaluateParticleCurve(definition.opacityOverLifetime, life) : 1);
+                view.life = life;
+                visit(view);
+            }
+        }
+    }
+    /** Removes every emitter and particle. */
+    clear() {
+        this.instances.clear();
+        this.emitterOrder.clear();
+        this.total = 0;
+    }
+    findInstance(entityId, emitterId) {
+        if (emitterId !== undefined) {
+            return this.instances.get(instanceKey(entityId, emitterId));
+        }
+        // The first emitter in document order. Every emitter of a synced entity is attached.
+        const first = this.emitterOrder.get(entityId)?.[0];
+        return first === undefined ? undefined : this.instances.get(instanceKey(entityId, first));
+    }
+    advance(instance, dt, deaths) {
+        const definition = instance.definition;
+        const data = instance.data;
+        const flat = this.dimension === "2d";
+        const gx = definition.gravity.x, gy = definition.gravity.y, gz = flat ? 0 : definition.gravity.z;
+        const damping = definition.drag > 0 ? 1 / (1 + definition.drag * dt) : 1;
+        let index = 0;
+        while (index < instance.count) {
+            const base = index * STRIDE;
+            const age = data[base + AGE] + dt;
+            if (age >= data[base + LIFE]) {
+                if (definition.onDeath.length > 0) {
+                    const point = definition.space === "local"
+                        ? transformPoint(instance.rotation, instance.position, data[base + PX], data[base + PY], data[base + PZ])
+                        : { x: data[base + PX], y: data[base + PY], z: data[base + PZ] };
+                    for (const sub of definition.onDeath) {
+                        deaths.push({ entityId: instance.entityId, emitter: sub.emitter, count: sub.count, ...point });
+                    }
+                }
+                const last = (instance.count - 1) * STRIDE;
+                if (last !== base) {
+                    data.copyWithin(base, last, last + STRIDE);
+                }
+                instance.count -= 1;
+                this.total -= 1;
+                continue;
+            }
+            data[base + AGE] = age;
+            data[base + VX] = (data[base + VX] + gx * dt) * damping;
+            data[base + VY] = (data[base + VY] + gy * dt) * damping;
+            data[base + VZ] = (data[base + VZ] + gz * dt) * damping;
+            const speed = definition.speedOverLifetime ? evaluateParticleCurve(definition.speedOverLifetime, age / data[base + LIFE]) : 1;
+            data[base + PX] += data[base + VX] * speed * dt;
+            data[base + PY] += data[base + VY] * speed * dt;
+            data[base + PZ] += data[base + VZ] * speed * dt;
+            data[base + ROT] += data[base + SPIN] * dt;
+            index += 1;
+        }
+    }
+    /** Emits the rate and bursts that fall in [time, time + dt), wrapping looping cycles, plus pending counts. */
+    schedule(instance, dt) {
+        const definition = instance.definition;
+        let emitted = instance.pending;
+        instance.pending = 0;
+        let remaining = dt;
+        while (instance.playing && remaining > 0) {
+            const start = instance.time;
+            // Subtracting the segment length itself ends the loop exactly, so float rounding cannot leave a sliver.
+            const length = Math.max(0, Math.min(remaining, definition.duration - start));
+            const end = start + length;
+            instance.accumulator += definition.rate * length;
+            const whole = Math.floor(instance.accumulator + SAME_TIME);
+            instance.accumulator = Math.max(0, instance.accumulator - whole);
+            emitted += whole;
+            for (const burst of definition.bursts) {
+                for (let cycle = 0; cycle < burst.cycles; cycle += 1) {
+                    const at = burst.time + cycle * burst.interval;
+                    if (at >= start - SAME_TIME && at < end - SAME_TIME) {
+                        emitted += burst.count;
+                    }
+                }
+            }
+            remaining -= length;
+            instance.time = end;
+            if (instance.time >= definition.duration - SAME_TIME) {
+                if (definition.loop) {
+                    instance.time = 0;
+                }
+                else {
+                    instance.playing = false;
+                }
+            }
+        }
+        for (let index = 0; index < emitted; index += 1) {
+            if (!this.spawn(instance)) {
+                break;
+            }
+        }
+    }
+    /** Spawns one particle at the emitter, or at `origin` (a world point) for a death emitter. */
+    spawn(instance, origin) {
+        const definition = instance.definition;
+        if (instance.count >= definition.maxParticles || this.total >= this.maxSceneParticles) {
+            return false;
+        }
+        const random = instance.random;
+        const shape = sampleParticleShape(definition.shape, this.dimension, random, this.sample);
+        const lifetime = sampleParticleRange(definition.lifetime, random);
+        const speed = sampleParticleRange(definition.speed, random);
+        const size = sampleParticleRange(definition.size, random);
+        const rotation = sampleParticleRange(definition.rotation, random);
+        const spin = sampleParticleRange(definition.angularVelocity, random);
+        const color = this.color;
+        if (typeof definition.color === "string") {
+            parseParticleColor(definition.color, color);
+        }
+        else {
+            const mix = random.next();
+            const from = parseParticleColor(definition.color.min);
+            const to = parseParticleColor(definition.color.max);
+            color.r = from.r + (to.r - from.r) * mix;
+            color.g = from.g + (to.g - from.g) * mix;
+            color.b = from.b + (to.b - from.b) * mix;
+        }
+        let position;
+        let direction;
+        if (definition.space === "world") {
+            const offset = rotate(instance.rotation, shape.px, shape.py, shape.pz);
+            const anchor = origin ?? instance.position;
+            position = { x: anchor.x + offset.x, y: anchor.y + offset.y, z: anchor.z + offset.z };
+            direction = rotate(instance.rotation, shape.dx, shape.dy, shape.dz);
+        }
+        else {
+            const anchor = origin ? inverseTransformPoint(instance.rotation, instance.position, origin) : { x: 0, y: 0, z: 0 };
+            position = { x: anchor.x + shape.px, y: anchor.y + shape.py, z: anchor.z + shape.pz };
+            direction = { x: shape.dx, y: shape.dy, z: shape.dz };
+        }
+        const flat = this.dimension === "2d";
+        const base = instance.count * STRIDE;
+        const data = instance.data;
+        data[base + PX] = position.x;
+        data[base + PY] = position.y;
+        data[base + PZ] = flat ? 0 : position.z;
+        data[base + VX] = direction.x * speed;
+        data[base + VY] = direction.y * speed;
+        data[base + VZ] = flat ? 0 : direction.z * speed;
+        data[base + AGE] = 0;
+        data[base + LIFE] = lifetime;
+        data[base + SIZE] = size;
+        data[base + ROT] = rotation;
+        data[base + SPIN] = spin;
+        data[base + CR] = color.r;
+        data[base + CG] = color.g;
+        data[base + CB] = color.b;
+        instance.count += 1;
+        this.total += 1;
+        return true;
+    }
+}
+/** Emitter sources from a 2D or 3D render frame. 2D rotation turns about Z. */
+export function particleSourcesFromFrame(frame) {
+    if ("dimension" in frame) {
+        return frame.entities.flatMap((entity) => entity.particles
+            ? [{ entityId: entity.entityId, position: entity.transform.position, rotation: entity.transform.rotation, particles: entity.particles }]
+            : []);
+    }
+    return (frame.particles ?? []).map((emitter) => ({
+        entityId: emitter.entityId,
+        position: { x: emitter.x, y: emitter.y, z: 0 },
+        rotation: emitter.rotation === 0 ? IDENTITY : [0, 0, Math.sin(emitter.rotation / 2), Math.cos(emitter.rotation / 2)],
+        particles: emitter.particles
+    }));
+}
+function isParticleEmission(event) {
+    return event.kind === "particles";
+}
+function instanceKey(entityId, emitterId) {
+    return `${entityId}\u0000${emitterId}`;
+}
+function rotate(q, x, y, z) {
+    const [qx, qy, qz, qw] = q;
+    const tx = 2 * (qy * z - qz * y);
+    const ty = 2 * (qz * x - qx * z);
+    const tz = 2 * (qx * y - qy * x);
+    return {
+        x: x + qw * tx + (qy * tz - qz * ty),
+        y: y + qw * ty + (qz * tx - qx * tz),
+        z: z + qw * tz + (qx * ty - qy * tx)
+    };
+}
+function transformPoint(q, origin, x, y, z) {
+    const turned = rotate(q, x, y, z);
+    return { x: origin.x + turned.x, y: origin.y + turned.y, z: origin.z + turned.z };
+}
+function inverseTransformPoint(q, origin, point) {
+    return rotate([-q[0], -q[1], -q[2], q[3]], point.x - origin.x, point.y - origin.y, point.z - origin.z);
+}
+//# sourceMappingURL=simulator.js.map