@codexo/exojs-particles 0.15.2 → 0.16.0

package/dist/esm/ParticleSystem.d.ts

@@ -1,4 +1,4 @@
-import type { Time } from '@codexo/exojs';
+import type { Seconds } from '@codexo/exojs';
 import { Rectangle } from '@codexo/exojs';
 import { Drawable } from '@codexo/exojs';
 import { Spritesheet } from '@codexo/exojs';
@@ -8,8 +8,11 @@ import { ParticleGpuState } from '#gpu/ParticleGpuState';
 import type { DeathModule } from '#modules/DeathModule';
 import type { SpawnModule } from '#modules/SpawnModule';
 import type { UpdateModule } from '#modules/UpdateModule';
+import type { ParticleEmitter, ParticleWriter } from '#ParticleStorage';
+import { ParticleStorage } from '#ParticleStorage';
+import type { ParticleRenderMode } from '#renderModes/ParticleRenderMode';
 /**
- * Options for {@link ParticleSystem}'s constructor — orthogonal config
+ * Options for {@link ParticleSystem}'s constructor - orthogonal config
  * that's independent of the texture source. Texture / frames / spritesheet
  * live in positional arguments to enforce mutual exclusivity at the type
  * level (you can't pass both a texture and a spritesheet by accident).
@@ -21,30 +24,51 @@ export interface ParticleSystemOptions {
      * Direct GPU device. Lets advanced consumers wire a `GPUDevice` owned
      * outside an `Application` (or a mock device in tests). When omitted,
      * the backend reference is captured automatically on the first
-     * {@link ParticleSystem.render} call — `WebGpuBackend` ⇒ GPU mode,
+     * {@link ParticleSystem.render} call - `WebGpuBackend` ⇒ GPU mode,
      * anything else (incl. WebGL2) ⇒ CPU mode.
      */
     device?: GPUDevice;
+    /**
+     * How this system's particles become vertices. Fixed at construction. A mode
+     * with `gpuEligible === false` forces the system onto the CPU path -
+     * silently, exactly like an update module without a `wgsl()` implementation,
+     * and observable through {@link ParticleSystem.gpuMode}.
+     *
+     * **Ownership.** A mode passed here belongs to the system: the system
+     * destroys it in {@link ParticleSystem.destroy}, which destroys the mode's
+     * material and geometry and releases the GPU resources cached against them.
+     * Pass one mode instance per system. Handing the same instance to two
+     * systems is not supported - destroying either one pulls the material out
+     * from under the other, which then silently rebuilds a fresh material and
+     * pays for a fresh shader compile mid-life. Two systems that should share
+     * one program simply omit this option; the default mode is shared for
+     * exactly that reason and is not owned by any system.
+     *
+     * @default a process-wide shared {@link QuadParticles}
+     */
+    readonly render?: ParticleRenderMode;
 }
 /**
  * The central coordinator of the particle pipeline. `ParticleSystem` is a
  * {@link Drawable} that owns:
  *
- * - **SoA particle storage** — one typed array per attribute (position,
- *   velocity, scale, rotation, color, lifetime, ...), sized to a fixed
- *   capacity at construction. User code reads/writes via
- *   `system.posX[slot]`, `system.velX[slot]`, etc.
- * - **Spawn modules** — write new particles into freshly allocated slots.
- * - **Update modules** — mutate the live range each frame (forces, color
+ * - **Particle storage** - one channel per attribute (position, velocity,
+ *   scale, rotation, color, timing, ...), sized to a fixed capacity at
+ *   construction. Modules and render modes address it by name through a
+ *   {@link ParticleBatch}; user code brings particles into existence with
+ *   {@link emit}.
+ * - **Spawn modules** - fill freshly emitted particles.
+ * - **Update modules** - mutate the live range each frame (forces, color
  *   blends, scale curves, drag, ...). Built-in modules ship both CPU and
  *   WGSL implementations; custom modules can opt into GPU acceleration by
  *   implementing `wgsl()`.
- * - **Death modules** — fire once per dying particle, before its slot is
+ * - **Death modules** - fire once per dying particle, before its slot is
  *   recycled (sub-emitters, event hooks).
  *
  * **Auto-routing CPU vs GPU:** at first {@link update}, the system checks:
  * if a `WebGpuBackend` was supplied AND every registered update module has
- * `wgsl()`, the GPU path engages — a composite compute pipeline runs
+ * `wgsl()` AND the render mode is GPU-eligible, the GPU path engages - a
+ * composite compute pipeline runs
  * integration plus all module bodies in one dispatch and writes directly
  * into the renderer's instance buffer (no CPU readback). Otherwise the CPU
  * path runs the existing per-module `apply()` loops.
@@ -60,21 +84,28 @@ export interface ParticleSystemOptions {
  * 1. Run every spawn module (CPU writes initial values into the spawn slot).
  * 2. Detect expiries on CPU (via `elapsed >= lifetime`); fire death modules;
  *    set `lifetime[slot] = -1` sentinel + clear `alive[slot]` so the GPU
- *    shader skips them. **No compaction** — slots are recycled on next spawn.
+ *    shader skips them. **No compaction** - slots are recycled on next spawn.
  * 3. Dispatch the composite compute pipeline. Integration + update modules
  *    + pack-instances run in one pass; the instance buffer is written
  *    directly. CPU SoA stays as-is for spawn writes.
  *
  * **Coordinate space:** particle positions are LOCAL to the system. The
- * system's `getGlobalTransform()` is applied on top during rendering — both
+ * system's `getGlobalTransform()` is applied on top during rendering - both
  * the WebGL2 and WebGPU shaders multiply `projection * translation * rotated`.
  * Setting world-space positions on individual particles double-translates.
  * Position the system itself via `system.setPosition(...)` and emit relative
  * to `(0, 0)`.
  *
+ * **Pixel snapping:** {@link Drawable.pixelSnapMode} is intentionally ignored
+ * for particle systems. Particle instances bake their own per-particle
+ * transforms in the emitter/compute path rather than reading the shared
+ * pixel-snap transform row, so a snap mode set on the system has no effect on
+ * rendered output - snapping thousands of independently-moving sub-pixel
+ * particles to the device grid is neither meaningful nor desirable.
+ *
  * @example
- * // Backend-agnostic — runs CPU on WebGL2, GPU on WebGPU automatically.
- * const system = new ParticleSystem(loader.get(Texture, 'spark'), {
+ * // Backend-agnostic - runs CPU on WebGL2, GPU on WebGPU automatically.
+ * const system = new ParticleSystem(loader.get('spark.png'), {
  *     capacity: 8192,
  * });
  *
@@ -83,35 +114,18 @@ export interface ParticleSystemOptions {
  * system.addUpdateModule(new ColorOverLifetime(fireGradient));
  * scene.addChild(system);
  */
-export declare class ParticleSystem extends Drawable {
+export declare class ParticleSystem extends Drawable implements ParticleEmitter {
     /** Maximum particle count this system will store. Fixed at construction. */
     readonly capacity: number;
-    readonly posX: Float32Array;
-    readonly posY: Float32Array;
-    readonly velX: Float32Array;
-    readonly velY: Float32Array;
-    readonly scaleX: Float32Array;
-    readonly scaleY: Float32Array;
-    readonly rotations: Float32Array;
-    readonly rotationSpeeds: Float32Array;
-    readonly color: Uint32Array;
-    readonly elapsed: Float32Array;
-    readonly lifetime: Float32Array;
-    readonly textureIndex: Uint16Array;
-    /**
-     * Number of currently live particles. In CPU mode this is exact: slots
-     * `[0, liveCount)` are all alive after each `update()`. In GPU mode
-     * this is a high-water mark — slots `[0, liveCount)` may contain dead
-     * holes (filled in by future spawns); use {@link aliveCount} for the
-     * actual alive count.
-     */
-    liveCount: number;
-    /**
-     * Per-slot alive flag (1 = alive, 0 = dead). Maintained in both CPU
-     * and GPU mode. Custom modules iterating the live range should check
-     * this to skip dead slots in GPU mode.
-     */
-    readonly alive: Uint8Array;
+    /**
+     * The simulation's channel storage. Handed to update modules and render modes
+     * as a {@link ParticleBatch}; never exposed as a property of the system,
+     * because outside those two callbacks its integrated values are not
+     * backend-true.
+     * @internal
+     */
+    readonly _storage: ParticleStorage;
+    private _writer;
     private readonly _spawnModules;
     private readonly _updateModules;
     private readonly _deathModules;
@@ -125,9 +139,31 @@ export declare class ParticleSystem extends Drawable {
      * In GPU mode, slots whose CPU SoA values need re-uploading to the GPU
      * (newly spawned, or just-expired with lifetime sentinel). Cleared
      * after each compute dispatch. CPU never overwrites integrated GPU
-     * state — only dirty slots flow CPU → GPU.
+     * state - only dirty slots flow CPU → GPU.
      */
     private readonly _gpuDirtySlots;
+    /**
+     * Spawn lifetimes, in death order per slot, of the particles that expired
+     * since the last batch the device staged for readback. The device's own
+     * record cannot carry them: by the time the shader sees the particle, the CPU
+     * has already overwritten its lifetime with the expiry sentinel. A slot can
+     * appear more than once when it is recycled and dies again before the batch
+     * is staged, so the lifetimes queue up per slot.
+     */
+    private _pendingDeathLifetimes;
+    /** Total entries across `_pendingDeathLifetimes`, which is what the dispatch reports. */
+    private _pendingDeathCount;
+    /** Whether this system has already reported that its death backlog overflowed. */
+    private _deathOverflowReported;
+    /**
+     * Slots handed out by `spawn()` while a recording window is open, or `null`
+     * when nothing is recording. Lets callers identify freshly spawned particles
+     * without diffing `liveCount`, which cannot see a recycled GPU slot.
+     */
+    private _spawnRecord;
+    private readonly _renderMode;
+    /** Whether {@link destroy} may destroy {@link _renderMode} - false for the shared default. */
+    private readonly _ownsRenderMode;
     private _texture;
     private readonly _frames;
     private readonly _textureFrame;
@@ -135,22 +171,32 @@ export declare class ParticleSystem extends Drawable {
     private readonly _texCoords;
     private _updateTexCoords;
     private _updateVertices;
-    /** No texture — particles render as solid-color quads on a 1×1 white default. */
+    /** No texture - particles render as solid-color quads on a 1×1 white default. */
     constructor(options?: ParticleSystemOptions);
-    /** Single texture, no atlas — every particle uses the full texture as one frame. */
+    /** Single texture, no atlas - every particle uses the full texture as one frame. */
     constructor(texture: Texture, options?: ParticleSystemOptions);
-    /** Multi-frame atlas — each particle's `textureIndex` selects a frame. */
+    /** Multi-frame atlas - each particle's `textureIndex` selects a frame. */
     constructor(texture: Texture, frames: readonly Rectangle[], options?: ParticleSystemOptions);
-    /** Spritesheet shorthand — texture + frames pulled from the sheet. */
+    /** Spritesheet shorthand - texture + frames pulled from the sheet. */
     constructor(spritesheet: Spritesheet, options?: ParticleSystemOptions);
+    /**
+     * The render mode this system's particles are drawn with. Fixed at
+     * construction via `ParticleSystemOptions.render`; the backend renderers
+     * read it every draw to learn the vertex layout, shader and draw model.
+     *
+     * Without that option this is the shared default mode - the same instance
+     * every other defaulted system draws with, so do not destroy it or mutate
+     * its material.
+     */
+    get renderMode(): ParticleRenderMode;
     get texture(): Texture;
     set texture(texture: Texture);
     get textureFrame(): Rectangle;
     set textureFrame(frame: Rectangle);
     /**
      * Atlas frames declared on this system, or empty when the texture is
-     * used as a single frame. Each particle's `textureIndex[i]` selects
-     * an entry from this list; out-of-range indices are clamped to 0.
+     * used as a single frame. Each particle's {@link textureIndex} selects
+     * an entry from this list; anything out of range shows frame 0.
      */
     get frames(): readonly Rectangle[];
     /** `true` when the system declares more than one atlas frame. */
@@ -161,7 +207,15 @@ export declare class ParticleSystem extends Drawable {
     get gpuMode(): boolean;
     /** GPU-side state, or `null` in CPU mode. */
     get gpuState(): ParticleGpuState | null;
-    /** Actual count of live particles (slots with `alive[i] === 1`). May differ from `liveCount` in GPU mode. */
+    /**
+     * Upper bound of the slot range that can hold live particles.
+     *
+     * Exact on the CPU path: after each `update()` slots `[0, liveCount)` are all
+     * alive. On the GPU path it is a high-water mark whose range can contain dead
+     * holes that future emissions fill; {@link aliveCount} counts the live ones.
+     */
+    get liveCount(): number;
+    /** Actual count of live particles. May be below {@link liveCount} on the GPU path. */
     get aliveCount(): number;
     get spawnModules(): readonly SpawnModule[];
     get updateModules(): readonly UpdateModule[];
@@ -170,23 +224,83 @@ export declare class ParticleSystem extends Drawable {
     setTextureFrame(frame: Rectangle): this;
     resetTextureFrame(): this;
     addSpawnModule(mod: SpawnModule): this;
+    /**
+     * Registers an update module. Modules run in registration order, each seeing
+     * what the previous ones did.
+     *
+     * Modules may be added and removed at any time, including mid-flight: the
+     * next update rebuilds whatever the change invalidated. On the GPU path that
+     * is the compute program alone - live particles keep the state the device has
+     * been integrating. Adding a module without a `wgsl()` implementation to a
+     * running GPU system is the one change that cannot preserve them: the
+     * simulation moves to the CPU, which has no copy of the integrated state, so
+     * the system clears its live particles rather than continuing from stale
+     * values (see {@link clearParticles}).
+     */
     addUpdateModule(mod: UpdateModule): this;
     addDeathModule(mod: DeathModule): this;
     clearSpawnModules(): this;
     clearUpdateModules(): this;
     clearDeathModules(): this;
     /**
-     * Allocates a particle slot and returns its index. Returns `-1` when
-     * the system is at {@link capacity}.
+     * Brings one particle into existence and returns a writer for its initial
+     * values, or `null` when the system is at {@link capacity}.
      *
-     * **CPU mode:** slots are dense in `[0, liveCount)`. `spawn()` returns
-     * the next sequential slot; `liveCount++`.
+     * The particle starts at the spawn defaults - origin, no velocity, unit
+     * scale, no rotation, opaque white, frame 0, one second of life - so a caller
+     * writes only what it varies. The returned writer is a cursor that the next
+     * `emit()` rebinds, so it must not be stored.
      *
-     * **GPU mode:** slots may have dead holes. `spawn()` finds the first
-     * `alive[i] === 0` slot via a round-robin hint pointer (amortised O(1),
-     * worst case O(capacity) on full systems).
+     * Emission is the only per-particle write that is true on every backend:
+     * spawn values originate on the CPU and are uploaded from there, while
+     * everything the simulation integrates afterwards lives wherever the
+     * simulation runs.
+     *
+     * @example
+     * ```ts
+     * const particle = system.emit();
+     *
+     * if (particle) {
+     *     particle.position.set(120, 40);
+     *     particle.velocity.set(0, -80);
+     *     particle.lifetime = 2;
+     * }
+     * ```
+     */
+    emit(): ParticleWriter | null;
+    /**
+     * Allocates one slot at the spawn defaults and returns its index, or `-1` at
+     * capacity. Backs {@link emit}; the simulation's own machinery addresses
+     * particles by slot, the public surface does not.
+     * @internal
      */
-    spawn(): number;
+    _spawnSlot(): number;
+    /**
+     * Begin recording the slots handed out by {@link spawn}.
+     *
+     * Callers that post-process freshly spawned particles cannot infer which
+     * slots those are from {@link liveCount}: in GPU mode a spawn may recycle a
+     * dead slot below the high-water mark, leaving the count unchanged, and the
+     * reused slots are scattered rather than contiguous. Pass the returned token
+     * back to {@link _endSpawnRecording}.
+     *
+     * @internal
+     */
+    _beginSpawnRecording(): number[] | null;
+    /**
+     * End the recording started by {@link _beginSpawnRecording} and return the
+     * slots allocated during it. Slots are also handed to an enclosing recording
+     * so a nested spawn stays visible to the outer window.
+     *
+     * @internal
+     */
+    _endSpawnRecording(previous: number[] | null): readonly number[];
+    /**
+     * Shifts the particles a sub-emitter just produced by `(x, y)`, so a child
+     * spawner's distributions read as offsets from the death position.
+     * @internal
+     */
+    _offsetSpawned(slots: readonly number[], x: number, y: number): void;
     /** Resets the system to zero live particles without destroying it. */
     clearParticles(): this;
     /**
@@ -200,12 +314,27 @@ export declare class ParticleSystem extends Drawable {
     /** @internal */
     _collect(builder: RenderPlanBuilder, seq?: number): void;
     /** Per-frame entry point. Routes to CPU or GPU pipeline based on auto-detection at first call. */
-    update(delta: Time): this;
+    update(delta: Seconds): this;
     destroy(): void;
+    /**
+     * Marks the compiled program stale. The next update decides what that costs:
+     * a GPU system that stays GPU-eligible rebuilds only its program, everything
+     * else follows the transition rules in {@link _compile}.
+     */
+    private _invalidateProgram;
     private _compile;
     private _spawnCpu;
     private _spawnGpu;
+    private _claimGpuSlot;
     private _updateCpu;
+    /** Hands one death snapshot to every registered death module, in registration order. */
+    private _reportDeath;
     private _updateGpu;
-    private _copySlot;
+    /**
+     * Delivers a staged batch of deaths once its readback has landed. Each record
+     * carries what the device integrated; the lifetime comes from the CPU, which
+     * is where it was written at spawn.
+     */
+    private _drainDeaths;
 }
+//# sourceMappingURL=ParticleSystem.d.ts.map

package/dist/esm/ParticleSystem.d.ts.map

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