sparcoon 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jango
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/behaviorModules/FXBehaviorDirectionalGravity.d.ts

@@ -0,0 +1,21 @@
+import type { Vector3Like } from "../miscellaneous/math";
+import { type FXVector3Config } from "../miscellaneous/miscellaneous";
+import { FXBehaviorModule } from "./FXBehaviorModule";
+/**
+ * Applies constant acceleration to all particles.
+ *
+ * Adds the direction vector to particle velocity each frame.
+ */
+export declare class FXBehaviorDirectionalGravity extends FXBehaviorModule<{
+    builtin: "Matrix4";
+}> {
+    private directionInternal;
+    /**
+     * @param direction - Acceleration vector in units/second²
+     */
+    constructor(direction: Vector3Like);
+    /** Acceleration vector in units/second² */
+    get direction(): Vector3Like;
+    /** Acceleration vector in units/second² */
+    set direction(value: FXVector3Config);
+}

package/dist/behaviorModules/FXBehaviorDirectionalGravity.js

@@ -0,0 +1,47 @@
+import { assertValidNumber } from '../miscellaneous/asserts.js';
+import { resolveFXVector2Config, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y } from '../miscellaneous/miscellaneous.js';
+import { FXBehaviorModule } from './FXBehaviorModule.js';
+
+/**
+ * Applies constant acceleration to all particles.
+ *
+ * Adds the direction vector to particle velocity each frame.
+ */
+class FXBehaviorDirectionalGravity extends FXBehaviorModule {
+    /**
+     * @param direction - Acceleration vector in units/second²
+     */
+    constructor(direction) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_directionInternal = resolveFXVector2Config(direction);
+        assertValidNumber(this._private_directionInternal.x, "UIBehaviorDirectionalGravity.constructor.direction.x");
+        assertValidNumber(this._private_directionInternal.y, "UIBehaviorDirectionalGravity.constructor.direction.y");
+    }
+    /** Acceleration vector in units/second² */
+    get direction() {
+        return this._private_directionInternal;
+    }
+    /** Acceleration vector in units/second² */
+    set direction(value) {
+        this._private_directionInternal = resolveFXVector2Config(value);
+        assertValidNumber(this._private_directionInternal.x, "UIBehaviorDirectionalGravity.direction.x");
+        assertValidNumber(this._private_directionInternal.y, "UIBehaviorDirectionalGravity.direction.y");
+    }
+    /** @internal */
+    update(properties, instanceCount, deltaTime) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        const offsetX = this._private_directionInternal.x * deltaTime;
+        const offsetY = this._private_directionInternal.y * deltaTime;
+        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;
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXBehaviorDirectionalGravity };

package/dist/behaviorModules/FXBehaviorModule.d.ts

@@ -0,0 +1,14 @@
+import type { InstancedBufferAttribute } from "three";
+import type { FXPropertyName } from "../instancedParticle/shared";
+/**
+ * Base class for particle behavior modules.
+ *
+ * Behavior modules update particle properties each frame.
+ */
+export declare abstract class FXBehaviorModule<T extends Record<string, FXPropertyName> = Record<string, FXPropertyName>> {
+    abstract readonly requiredProperties: T;
+    abstract update(properties: {
+        [K in keyof T]: InstancedBufferAttribute;
+    }, instanceCount: number, deltaTime: number): void;
+    destroy?(): void;
+}

package/dist/behaviorModules/FXBehaviorModule.js

@@ -0,0 +1,9 @@
+/**
+ * Base class for particle behavior modules.
+ *
+ * Behavior modules update particle properties each frame.
+ */
+class FXBehaviorModule {
+}
+
+export { FXBehaviorModule };

package/dist/behaviorModules/FXBehaviorPointGravity.d.ts

@@ -0,0 +1,39 @@
+import type { Vector3Like } from "../miscellaneous/math";
+import { type FXRange, type FXRangeConfig, type FXVector3Config } from "../miscellaneous/miscellaneous";
+import { FXBehaviorModule } from "./FXBehaviorModule";
+/**
+ * Applies gravity attraction toward a point.
+ *
+ * Force follows inverse power law: strength / distance^exponent. Particles closer than threshold are unaffected.
+ */
+export declare class FXBehaviorPointGravity extends FXBehaviorModule<{
+    builtin: "Matrix4";
+}> {
+    private centerInternal;
+    private strengthInternal;
+    private exponentInternal;
+    private thresholdInternal;
+    /**
+     * @param center - Gravity center position
+     * @param strength - Force multiplier range. Accepts number, tuple, or range object
+     * @param exponent - Distance power exponent range. Accepts number, tuple, or range object
+     * @param threshold - Minimum distance range. Accepts number, tuple, or range object
+     */
+    constructor(center: Vector3Like, strength: FXRangeConfig, exponent?: FXRangeConfig, threshold?: FXRangeConfig);
+    /** Gravity center position */
+    get center(): Vector3Like;
+    /** Force multiplier range */
+    get strength(): FXRange;
+    /** Distance power exponent range */
+    get exponent(): FXRange;
+    /** Minimum distance range */
+    get threshold(): FXRange;
+    /** Gravity center position */
+    set center(value: FXVector3Config);
+    /** Force multiplier range */
+    set strength(value: FXRangeConfig);
+    /** Distance power exponent range */
+    set exponent(value: FXRangeConfig);
+    /** Minimum distance range */
+    set threshold(value: FXRangeConfig);
+}

package/dist/behaviorModules/FXBehaviorPointGravity.js

@@ -0,0 +1,110 @@
+import { MathUtils } from 'three';
+import { assertValidNumber } from '../miscellaneous/asserts.js';
+import { resolveFXVector2Config, resolveFXRangeConfig, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y } from '../miscellaneous/miscellaneous.js';
+import { FXBehaviorModule } from './FXBehaviorModule.js';
+
+/**
+ * Applies gravity attraction toward a point.
+ *
+ * Force follows inverse power law: strength / distance^exponent. Particles closer than threshold are unaffected.
+ */
+class FXBehaviorPointGravity extends FXBehaviorModule {
+    /**
+     * @param center - Gravity center position
+     * @param strength - Force multiplier range. Accepts number, tuple, or range object
+     * @param exponent - Distance power exponent range. Accepts number, tuple, or range object
+     * @param threshold - Minimum distance range. Accepts number, tuple, or range object
+     */
+    constructor(center, strength, exponent = 2, threshold = 1) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_centerInternal = resolveFXVector2Config(center);
+        assertValidNumber(this._private_centerInternal.x, "UIBehaviorPointGravity.constructor.center.x");
+        assertValidNumber(this._private_centerInternal.y, "UIBehaviorPointGravity.constructor.center.y");
+        this._private_strengthInternal = resolveFXRangeConfig(strength);
+        assertValidNumber(this._private_strengthInternal.min, "UIBehaviorPointGravity.constructor.strength.min");
+        assertValidNumber(this._private_strengthInternal.max, "UIBehaviorPointGravity.constructor.strength.max");
+        this._private_exponentInternal = resolveFXRangeConfig(exponent);
+        assertValidNumber(this._private_exponentInternal.min, "UIBehaviorPointGravity.constructor.exponent.min");
+        assertValidNumber(this._private_exponentInternal.max, "UIBehaviorPointGravity.constructor.exponent.max");
+        this._private_thresholdInternal = resolveFXRangeConfig(threshold);
+        assertValidNumber(this._private_thresholdInternal.min, "UIBehaviorPointGravity.constructor.threshold.min");
+        assertValidNumber(this._private_thresholdInternal.max, "UIBehaviorPointGravity.constructor.threshold.max");
+    }
+    /** Gravity center position */
+    get center() {
+        return this._private_centerInternal;
+    }
+    /** Force multiplier range */
+    get strength() {
+        return this._private_strengthInternal;
+    }
+    /** Distance power exponent range */
+    get exponent() {
+        return this._private_exponentInternal;
+    }
+    /** Minimum distance range */
+    get threshold() {
+        return this._private_thresholdInternal;
+    }
+    /** Gravity center position */
+    set center(value) {
+        this._private_centerInternal = resolveFXVector2Config(value);
+        assertValidNumber(this._private_centerInternal.x, "UIBehaviorPointGravity.center.x");
+        assertValidNumber(this._private_centerInternal.y, "UIBehaviorPointGravity.center.y");
+    }
+    /** Force multiplier range */
+    set strength(value) {
+        this._private_strengthInternal = resolveFXRangeConfig(value);
+        assertValidNumber(this._private_strengthInternal.min, "UIBehaviorPointGravity.strength.min");
+        assertValidNumber(this._private_strengthInternal.max, "UIBehaviorPointGravity.strength.max");
+    }
+    /** Distance power exponent range */
+    set exponent(value) {
+        this._private_exponentInternal = resolveFXRangeConfig(value);
+        assertValidNumber(this._private_exponentInternal.min, "UIBehaviorPointGravity.exponent.min");
+        assertValidNumber(this._private_exponentInternal.max, "UIBehaviorPointGravity.exponent.max");
+    }
+    /** Minimum distance range */
+    set threshold(value) {
+        this._private_thresholdInternal = resolveFXRangeConfig(value);
+        assertValidNumber(this._private_thresholdInternal.min, "UIBehaviorPointGravity.threshold.min");
+        assertValidNumber(this._private_thresholdInternal.max, "UIBehaviorPointGravity.threshold.max");
+    }
+    /** @internal */
+    update(properties, instanceCount, deltaTime) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        for (let i = 0; i < instanceCount; i++) {
+            const itemOffset = i * itemSize;
+            const dx = this._private_centerInternal.x - array[itemOffset + BUILTIN_OFFSET_POSITION_X];
+            const dy = this._private_centerInternal.y - array[itemOffset + BUILTIN_OFFSET_POSITION_Y];
+            // Constant over the life of a particle but different for each particle
+            const thresholdT = array[itemOffset + BUILTIN_OFFSET_RANDOM_A];
+            const threshold = MathUtils.lerp(this.threshold.min, this.threshold.max, thresholdT);
+            const thresholdSquared = threshold * threshold;
+            const distanceSquared = dx * dx + dy * dy;
+            if (distanceSquared < thresholdSquared) {
+                continue;
+            }
+            // Constant over the life of a particle but different for each particle
+            const strengthT = array[itemOffset + BUILTIN_OFFSET_RANDOM_B];
+            const strength = MathUtils.lerp(this._private_strengthInternal.min, this._private_strengthInternal.max, strengthT);
+            // Constant over the life of a particle but different for each particle
+            const exponentT = array[itemOffset + BUILTIN_OFFSET_RANDOM_C];
+            const exponent = MathUtils.lerp(this._private_exponentInternal.min, this._private_exponentInternal.max, exponentT);
+            const distance = Math.sqrt(distanceSquared);
+            const forceMagnitude = strength / Math.pow(distance, exponent);
+            const directionX = dx / distance;
+            const directionY = dy / distance;
+            const accelerationX = directionX * forceMagnitude;
+            const accelerationY = directionY * forceMagnitude;
+            array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] += accelerationX * deltaTime;
+            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] += accelerationY * deltaTime;
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXBehaviorPointGravity };

package/dist/behaviorModules/FXBehaviorScaleOverLife.d.ts

@@ -0,0 +1,22 @@
+import { type FXAspectConfig, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import { FXBehaviorModule } from "./FXBehaviorModule";
+/**
+ * Animates particle scale over lifetime.
+ *
+ * Interpolates between scale anchors based on particle age. Requires at least 2 anchors.
+ */
+export declare class FXBehaviorScaleOverLife extends FXBehaviorModule<{
+    builtin: "Matrix4";
+}> {
+    private readonly scales;
+    private aspectInternal;
+    /**
+     * @param scales - Scale anchor points. Each accepts number, tuple, or range object
+     * @param aspect - Width/height ratio. Accepts number or texture
+     */
+    constructor(scales: FXRangeConfig[], aspect?: FXAspectConfig);
+    /** Width/height aspect ratio */
+    get aspect(): number;
+    /** Width/height aspect ratio */
+    set aspect(value: FXAspectConfig);
+}

package/dist/behaviorModules/FXBehaviorScaleOverLife.js

@@ -0,0 +1,66 @@
+import { MathUtils } from 'three';
+import { assertValidNonNegativeNumber, assertValidPositiveNumber } from '../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, resolveAspect, BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_LIFETIME, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_SCALE_X, BUILTIN_OFFSET_SCALE_Y } from '../miscellaneous/miscellaneous.js';
+import { FXBehaviorModule } from './FXBehaviorModule.js';
+
+/**
+ * Animates particle scale over lifetime.
+ *
+ * Interpolates between scale anchors based on particle age. Requires at least 2 anchors.
+ */
+class FXBehaviorScaleOverLife extends FXBehaviorModule {
+    /**
+     * @param scales - Scale anchor points. Each accepts number, tuple, or range object
+     * @param aspect - Width/height ratio. Accepts number or texture
+     */
+    constructor(scales, aspect = 1) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_scales = [];
+        if (scales.length < 2) {
+            throw new Error("UIBehaviorScaleOverLife.scales: the number of scale anchors must be more than two");
+        }
+        for (let i = 0; i < scales.length; i++) {
+            const scale = resolveFXRangeConfig(scales[i]);
+            assertValidNonNegativeNumber(scale.min, `UIBehaviorScaleOverLife.constructor.scales[${i}].min`);
+            assertValidNonNegativeNumber(scale.max, `UIBehaviorScaleOverLife.constructor.scales[${i}].max`);
+            this._private_scales.push(scale);
+        }
+        this._private_aspectInternal = resolveAspect(aspect);
+        assertValidPositiveNumber(this._private_aspectInternal, "UIBehaviorScaleOverLife.constructor.aspect");
+    }
+    /** Width/height aspect ratio */
+    get aspect() {
+        return this._private_aspectInternal;
+    }
+    /** Width/height aspect ratio */
+    set aspect(value) {
+        this._private_aspectInternal = resolveAspect(value);
+        assertValidPositiveNumber(this._private_aspectInternal, "UIBehaviorScaleOverLife.aspect");
+    }
+    /** @internal */
+    update(properties, instanceCount) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        for (let i = 0; i < instanceCount; i++) {
+            const itemOffset = i * itemSize;
+            const lifeT = Math.min(array[itemOffset + BUILTIN_OFFSET_AGE] / array[itemOffset + BUILTIN_OFFSET_LIFETIME], 1);
+            const segment = (this._private_scales.length - 1) * lifeT;
+            const index = Math.floor(segment);
+            // Constant over the life of a particle but different for each particle
+            const scaleT = array[itemOffset + BUILTIN_OFFSET_RANDOM_A];
+            const localT = segment - index;
+            const scaleRange0 = this._private_scales[index];
+            const scaleRange1 = this._private_scales[index + 1];
+            const scale0 = MathUtils.lerp(scaleRange0.min, scaleRange0.max, scaleT);
+            const scale1 = MathUtils.lerp(scaleRange1.min, scaleRange1.max, scaleT);
+            const interpolatedScale = scale0 + (scale1 - scale0) * localT;
+            array[itemOffset + BUILTIN_OFFSET_SCALE_X] = interpolatedScale * this._private_aspectInternal;
+            array[itemOffset + BUILTIN_OFFSET_SCALE_Y] = interpolatedScale;
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXBehaviorScaleOverLife };

package/dist/behaviorModules/FXBehaviorTorqueDamping.d.ts

@@ -0,0 +1,20 @@
+import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import { FXBehaviorModule } from "./FXBehaviorModule";
+/**
+ * Reduces particle angular velocity over time.
+ *
+ * Applies exponential decay to torque. Damping of 0 means no effect, 1 means instant stop.
+ */
+export declare class FXBehaviorTorqueDamping extends FXBehaviorModule<{
+    builtin: "Matrix4";
+}> {
+    private dampingInternal;
+    /**
+     * @param damping - Damping coefficient range (0-1). Accepts number, tuple, or range object
+     */
+    constructor(damping: number);
+    /** Damping coefficient range (0-1) */
+    get damping(): FXRange;
+    /** Damping coefficient range (0-1) */
+    set damping(value: FXRangeConfig);
+}

package/dist/behaviorModules/FXBehaviorTorqueDamping.js

@@ -0,0 +1,48 @@
+import { MathUtils } from 'three';
+import { assertValidNonNegativeNumber } from '../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_TORQUE } from '../miscellaneous/miscellaneous.js';
+import { FXBehaviorModule } from './FXBehaviorModule.js';
+
+/**
+ * Reduces particle angular velocity over time.
+ *
+ * Applies exponential decay to torque. Damping of 0 means no effect, 1 means instant stop.
+ */
+class FXBehaviorTorqueDamping extends FXBehaviorModule {
+    /**
+     * @param damping - Damping coefficient range (0-1). Accepts number, tuple, or range object
+     */
+    constructor(damping) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_dampingInternal = resolveFXRangeConfig(damping);
+        assertValidNonNegativeNumber(this._private_dampingInternal.min, `UIBehaviorTorqueDamping.constructor.damping.min`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.max, `UIBehaviorTorqueDamping.constructor.damping.max`);
+    }
+    /** Damping coefficient range (0-1) */
+    get damping() {
+        return this._private_dampingInternal;
+    }
+    /** Damping coefficient range (0-1) */
+    set damping(value) {
+        this._private_dampingInternal = resolveFXRangeConfig(value);
+        assertValidNonNegativeNumber(this._private_dampingInternal.min, `UIBehaviorTorqueDamping.damping.min`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.max, `UIBehaviorTorqueDamping.damping.max`);
+    }
+    /** @internal */
+    update(properties, instanceCount, deltaTime) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        for (let i = 0; i < instanceCount; i++) {
+            const itemOffset = i * itemSize;
+            // Constant over the life of a particle but different for each particle
+            const dampingT = array[itemOffset + BUILTIN_OFFSET_RANDOM_B];
+            const dampingFactor = Math.pow(1 - MathUtils.lerp(this._private_dampingInternal.min, this._private_dampingInternal.max, dampingT), deltaTime);
+            array[itemOffset + BUILTIN_OFFSET_TORQUE] *= dampingFactor;
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXBehaviorTorqueDamping };

package/dist/behaviorModules/FXBehaviorTorqueNoise.d.ts

@@ -0,0 +1,26 @@
+import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import { FXBehaviorModule } from "./FXBehaviorModule";
+/**
+ * Applies noise-based angular acceleration to particles.
+ *
+ * Uses 2D noise based on particle position. Higher scale means finer noise detail.
+ */
+export declare class FXBehaviorTorqueNoise extends FXBehaviorModule<{
+    builtin: "Matrix4";
+}> {
+    private scaleInternal;
+    private strengthInternal;
+    /**
+     * @param scale - Noise frequency range. Accepts number, tuple, or range object
+     * @param strength - Force multiplier range. Accepts number, tuple, or range object
+     */
+    constructor(scale: number, strength: number);
+    /** Noise frequency range */
+    get scale(): FXRange;
+    /** Force multiplier range */
+    get strength(): FXRange;
+    /** Noise frequency range */
+    set scale(value: FXRangeConfig);
+    /** Force multiplier range */
+    set strength(value: FXRangeConfig);
+}

package/dist/behaviorModules/FXBehaviorTorqueNoise.js

@@ -0,0 +1,66 @@
+import { MathUtils } from 'three';
+import { assertValidPositiveNumber, assertValidNonNegativeNumber } from '../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_RANDOM_C, generateNoise3D, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_TORQUE } from '../miscellaneous/miscellaneous.js';
+import { FXBehaviorModule } from './FXBehaviorModule.js';
+
+/**
+ * Applies noise-based angular acceleration to particles.
+ *
+ * Uses 2D noise based on particle position. Higher scale means finer noise detail.
+ */
+class FXBehaviorTorqueNoise extends FXBehaviorModule {
+    /**
+     * @param scale - Noise frequency range. Accepts number, tuple, or range object
+     * @param strength - Force multiplier range. Accepts number, tuple, or range object
+     */
+    constructor(scale, strength) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_scaleInternal = resolveFXRangeConfig(scale);
+        assertValidPositiveNumber(this._private_scaleInternal.min, `UIBehaviorTorqueNoise.constructor.scale.min`);
+        assertValidPositiveNumber(this._private_scaleInternal.max, `UIBehaviorTorqueNoise.constructor.scale.max`);
+        this._private_strengthInternal = resolveFXRangeConfig(strength);
+        assertValidNonNegativeNumber(this._private_strengthInternal.min, `UIBehaviorTorqueNoise.constructor.strength.min`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.max, `UIBehaviorTorqueNoise.constructor.strength.max`);
+    }
+    /** Noise frequency range */
+    get scale() {
+        return this._private_scaleInternal;
+    }
+    /** Force multiplier range */
+    get strength() {
+        return this._private_strengthInternal;
+    }
+    /** Noise frequency range */
+    set scale(value) {
+        this._private_scaleInternal = resolveFXRangeConfig(value);
+        assertValidPositiveNumber(this._private_scaleInternal.min, `UIBehaviorTorqueNoise.scale.min`);
+        assertValidPositiveNumber(this._private_scaleInternal.max, `UIBehaviorTorqueNoise.scale.max`);
+    }
+    /** Force multiplier range */
+    set strength(value) {
+        this._private_strengthInternal = resolveFXRangeConfig(value);
+        assertValidNonNegativeNumber(this._private_strengthInternal.min, `UIBehaviorTorqueNoise.strength.min`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.max, `UIBehaviorTorqueNoise.strength.max`);
+    }
+    /** @internal */
+    update(properties, instanceCount, deltaTime) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        for (let i = 0; i < instanceCount; i++) {
+            const itemOffset = i * itemSize;
+            // Constant over the life of a particle but different for each particle
+            const scaleT = array[itemOffset + BUILTIN_OFFSET_RANDOM_C];
+            const scale = MathUtils.lerp(this._private_scaleInternal.min, this._private_scaleInternal.max, scaleT);
+            const noise = generateNoise3D(array[itemOffset + BUILTIN_OFFSET_POSITION_X] * scale, array[itemOffset + BUILTIN_OFFSET_POSITION_Y] * scale, array[itemOffset + BUILTIN_OFFSET_POSITION_Z] * scale);
+            // Constant over the life of a particle but different for each particle
+            const strengthT = array[itemOffset + BUILTIN_OFFSET_RANDOM_A];
+            const strength = MathUtils.lerp(this._private_strengthInternal.min, this._private_strengthInternal.max, strengthT);
+            array[itemOffset + BUILTIN_OFFSET_TORQUE] += noise * strength * deltaTime;
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXBehaviorTorqueNoise };

package/dist/behaviorModules/FXBehaviorVelocityDamping.d.ts

@@ -0,0 +1,20 @@
+import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import { FXBehaviorModule } from "./FXBehaviorModule";
+/**
+ * Reduces particle velocity over time.
+ *
+ * Applies exponential decay to velocity. Damping of 0 means no effect, 1 means instant stop.
+ */
+export declare class FXBehaviorVelocityDamping extends FXBehaviorModule<{
+    builtin: "Matrix4";
+}> {
+    private dampingInternal;
+    /**
+     * @param damping - Damping coefficient range (0-1). Accepts number, tuple, or range object
+     */
+    constructor(damping: FXRangeConfig);
+    /** Damping coefficient range (0-1) */
+    get damping(): FXRange;
+    /** Damping coefficient range (0-1) */
+    set damping(value: FXRangeConfig);
+}

package/dist/behaviorModules/FXBehaviorVelocityDamping.js

@@ -0,0 +1,49 @@
+import { MathUtils } from 'three';
+import { assertValidNonNegativeNumber } from '../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y } from '../miscellaneous/miscellaneous.js';
+import { FXBehaviorModule } from './FXBehaviorModule.js';
+
+/**
+ * Reduces particle velocity over time.
+ *
+ * Applies exponential decay to velocity. Damping of 0 means no effect, 1 means instant stop.
+ */
+class FXBehaviorVelocityDamping extends FXBehaviorModule {
+    /**
+     * @param damping - Damping coefficient range (0-1). Accepts number, tuple, or range object
+     */
+    constructor(damping) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_dampingInternal = resolveFXRangeConfig(damping);
+        assertValidNonNegativeNumber(this._private_dampingInternal.min, `UIBehaviorVelocityDamping.constructor.damping.min`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.max, `UIBehaviorVelocityDamping.constructor.damping.max`);
+    }
+    /** Damping coefficient range (0-1) */
+    get damping() {
+        return this._private_dampingInternal;
+    }
+    /** Damping coefficient range (0-1) */
+    set damping(value) {
+        this._private_dampingInternal = resolveFXRangeConfig(value);
+        assertValidNonNegativeNumber(this._private_dampingInternal.min, `UIBehaviorVelocityDamping.damping.min`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.max, `UIBehaviorVelocityDamping.damping.max`);
+    }
+    /** @internal */
+    update(properties, instanceCount, deltaTime) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        for (let i = 0; i < instanceCount; i++) {
+            const itemOffset = i * itemSize;
+            // Constant over the life of a particle but different for each particle
+            const dampingT = array[itemOffset + BUILTIN_OFFSET_RANDOM_B];
+            const dampingFactor = Math.pow(1 - MathUtils.lerp(this._private_dampingInternal.min, this._private_dampingInternal.max, dampingT), deltaTime);
+            array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] *= dampingFactor;
+            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] *= dampingFactor;
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXBehaviorVelocityDamping };

package/dist/behaviorModules/FXBehaviorVelocityNoise.d.ts

@@ -0,0 +1,26 @@
+import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import { FXBehaviorModule } from "./FXBehaviorModule";
+/**
+ * Applies noise-based acceleration to particles.
+ *
+ * Uses 2D noise based on particle position. Higher scale means finer noise detail.
+ */
+export declare class FXBehaviorVelocityNoise extends FXBehaviorModule<{
+    builtin: "Matrix4";
+}> {
+    private scaleInternal;
+    private strengthInternal;
+    /**
+     * @param scale - Noise frequency range. Accepts number, tuple, or range object
+     * @param strength - Force multiplier range. Accepts number, tuple, or range object
+     */
+    constructor(scale?: number, strength?: number);
+    /** Noise frequency range */
+    get scale(): FXRange;
+    /** Force multiplier range */
+    get strength(): FXRange;
+    /** Noise frequency range */
+    set scale(value: FXRangeConfig);
+    /** Force multiplier range */
+    set strength(value: FXRangeConfig);
+}