@zylem/behaviors 0.2.0 → 0.3.0

package/dist/screen-visibility.js

@@ -1,10 +1,9 @@
 import {
   ScreenVisibilityBehavior,
   ScreenVisibilityFSM
-} from "./chunk-WOMHL23C.js";
-import "./chunk-EZNCCO4L.js";
+} from "./chunk-ERS6SNA5.js";
+import "./chunk-YDLO5M7S.js";
 export {
   ScreenVisibilityBehavior,
   ScreenVisibilityFSM
 };
-//# sourceMappingURL=screen-visibility.js.map

package/dist/screen-wrap.js

@@ -3,14 +3,13 @@ import {
   ScreenWrapEvent,
   ScreenWrapFSM,
   ScreenWrapState
-} from "./chunk-XIJNE67Y.js";
-import "./chunk-KDY5N6J4.js";
-import "./chunk-4URF65BR.js";
-import "./chunk-EZNCCO4L.js";
+} from "./chunk-D53GNZXP.js";
+import "./chunk-ZHBD65AZ.js";
+import "./chunk-RER2IDPW.js";
+import "./chunk-YDLO5M7S.js";
 export {
   ScreenWrapBehavior,
   ScreenWrapEvent,
   ScreenWrapFSM,
   ScreenWrapState
 };
-//# sourceMappingURL=screen-wrap.js.map

package/dist/shooter-2d.js

@@ -1,12 +1,11 @@
 import {
   Shooter2DBehavior,
   createShooter2DStateComponent
-} from "./chunk-STCCNLPC.js";
-import "./chunk-ID5QJYF5.js";
-import "./chunk-WWVD5DR5.js";
-import "./chunk-EZNCCO4L.js";
+} from "./chunk-L76JG73P.js";
+import "./chunk-7U4WFBWM.js";
+import "./chunk-RHW3IDQX.js";
+import "./chunk-YDLO5M7S.js";
 export {
   Shooter2DBehavior,
   createShooter2DStateComponent
 };
-//# sourceMappingURL=shooter-2d.js.map

package/dist/spark-Dx3cJbTW.d.ts

@@ -0,0 +1,356 @@
+import { Texture, Blending, ColorRepresentation } from 'three';
+import * as THREE from 'three/webgpu';
+
+/**
+ * GPU particle engine configuration types.
+ *
+ * Ported/adapted from the `threeparticles` project (MIT) — a WebGPU/TSL
+ * particle system — to replace the previous three.quarks backend. Editor-only
+ * export types from the original are omitted.
+ */
+/** Color stop definition for gradient textures. */
+interface ColorStop$1 {
+    /** CSS color string (hex, rgb, named color, etc.) */
+    color: string;
+    /** Position in gradient from 0 to 1 */
+    stop: number;
+}
+/** Available easing function identifiers. */
+type EaseFunction = 'easeLinear' | 'easeInPower1' | 'easeOutPower1' | 'easeInOutPower1' | 'easeInPower2' | 'easeOutPower2' | 'easeInOutPower2' | 'easeInPower3' | 'easeOutPower3' | 'easeInOutPower3' | 'easeInPower4' | 'easeOutPower4' | 'easeInOutPower4' | 'easeInQuad' | 'easeOutQuad' | 'easeInOutQuad' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic' | 'easeInQuart' | 'easeOutQuart' | 'easeInOutQuart' | 'easeInQuint' | 'easeOutQuint' | 'easeInOutQuint' | 'easeInSine' | 'easeOutSine' | 'easeInOutSine' | 'easeInExpo' | 'easeOutExpo' | 'easeInOutExpo' | 'easeInCirc' | 'easeOutCirc' | 'easeInOutCirc' | 'easeInElastic' | 'easeOutElastic' | 'easeInOutElastic' | 'easeInBack' | 'easeOutBack' | 'easeInOutBack';
+/** Particle shape rendering modes. */
+declare enum AppearanceMode {
+    /** Square/quad particles */
+    Square = 0,
+    /** Circular particles with soft edges */
+    Circular = 1
+}
+/** Configuration for particle visual appearance and behavior. */
+interface ParticleSettings {
+    /** Maximum number of particles in the system */
+    count: number;
+    /** Color intensity multiplier (1.0 = normal) */
+    intensity: number;
+    /** Size fade range [start, end] as progress values (0-1) */
+    fadeSize: [min: number, max: number];
+    /** Alpha fade range [start, end] as progress values (0-1) */
+    fadeAlpha: [min: number, max: number];
+    /** Alpha map morph range [start, end] as progress values (0-1) */
+    fadeAlphaMap: [min: number, max: number];
+    /** World-space gravity force [x, y, z] */
+    gravity: [x: number, y: number, z: number];
+    /** Alpha map textures for particle start state */
+    alphaMapsStart?: THREE.Texture[];
+    /** Alpha map textures for particle end state */
+    alphaMapsEnd?: THREE.Texture[];
+    /** Color gradient definitions per row */
+    colors: ColorStop$1[][];
+    /** Particle shape mode */
+    appearance: AppearanceMode;
+    /** Easing function for particle animation */
+    easeFunction: EaseFunction;
+}
+/** Configuration for WebGPU rendering settings. */
+interface RenderSettings {
+    /** Size of each alpha map slot in the texture atlas (pixels) */
+    alphaMapSize: number;
+    /** Texture filtering mode for alpha maps */
+    alphaMapFilter: THREE.MagnificationTextureFilter;
+    /** Enable frustum culling for the particle mesh */
+    frustumCulled: boolean;
+    /** Blending mode for particle rendering */
+    blendingMode: THREE.Blending;
+    /** Which side of faces to render */
+    side: THREE.Side;
+    /** Enable depth testing */
+    depthTest: boolean;
+}
+/** Configuration for particle emission behavior. */
+interface EmitterSettings {
+    /** Total duration of emission in seconds */
+    duration: number;
+    /** Number of particles to emit per cycle */
+    rate: number;
+    /** Emission timing mode: "time" spreads over duration, "burst" emits all at once */
+    spawnMode: 'time' | 'burst';
+    /** Static position blend (0 = dynamic, 1 = static at spawn position) */
+    static: number;
+    /** Apply world up-right correction during animation */
+    worldUpRight: boolean;
+    /** Loop the emission continuously */
+    loop: boolean;
+    /** Delay before first emission in seconds */
+    delay: number;
+    /** Show debug wireframe mesh at emitter position */
+    debug: boolean;
+    /** Particle lifetime range [min, max] in seconds */
+    lifetime: [min: number, max: number];
+    /** Speed range [min, max] in units per second */
+    speed: [min: number, max: number];
+    /** Size range [min, max] */
+    size: [min: number, max: number];
+    /** Minimum spawn position offset [x, y, z] */
+    startPositionMin: [x: number, y: number, z: number];
+    /** Maximum spawn position offset [x, y, z] */
+    startPositionMax: [x: number, y: number, z: number];
+    /** Minimum initial rotation [x, y, z] normalized -1 to 1 */
+    startRotationMin: [x: number, y: number, z: number];
+    /** Maximum initial rotation [x, y, z] normalized -1 to 1 */
+    startRotationMax: [x: number, y: number, z: number];
+    /** Minimum rotation speed [x, y, z] in radians per second */
+    rotationSpeedMin: [x: number, y: number, z: number];
+    /** Maximum rotation speed [x, y, z] in radians per second */
+    rotationSpeedMax: [x: number, y: number, z: number];
+    /** Minimum emission direction [x, y, z] */
+    directionMin: [x: number, y: number, z: number];
+    /** Maximum emission direction [x, y, z] */
+    directionMax: [x: number, y: number, z: number];
+}
+/**
+ * Complete particle system configuration. All sections are deep-partial at the
+ * authoring boundary; the {@link Particles} constructor fills defaults.
+ */
+interface ParticlesConfig {
+    particles: Partial<ParticleSettings> & Pick<ParticleSettings, 'count'>;
+    render?: Partial<RenderSettings>;
+    emitter?: Partial<EmitterSettings>;
+}
+
+/**
+ * WebGPU-accelerated particle system using Three.js TSL.
+ *
+ * Ported/adapted from the `threeparticles` project (MIT). The per-particle
+ * simulation (position/rotation/scale/color over life) runs in the node
+ * material on the GPU; emission is done on the CPU in `update(delta)`. No
+ * renderer/compute access is required, so it ticks from the behavior system
+ * exactly like the previous three.quarks `BatchedRenderer` node did.
+ *
+ * @module
+ */
+
+declare class Particles extends THREE.Object3D {
+    private mesh;
+    /** Base object for positioning the emitter. */
+    base: THREE.Object3D;
+    private debugMesh;
+    private material;
+    private config;
+    private uniforms;
+    private buffers;
+    private attributes;
+    private easingIndex;
+    private alphaMapCount;
+    private emitted;
+    private cursor;
+    /** Whether the particle system is currently running. */
+    running: boolean;
+    constructor(config: ParticlesConfig, geometry?: THREE.BufferGeometry);
+    private createMaterial;
+    /** Starts the particle system from the beginning. */
+    start(): void;
+    /** Restarts (alias for start). */
+    restart(): void;
+    /** Pauses the particle system, keeping current state. */
+    pause(): void;
+    /** Resumes a paused system without resetting its state. */
+    resume(): void;
+    /** Stops the particle system and hides it. */
+    stop(): void;
+    /** Whether emission loops continuously. */
+    get looping(): boolean;
+    /**
+     * For non-looping systems, whether all emitted particles have aged past
+     * their maximum lifetime (so the effect is visually finished).
+     */
+    isComplete(): boolean;
+    /** Updates the particle system. Call each frame. */
+    update(delta: number): void;
+    private _compute;
+    private _update;
+    /** Updates configuration at runtime (shallow per-section merge). */
+    updateConfig(config: Partial<ParticlesConfig>): void;
+    /** Disposes of all resources used by the particle system. */
+    dispose(): void;
+}
+
+/**
+ * Builds {@link ParticlesConfig} objects for the WebGPU/TSL particle engine
+ * ({@link Particles}) from a high-level "semantic" description.
+ *
+ * This module previously targeted the CPU-simulated `three.quarks`
+ * `ParticleSystem`. The authoring surface (semantic presets, magic modifiers,
+ * option names) is preserved; the output now drives the GPU engine instead.
+ *
+ * ## three.quarks feature-parity notes
+ *
+ * The GPU engine simulates each particle from a small set of per-instance
+ * values, so several three.quarks behaviors are approximated or unsupported:
+ *
+ * - `ColorOverLife` -> sampled gradient (`particles.colors`). Per-stop alpha is
+ *   collapsed into a single fade-in/fade-out window (`fadeAlpha`).
+ * - `SizeOverLife` (bezier) -> fade-in/out window (`fadeSize`), approximated
+ *   from the curve's endpoints.
+ * - `SpeedOverLife` (bezier) -> chooses an `easeFunction` (accelerate vs.
+ *   decelerate); the exact curve is not reproduced.
+ * - `ForceOverLife` -> constant `gravity` (midpoint of the configured ranges).
+ * - `RotationOverLife` -> per-particle `rotationSpeed`.
+ * - Cone/Sphere emitters -> emission direction/position ranges approximating
+ *   the shape; not an exact volumetric match.
+ * - `renderMode` -> only billboard is supported (sprites always face the
+ *   camera); stretched/mesh/trail modes are ignored.
+ * - `Noise`, `OrbitOverLife`, sprite-sheet tiling, and trails -> not supported.
+ */
+/** Subset of three.quarks `RenderMode` kept for preset-authoring compatibility. */
+declare enum RenderMode {
+    BillBoard = 0,
+    StretchedBillBoard = 1,
+    HorizontalBillBoard = 2,
+    VerticalBillBoard = 3,
+    Mesh = 4,
+    Trail = 5
+}
+/** A particle effect factory returning a fresh {@link Particles} object. */
+interface ParticleEffectDefinition {
+    create(): Particles;
+}
+interface ParticlePresetMaterialOptions {
+    texture?: Texture;
+    opacity?: number;
+    depthWrite?: boolean;
+    alphaTest?: number;
+    blending?: Blending;
+    uTileCount?: number;
+    vTileCount?: number;
+    blendTiles?: boolean;
+}
+type NumericRange = number | readonly [number, number];
+type CurvePoints = readonly [number, number, number, number];
+type ColorStop = readonly [ColorRepresentation, number];
+type AlphaStop = readonly [number, number];
+interface ParticleColorOverLifeConfig {
+    colors: readonly ColorStop[];
+    alpha: readonly AlphaStop[];
+}
+interface ParticleForceOverLifeConfig {
+    x?: NumericRange;
+    y?: NumericRange;
+    z?: NumericRange;
+}
+interface ParticleNoiseConfig {
+    frequency: NumericRange;
+    power: NumericRange;
+    positionAmount?: NumericRange;
+    rotationAmount?: NumericRange;
+}
+interface ParticleOrbitConfig {
+    speed: NumericRange;
+    axis?: readonly [number, number, number];
+}
+interface ParticleBehaviorOverrides {
+    colorOverLife?: ParticleColorOverLifeConfig | null;
+    sizeOverLife?: CurvePoints | null;
+    speedOverLife?: CurvePoints | null;
+    rotationOverLife?: NumericRange | null;
+    forceOverLife?: Partial<ParticleForceOverLifeConfig> | null;
+    noise?: Partial<ParticleNoiseConfig> | null;
+    orbitOverLife?: Partial<ParticleOrbitConfig> | null;
+}
+type ParticleShapeConfig = {
+    type: 'point';
+} | {
+    type: 'cone';
+    radius?: number;
+    thickness?: number;
+    angle?: number;
+    speed?: NumericRange;
+} | {
+    type: 'sphere';
+    radius?: number;
+    thickness?: number;
+    speed?: NumericRange;
+};
+type ParticleMagicAlignment = 'arcane' | 'holy' | 'corrupted' | 'nature' | 'void' | 'psychic';
+type ParticleMagicTemperament = 'calm' | 'ominous' | 'playful' | 'regal' | 'predatory';
+type ParticleMagicAgency = 'passive' | 'reactive' | 'seeking' | 'sentient-feeling';
+type ParticleMagicOrder = 'geometric' | 'organic' | 'chaotic';
+type ParticleMagicRealityEffect = 'warping' | 'illuminating' | 'binding' | 'decaying' | 'healing';
+interface ParticleMagicModifierOptions {
+    alignment: ParticleMagicAlignment;
+    temperament?: ParticleMagicTemperament;
+    agency?: ParticleMagicAgency;
+    order?: ParticleMagicOrder;
+    realityEffect?: ParticleMagicRealityEffect;
+    intensity?: number;
+}
+type ParticleMagicModifierInput = ParticleMagicAlignment | ParticleMagicModifierOptions;
+interface SemanticParticlePresetOptions extends ParticlePresetMaterialOptions {
+    behaviors?: ParticleBehaviorOverrides;
+    color?: ColorRepresentation;
+    count?: number;
+    duration?: number;
+    emissionRate?: number;
+    life?: NumericRange;
+    looping?: boolean;
+    magic?: ParticleMagicModifierInput;
+    renderMode?: RenderMode;
+    rendererEmitterSettings?: Record<string, unknown>;
+    rotation?: NumericRange;
+    shape?: ParticleShapeConfig;
+    size?: NumericRange;
+    speed?: NumericRange;
+    worldSpace?: boolean;
+}
+declare function particleEffect(create: () => Particles): ParticleEffectDefinition;
+
+declare function arcane(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function corrupted(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function holy(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function nature(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function psychic(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function voidMagic(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function arc(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function pulse(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function spark$1(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function storm(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function surge(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function haze(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function miasma(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function plume(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function smoke(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function vapor(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function drizzle(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function mist(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function splash(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function spray(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function torrent(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function blaze(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function ember(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function flamelet(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function smolder(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function spark(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+export { smolder as A, spark$1 as B, spark as C, splash as D, spray as E, storm as F, surge as G, torrent as H, vapor as I, voidMagic as J, type ParticleEffectDefinition as P, type SemanticParticlePresetOptions as S, type ParticleMagicAgency as a, type ParticleMagicAlignment as b, type ParticleMagicModifierInput as c, type ParticleMagicModifierOptions as d, type ParticleMagicOrder as e, type ParticleMagicRealityEffect as f, type ParticleMagicTemperament as g, type ParticlePresetMaterialOptions as h, Particles as i, arc as j, arcane as k, blaze as l, corrupted as m, drizzle as n, ember as o, flamelet as p, haze as q, holy as r, miasma as s, mist as t, nature as u, particleEffect as v, plume as w, psychic as x, pulse as y, smoke as z };

package/dist/thruster.js

@@ -4,15 +4,15 @@ import {
   ThrusterFSM,
   ThrusterMovementBehavior,
   ThrusterState
-} from "./chunk-2CLT36VB.js";
+} from "./chunk-BC3IJYS7.js";
 import {
   createThrusterInputComponent,
   createThrusterMovementComponent,
   createThrusterStateComponent
-} from "./chunk-KS72RZHX.js";
-import "./chunk-ID5QJYF5.js";
-import "./chunk-4URF65BR.js";
-import "./chunk-EZNCCO4L.js";
+} from "./chunk-2HLZBWGD.js";
+import "./chunk-7U4WFBWM.js";
+import "./chunk-RER2IDPW.js";
+import "./chunk-YDLO5M7S.js";
 export {
   ThrusterBehavior,
   ThrusterEvent,
@@ -23,4 +23,3 @@ export {
   createThrusterMovementComponent,
   createThrusterStateComponent
 };
-//# sourceMappingURL=thruster.js.map

package/dist/top-down-movement.js

@@ -1,15 +1,15 @@
 import {
   TopDownMovementBehavior,
   TopDownMovementRuntimeBehavior
-} from "./chunk-OYWFPIHF.js";
+} from "./chunk-HIBJDA5Z.js";
 import {
   createTopDownMovementComponent,
   createTopDownMovementInputComponent,
   createTopDownMovementStateComponent
-} from "./chunk-EIWQM6U3.js";
-import "./chunk-ID5QJYF5.js";
-import "./chunk-Y6UJOUE5.js";
-import "./chunk-EZNCCO4L.js";
+} from "./chunk-2HKY6WF7.js";
+import "./chunk-7U4WFBWM.js";
+import "./chunk-YYJP62QD.js";
+import "./chunk-YDLO5M7S.js";
 export {
   TopDownMovementBehavior,
   TopDownMovementRuntimeBehavior,
@@ -17,4 +17,3 @@ export {
   createTopDownMovementInputComponent,
   createTopDownMovementStateComponent
 };
-//# sourceMappingURL=top-down-movement.js.map

package/dist/world-boundary-2d.js

@@ -5,11 +5,11 @@ import {
   WorldBoundary2DState,
   computeWorldBoundary2DHits,
   hasAnyWorldBoundary2DHit
-} from "./chunk-XG2YMCJW.js";
-import "./chunk-KDY5N6J4.js";
-import "./chunk-Y6UJOUE5.js";
-import "./chunk-4URF65BR.js";
-import "./chunk-EZNCCO4L.js";
+} from "./chunk-E4HTCQPK.js";
+import "./chunk-ZHBD65AZ.js";
+import "./chunk-YYJP62QD.js";
+import "./chunk-RER2IDPW.js";
+import "./chunk-YDLO5M7S.js";
 export {
   WorldBoundary2DBehavior,
   WorldBoundary2DEvent,
@@ -18,4 +18,3 @@ export {
   computeWorldBoundary2DHits,
   hasAnyWorldBoundary2DHit
 };
-//# sourceMappingURL=world-boundary-2d.js.map

package/dist/world-boundary-3d.js

@@ -5,11 +5,11 @@ import {
   WorldBoundary3DState,
   computeWorldBoundary3DHits,
   hasAnyWorldBoundary3DHit
-} from "./chunk-4I6E6DGV.js";
-import "./chunk-OHCPV2NT.js";
-import "./chunk-Y6UJOUE5.js";
-import "./chunk-4URF65BR.js";
-import "./chunk-EZNCCO4L.js";
+} from "./chunk-6UMC6BB5.js";
+import "./chunk-WHKPWIQO.js";
+import "./chunk-YYJP62QD.js";
+import "./chunk-RER2IDPW.js";
+import "./chunk-YDLO5M7S.js";
 export {
   WorldBoundary3DBehavior,
   WorldBoundary3DEvent,
@@ -18,4 +18,3 @@ export {
   computeWorldBoundary3DHits,
   hasAnyWorldBoundary3DHit
 };
-//# sourceMappingURL=world-boundary-3d.js.map