sparcoon 0.7.3 → 0.9.0

package/dist/render/FXArtifactMaterial.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/render/FXArtifactMaterial.js

@@ -0,0 +1,79 @@
+import { buildArtifactDepthMaterial, buildArtifactMaterial } from "./FXArtifactMaterial.Internal.js";
+/**
+ * @internal Runtime material driver: wraps a precompiled {@link FXRenderArtifact} and builds the
+ * concrete self-contained `ShaderMaterial` via {@link buildArtifactMaterial}, which picks the flat or
+ * lit variant from the artifact's lighting capability ({@link FXRenderArtifact.lightingIntrinsics}).
+ * The emitter owns one, calls {@link buildThreeMaterial} once, and pushes the shared clock each frame.
+ */
+export class FXArtifactMaterial {
+    /**
+     * @param textures - App-supplied external textures by slot name. A missing one fails fast here
+     * rather than surfacing as a blank sampler at draw time.
+     */
+    constructor(artifact, textures = {}) {
+        this.artifact = artifact;
+        this.elapsedTime = { value: 0 };
+        this.deltaTime = { value: 0 };
+        this.velocity = { value: [0, 0, 0] };
+        this.angularVelocity = { value: [0, 0, 0] };
+        // Durable per-emitter slots for `external` texture uniforms. Unlike non-external uniforms (which
+        // bind the shared artifact slot directly), an external uniform resolves per emitter, so it gets
+        // its own slot here - and that slot is what gets bound, keeping it live-scrubbable.
+        this.externalSlots = {};
+        for (const name in artifact.uniforms) {
+            const uniform = artifact.uniforms[name];
+            if ("external" in uniform) {
+                if (!(uniform.external in textures)) {
+                    throw new Error(`FXArtifactMaterial: no texture supplied for external slot "${uniform.external}" ` +
+                        `(uniform "${name}"); pass it via FXEmitter.fromArtifacts({ textures })`);
+                }
+                this.externalSlots[name] = { value: textures[uniform.external] };
+            }
+        }
+    }
+    get attributeReads() {
+        return this.artifact.attributeReads;
+    }
+    buildThreeMaterial(varyings) {
+        return buildArtifactMaterial(this.artifact, varyings, this.elapsedTime, this.deltaTime, this.velocity, this.angularVelocity, this.externalSlots);
+    }
+    /**
+     * The `customDepthMaterial` for casting shadows: the same artifact IR spliced into a depth-packing
+     * material, so the shadow silhouette honors the authored shape/alpha-cutout (see
+     * {@link buildArtifactDepthMaterial}). Built only when the emitter opts into `castShadow`.
+     */
+    buildThreeDepthMaterial(varyings) {
+        return buildArtifactDepthMaterial(this.artifact, varyings, this.elapsedTime, this.deltaTime, this.velocity, this.angularVelocity, this.externalSlots);
+    }
+    setElapsedTime(seconds) {
+        this.elapsedTime.value = seconds;
+    }
+    setDeltaTime(seconds) {
+        this.deltaTime.value = seconds;
+    }
+    setObjectVelocity(velocity) {
+        this.velocity.value = velocity;
+    }
+    setObjectAngularVelocity(angularVelocity) {
+        this.angularVelocity.value = angularVelocity;
+    }
+    /**
+     * Render half of {@link FXEmitter.applyValues}. A non-external uniform mutates its shared artifact
+     * slot (module-scoped); an external uniform mutates this emitter's own slot. Unknown name = no-op.
+     */
+    applyUniformValues(values) {
+        for (const name in values) {
+            const value = values[name];
+            if (name in this.externalSlots) {
+                this.externalSlots[name].value = value;
+            }
+            else if (name in this.artifact.uniforms) {
+                this.artifact.uniforms[name].value =
+                    value;
+            }
+        }
+    }
+    // No-op: the artifact owns no per-emitter resources. Generated textures are module-scoped and
+    // shared (see the `fromArtifacts` texture-ownership contract); external textures are app-owned.
+    destroy() { }
+}

package/dist/render/FXMaterialOptions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Render options carried in `FXRenderArtifact.options`. Runtime-owned so the artifact contract has no
+ * editor dependency; the editor's graph material adapters import the same types.
+ */
+/**
+ * How a particle fragment's alpha is composited into the framebuffer:
+ * - `blending` - alpha blending (transparent, no depth write). The only mode that honors the
+ *   `additivity` output slot: 0 = normal "over", 1 = additive, blended continuously via the
+ *   premultiplied-alpha channel (a single `NormalBlending`, no separate additive blend mode).
+ * - `alphaHash` - stochastic alpha hashing (opaque, depth-writing, dithered discard).
+ * - `alphaTest` - hard alpha cutout (opaque, depth-writing).
+ * - `opaque` - fully opaque (alpha forced to 1).
+ *
+ * The `alphaThreshold` output slot (hard discard cutoff, default 0.0075) applies in every mode except
+ * `opaque`; `additivity` applies only in `blending`.
+ */
+export type FXRenderMode = "blending" | "alphaHash" | "alphaTest" | "opaque";
+/** Unlit (flat albedo `ShaderMaterial`) particle material options. */
+export interface FXGraphUnlitMaterialOptions {
+    /** @defaultValue `"blending"` */
+    renderMode?: FXRenderMode;
+}
+/** Lambert (lit `ShaderMaterial`, `lights`/`fog` from Three) particle material options. */
+export interface FXGraphLambertMaterialOptions {
+    /** @defaultValue `"blending"` */
+    renderMode?: FXRenderMode;
+}

package/dist/render/FXMaterialOptions.js

@@ -0,0 +1,5 @@
+/**
+ * Render options carried in `FXRenderArtifact.options`. Runtime-owned so the artifact contract has no
+ * editor dependency; the editor's graph material adapters import the same types.
+ */
+export {};

package/dist/render/FXMeshMaterial.d.ts

@@ -0,0 +1,40 @@
+import type { Material, Texture } from "three";
+import type { FXRenderArtifact } from "../artifact/FXArtifact.js";
+/**
+ * Runtime material driver for a **VFX mesh**: the mesh twin of {@link FXArtifactMaterial}. Wraps a
+ * precompiled {@link FXRenderArtifact} (compiled against the mesh render target) and builds a
+ * self-contained `ShaderMaterial` for a single, non-instanced `THREE.Mesh`. Unlike the particle
+ * driver it takes no per-particle `varyings` - a VFX mesh has no simulation and no attributes. The
+ * host builds the material once and pushes the shared clock each frame.
+ */
+export declare class FXMeshMaterial {
+    private readonly artifact;
+    private readonly elapsedTime;
+    private readonly deltaTime;
+    private readonly velocity;
+    private readonly angularVelocity;
+    private readonly externalSlots;
+    /**
+     * @param textures - App-supplied external textures by slot name. A missing one fails fast here
+     * rather than surfacing as a blank sampler at draw time.
+     */
+    constructor(artifact: FXRenderArtifact, textures?: Readonly<Record<string, Texture>>);
+    buildThreeMaterial(): Material;
+    /**
+     * The `customDepthMaterial` for casting shadows: the mesh twin of
+     * {@link FXArtifactMaterial.buildThreeDepthMaterial}. The mesh host attaches it on the `Mesh` only
+     * when the mesh opts into `castShadow`.
+     */
+    buildThreeDepthMaterial(): Material;
+    setElapsedTime(seconds: number): void;
+    setDeltaTime(seconds: number): void;
+    setObjectVelocity(velocity: readonly [number, number, number]): void;
+    setObjectAngularVelocity(angularVelocity: readonly [number, number, number]): void;
+    /**
+     * Applies a value edit (a rebind, no rebuild). A non-external uniform mutates its shared artifact
+     * slot; an external uniform mutates this mesh's own slot. Unknown name = no-op (an editor<->runtime
+     * name drift never corrupts values).
+     */
+    applyUniformValues(values: Readonly<Record<string, number | readonly number[] | Texture>>): void;
+    destroy(): void;
+}

package/dist/render/FXMeshMaterial.js

@@ -0,0 +1,77 @@
+import { buildMeshArtifactDepthMaterial, buildMeshArtifactMaterial, } from "./FXArtifactMaterial.Internal.js";
+/**
+ * Runtime material driver for a **VFX mesh**: the mesh twin of {@link FXArtifactMaterial}. Wraps a
+ * precompiled {@link FXRenderArtifact} (compiled against the mesh render target) and builds a
+ * self-contained `ShaderMaterial` for a single, non-instanced `THREE.Mesh`. Unlike the particle
+ * driver it takes no per-particle `varyings` - a VFX mesh has no simulation and no attributes. The
+ * host builds the material once and pushes the shared clock each frame.
+ */
+export class FXMeshMaterial {
+    /**
+     * @param textures - App-supplied external textures by slot name. A missing one fails fast here
+     * rather than surfacing as a blank sampler at draw time.
+     */
+    constructor(artifact, textures = {}) {
+        this.artifact = artifact;
+        this.elapsedTime = { value: 0 };
+        this.deltaTime = { value: 0 };
+        this.velocity = { value: [0, 0, 0] };
+        this.angularVelocity = { value: [0, 0, 0] };
+        // Durable per-mesh slots for `external` texture uniforms: an external uniform resolves per mesh, so
+        // it binds its own live-scrubbable slot (non-external uniforms bind the shared artifact slot).
+        this.externalSlots = {};
+        for (const name in artifact.uniforms) {
+            const uniform = artifact.uniforms[name];
+            if ("external" in uniform) {
+                if (!(uniform.external in textures)) {
+                    throw new Error(`FXMeshMaterial: no texture supplied for external slot "${uniform.external}" ` +
+                        `(uniform "${name}"); pass it via the mesh host's textures`);
+                }
+                this.externalSlots[name] = { value: textures[uniform.external] };
+            }
+        }
+    }
+    buildThreeMaterial() {
+        return buildMeshArtifactMaterial(this.artifact, this.elapsedTime, this.deltaTime, this.velocity, this.angularVelocity, this.externalSlots);
+    }
+    /**
+     * The `customDepthMaterial` for casting shadows: the mesh twin of
+     * {@link FXArtifactMaterial.buildThreeDepthMaterial}. The mesh host attaches it on the `Mesh` only
+     * when the mesh opts into `castShadow`.
+     */
+    buildThreeDepthMaterial() {
+        return buildMeshArtifactDepthMaterial(this.artifact, this.elapsedTime, this.deltaTime, this.velocity, this.angularVelocity, this.externalSlots);
+    }
+    setElapsedTime(seconds) {
+        this.elapsedTime.value = seconds;
+    }
+    setDeltaTime(seconds) {
+        this.deltaTime.value = seconds;
+    }
+    setObjectVelocity(velocity) {
+        this.velocity.value = velocity;
+    }
+    setObjectAngularVelocity(angularVelocity) {
+        this.angularVelocity.value = angularVelocity;
+    }
+    /**
+     * Applies a value edit (a rebind, no rebuild). A non-external uniform mutates its shared artifact
+     * slot; an external uniform mutates this mesh's own slot. Unknown name = no-op (an editor<->runtime
+     * name drift never corrupts values).
+     */
+    applyUniformValues(values) {
+        for (const name in values) {
+            const value = values[name];
+            if (name in this.externalSlots) {
+                this.externalSlots[name].value = value;
+            }
+            else if (name in this.artifact.uniforms) {
+                this.artifact.uniforms[name].value =
+                    value;
+            }
+        }
+    }
+    // No-op: the artifact owns no per-mesh resources (generated textures are module-scoped; external
+    // textures are app-owned).
+    destroy() { }
+}

package/dist/world/FXWorld.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The tick domain that drives effects. A world owns a pool of emitters, a registry of effects, and
+ * a single monotonic clock; one {@link FXWorld.update} call per frame advances every playing
+ * effect's timeline and then ticks the shared particle pool exactly once.
+ *
+ * An {@link FXEffect} subscribes to a world on construction and unsubscribes on
+ * {@link FXEffect.dispose} - the host never wires that up by hand. Pass a world through
+ * `FXEffectOptions.world` to place an effect in a specific world; omit it and the effect joins the
+ * lazily created default world, which the static {@link FXWorld.update} ticks.
+ *
+ * A world is only a tick/clock domain, NOT a scene graph: an effect is still a `THREE.Object3D` you
+ * add to your own scene. Two worlds give two independent clocks (for an independent time scale or an
+ * isolated group); within one world every effect shares the clock and one delta per frame, so
+ * {@link FXEffect.stop} clears rather than freezes - freeze one effect independently by giving it
+ * its own world.
+ */
+export declare class FXWorld {
+    private static defaultInstance;
+    private readonly emitters;
+    private readonly effects;
+    private elapsedTime;
+    private disposed;
+    /**
+     * The lazily created default world - the one an effect joins when its options carry no `world`.
+     * Nothing is allocated until the first effect or the first {@link FXWorld.update}.
+     */
+    static getDefault(): FXWorld;
+    /** Advances the default world by `deltaTime`; call once per frame. See {@link update}. */
+    static update(deltaTime: number): void;
+    /**
+     * Advances this world by `deltaTime` seconds: every playing effect drives its own timeline and
+     * meshes, then the shared particle pool ticks once. Call exactly once per frame, before rendering.
+     * A disposed world is a no-op.
+     */
+    update(deltaTime: number): void;
+    /**
+     * Disposes every effect registered in this world (each frees its emitters and mesh resources),
+     * then drops any remaining emitters. Idempotent. After this the world's {@link update} is a
+     * no-op; disposing the default world simply makes the next {@link getDefault} create a fresh one.
+     */
+    dispose(): void;
+}

package/dist/world/FXWorld.js

@@ -0,0 +1,103 @@
+import { EMITTER_TIME_WRAP_PERIOD } from "../emitter/FXEmitter.Internal.js";
+/**
+ * The tick domain that drives effects. A world owns a pool of emitters, a registry of effects, and
+ * a single monotonic clock; one {@link FXWorld.update} call per frame advances every playing
+ * effect's timeline and then ticks the shared particle pool exactly once.
+ *
+ * An {@link FXEffect} subscribes to a world on construction and unsubscribes on
+ * {@link FXEffect.dispose} - the host never wires that up by hand. Pass a world through
+ * `FXEffectOptions.world` to place an effect in a specific world; omit it and the effect joins the
+ * lazily created default world, which the static {@link FXWorld.update} ticks.
+ *
+ * A world is only a tick/clock domain, NOT a scene graph: an effect is still a `THREE.Object3D` you
+ * add to your own scene. Two worlds give two independent clocks (for an independent time scale or an
+ * isolated group); within one world every effect shares the clock and one delta per frame, so
+ * {@link FXEffect.stop} clears rather than freezes - freeze one effect independently by giving it
+ * its own world.
+ */
+export class FXWorld {
+    constructor() {
+        this.emitters = [];
+        this.effects = [];
+        this.elapsedTime = 0;
+        this.disposed = false;
+    }
+    /**
+     * The lazily created default world - the one an effect joins when its options carry no `world`.
+     * Nothing is allocated until the first effect or the first {@link FXWorld.update}.
+     */
+    static getDefault() {
+        if (FXWorld.defaultInstance === undefined || FXWorld.defaultInstance.disposed) {
+            FXWorld.defaultInstance = new FXWorld();
+        }
+        return FXWorld.defaultInstance;
+    }
+    /** Advances the default world by `deltaTime`; call once per frame. See {@link update}. */
+    static update(deltaTime) {
+        FXWorld.getDefault().update(deltaTime);
+    }
+    /**
+     * Advances this world by `deltaTime` seconds: every playing effect drives its own timeline and
+     * meshes, then the shared particle pool ticks once. Call exactly once per frame, before rendering.
+     * A disposed world is a no-op.
+     */
+    update(deltaTime) {
+        if (this.disposed) {
+            return;
+        }
+        for (const effect of this.effects) {
+            effect.advanceFrame(deltaTime);
+        }
+        // Wrap the clock so a float32 `u_time` keeps sub-millisecond resolution in long sessions, then
+        // tick the whole pool once with the shared clock.
+        this.elapsedTime = (this.elapsedTime + deltaTime) % EMITTER_TIME_WRAP_PERIOD;
+        for (const emitter of this.emitters) {
+            emitter.onWorldTick(deltaTime, this.elapsedTime);
+        }
+    }
+    /**
+     * Disposes every effect registered in this world (each frees its emitters and mesh resources),
+     * then drops any remaining emitters. Idempotent. After this the world's {@link update} is a
+     * no-op; disposing the default world simply makes the next {@link getDefault} create a fresh one.
+     */
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        // dispose() unregisters each effect from this world, so iterate a snapshot.
+        for (const effect of [...this.effects]) {
+            effect.dispose();
+        }
+        for (const emitter of [...this.emitters]) {
+            emitter.destroy();
+        }
+        this.effects.length = 0;
+        this.emitters.length = 0;
+        if (FXWorld.defaultInstance === this) {
+            FXWorld.defaultInstance = undefined;
+        }
+    }
+    /** @internal Called by {@link FXEffect}'s constructor. */
+    registerEffect(effect) {
+        this.effects.push(effect);
+    }
+    /** @internal Called by {@link FXEffect.dispose}. */
+    unregisterEffect(effect) {
+        const index = this.effects.indexOf(effect);
+        if (index !== -1) {
+            this.effects.splice(index, 1);
+        }
+    }
+    /** @internal Called by {@link FXEmitter}'s constructor. */
+    registerEmitter(emitter) {
+        this.emitters.push(emitter);
+    }
+    /** @internal Called by {@link FXEmitter.destroy}. */
+    unregisterEmitter(emitter) {
+        const index = this.emitters.indexOf(emitter);
+        if (index !== -1) {
+            this.emitters.splice(index, 1);
+        }
+    }
+}

package/package.json

@@ -1,60 +1,76 @@
 {
   "name": "sparcoon",
-  "version": "0.7.3",
-  "description": "Instanced-mesh particle system for Three.js.",
+  "version": "0.9.0",
+  "description": "Runtime for VFX artifacts authored in the Sparcoon Editor.",
   "keywords": [
+    "three",
+    "threejs",
+    "three.js",
     "particles",
     "particle-system",
-    "three.js",
-    "3d",
-    "webgl",
+    "vfx",
+    "visual-effects",
+    "fx",
     "instanced",
+    "instancing",
     "billboard",
-    "typescript"
+    "webgl",
+    "3d",
+    "animation",
+    "typescript",
+    "sparcoon"
   ],
-  "author": "jango",
-  "license": "MIT",
+  "homepage": "https://github.com/jango-git/sparcoon#readme",
+  "bugs": {
+    "url": "https://github.com/jango-git/sparcoon/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jango-git/sparcoon.git"
   },
+  "license": "MIT",
+  "author": "jango",
   "type": "module",
-  "sideEffects": false,
-  "scripts": {
-    "clean": "rm -rf dist",
-    "build": "npm run clean && rollup -c",
-    "prepublishOnly": "npm run build"
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
   },
   "main": "./dist/index.js",
-  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "README.md",
     "LICENSE"
   ],
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "lint": "eslint src",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "format": "prettier --write . && eslint src --fix",
+    "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "fast-simplex-noise": "^4.0.0",
-    "ferrsign": "^0.0.4",
     "three": ">=0.157.0 <0.180.0"
   },
   "devDependencies": {
-    "@rollup/plugin-node-resolve": "^16.0.1",
-    "@rollup/plugin-commonjs": "^29.0.2",
-    "@types/node": "^25.0.2",
+    "@types/node": "^20.0.0",
     "@types/three": "^0.157.0",
     "@typescript-eslint/eslint-plugin": "^8.32.0",
     "@typescript-eslint/parser": "^8.32.0",
+    "@vitest/coverage-v8": "^4.1.9",
     "eslint": "^9.26.0",
-    "rollup": "^4.40.2",
-    "rollup-plugin-string": "^3.0.0",
-    "rollup-plugin-typescript2": "^0.36.0",
-    "ts-transformer-minify-privates": "^1.0.0",
-    "typescript": "^5.8.3"
+    "prettier": "^3.9.5",
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.9"
   }
 }

package/dist/_virtual/2d.js

@@ -1,3 +0,0 @@
-var _2d = {};
-
-export { _2d as __exports };

package/dist/_virtual/3d.js

@@ -1,3 +0,0 @@
-var _3d = {};
-
-export { _3d as __exports };

package/dist/_virtual/4d.js

@@ -1,3 +0,0 @@
-var _4d = {};
-
-export { _4d as __exports };

package/dist/_virtual/mod.js

@@ -1,5 +0,0 @@
-import { __require as requireMod } from '../node_modules/fast-simplex-noise/lib/mod.js';
-
-var modExports = requireMod();
-
-export { modExports as m };

package/dist/_virtual/mod2.js

@@ -1,3 +0,0 @@
-var mod = {};
-
-export { mod as __exports };

package/dist/emitter/behavior/FXBehavior.d.ts

@@ -1,24 +0,0 @@
-import type { InstancedBufferAttribute } from "three";
-import type { FXPropertyName } from "../../instancedParticle/shared";
-/**
- * Abstract base for particle behavior modules that mutate per-particle properties each frame
- *
- * @typeParam T - Map of local property keys to {@link FXPropertyName} identifiers,
- * declaring which particle attributes this behavior reads or writes
- */
-export declare abstract class FXBehavior<T extends Record<string, FXPropertyName> = Record<string, FXPropertyName>> {
-    /** Particle attributes required by this behavior */
-    abstract readonly requiredProperties: T;
-    /**
-     * Called once per frame to update all live particles
-     *
-     * @param properties - Buffer attributes keyed by `requiredProperties`
-     * @param instanceCount - Number of currently live particles
-     * @param deltaTime - Elapsed time since the last frame, in seconds
-     */
-    abstract update(properties: {
-        [K in keyof T]: InstancedBufferAttribute;
-    }, instanceCount: number, deltaTime: number): void;
-    /** Releases any resources held by this behavior */
-    destroy?(): void;
-}

package/dist/emitter/behavior/FXBehavior.js

@@ -1,10 +0,0 @@
-/**
- * Abstract base for particle behavior modules that mutate per-particle properties each frame
- *
- * @typeParam T - Map of local property keys to {@link FXPropertyName} identifiers,
- * declaring which particle attributes this behavior reads or writes
- */
-class FXBehavior {
-}
-
-export { FXBehavior };

package/dist/emitter/behavior/FXBehaviorDirectionalForce.d.ts

@@ -1,23 +0,0 @@
-import { type Vector3Like } from "../../miscellaneous/math";
-import type { FXVector3Config } from "../../miscellaneous/miscellaneous";
-import { FXBehavior } from "./FXBehavior";
-/**
- * Applies constant acceleration to all particles
- */
-export declare class FXBehaviorDirectionalForce extends FXBehavior<{
-    builtin: "Matrix4";
-}> {
-    private readonly directionInternal;
-    private magnitudeInternal;
-    /**
-     * @param direction - Direction vector (will be normalized)
-     * @param magnitude - Acceleration magnitude in units/second²
-     */
-    constructor(direction: Vector3Like, magnitude: number);
-    /** Direction vector (normalized) */
-    get direction(): Vector3Like;
-    /** Acceleration magnitude in units/second² */
-    get magnitude(): number;
-    set direction(value: FXVector3Config);
-    set magnitude(value: number);
-}

package/dist/emitter/behavior/FXBehaviorDirectionalForce.js

@@ -1,72 +0,0 @@
-import { Vector3 } from 'three';
-import { assertValidNumber } from '../../miscellaneous/asserts.js';
-import { EPSILON } from '../../miscellaneous/math.js';
-import { resolveFXVector3Config, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z } from '../../miscellaneous/miscellaneous.js';
-import { FXBehavior } from './FXBehavior.js';
-
-/**
- * Applies constant acceleration to all particles
- */
-class FXBehaviorDirectionalForce extends FXBehavior {
-    /**
-     * @param direction - Direction vector (will be normalized)
-     * @param magnitude - Acceleration magnitude in units/second²
-     */
-    constructor(direction, magnitude) {
-        super();
-        /** @internal */
-        this.requiredProperties = { builtin: "Matrix4" };
-        const resolvedDirection = resolveFXVector3Config(direction);
-        assertValidNumber(resolvedDirection.x, "FXBehaviorDirectionalForce.direction.x");
-        assertValidNumber(resolvedDirection.y, "FXBehaviorDirectionalForce.direction.y");
-        assertValidNumber(resolvedDirection.z, "FXBehaviorDirectionalForce.direction.z");
-        assertValidNumber(magnitude, "FXBehaviorDirectionalForce.constructor.magnitude");
-        this._private_directionInternal = new Vector3(resolvedDirection.x, resolvedDirection.y, resolvedDirection.z);
-        if (this._private_directionInternal.lengthSq() <= EPSILON) {
-            throw new Error("FXBehaviorDirectionalForce.direction: vector cannot be zero");
-        }
-        this._private_directionInternal.normalize();
-        this._private_magnitudeInternal = magnitude;
-    }
-    /** Direction vector (normalized) */
-    get direction() {
-        return this._private_directionInternal;
-    }
-    /** Acceleration magnitude in units/second² */
-    get magnitude() {
-        return this._private_magnitudeInternal;
-    }
-    set direction(value) {
-        const resolved = resolveFXVector3Config(value);
-        assertValidNumber(resolved.x, "FXBehaviorDirectionalForce.direction.x");
-        assertValidNumber(resolved.y, "FXBehaviorDirectionalForce.direction.y");
-        assertValidNumber(resolved.z, "FXBehaviorDirectionalForce.direction.z");
-        this._private_directionInternal.set(resolved.x, resolved.y, resolved.z);
-        if (this._private_directionInternal.lengthSq() < EPSILON) {
-            throw new Error("FXBehaviorDirectionalForce.direction: vector cannot be zero");
-        }
-        this._private_directionInternal.normalize();
-    }
-    set magnitude(value) {
-        assertValidNumber(value, "FXBehaviorDirectionalForce.magnitude");
-        this._private_magnitudeInternal = value;
-    }
-    /** @internal */
-    update(properties, instanceCount, deltaTime) {
-        const { builtin } = properties;
-        const { array, itemSize } = builtin;
-        const scale = this._private_magnitudeInternal * deltaTime;
-        const offsetX = this._private_directionInternal.x * scale;
-        const offsetY = this._private_directionInternal.y * scale;
-        const offsetZ = this._private_directionInternal.z * scale;
-        for (let i = 0; i < instanceCount; i++) {
-            const itemOffset = i * itemSize;
-            array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] += offsetX;
-            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] += offsetY;
-            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Z] += offsetZ;
-        }
-        builtin.needsUpdate = true;
-    }
-}
-
-export { FXBehaviorDirectionalForce };