sparcoon 0.0.1

package/dist/behaviorModules/FXBehaviorVelocityNoise.js

@@ -0,0 +1,73 @@
+import { MathUtils } from 'three';
+import { assertValidPositiveNumber, assertValidNonNegativeNumber } from '../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z, generateNoise3D } from '../miscellaneous/miscellaneous.js';
+import { FXBehaviorModule } from './FXBehaviorModule.js';
+
+/**
+ * Applies noise-based acceleration to particles.
+ *
+ * Uses 2D noise based on particle position. Higher scale means finer noise detail.
+ */
+class FXBehaviorVelocityNoise 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 = 100, strength = 500) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_scaleInternal = resolveFXRangeConfig(scale);
+        assertValidPositiveNumber(this._private_scaleInternal.min, `UIBehaviorVelocityNoise.constructor.scale.min`);
+        assertValidPositiveNumber(this._private_scaleInternal.max, `UIBehaviorVelocityNoise.constructor.scale.max`);
+        this._private_strengthInternal = resolveFXRangeConfig(strength);
+        assertValidNonNegativeNumber(this._private_strengthInternal.min, `UIBehaviorVelocityNoise.constructor.strength.min`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.max, `UIBehaviorVelocityNoise.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, `UIBehaviorVelocityNoise.scale.min`);
+        assertValidPositiveNumber(this._private_scaleInternal.max, `UIBehaviorVelocityNoise.scale.max`);
+    }
+    /** Force multiplier range */
+    set strength(value) {
+        this._private_strengthInternal = resolveFXRangeConfig(value);
+        assertValidNonNegativeNumber(this._private_strengthInternal.min, `UIBehaviorVelocityNoise.strength.min`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.max, `UIBehaviorVelocityNoise.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;
+            const x = array[itemOffset + BUILTIN_OFFSET_POSITION_X];
+            const y = array[itemOffset + BUILTIN_OFFSET_POSITION_Y];
+            const z = array[itemOffset + BUILTIN_OFFSET_POSITION_Z];
+            // 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 noiseX = generateNoise3D(x * scale, y * scale, z * scale);
+            const noiseY = generateNoise3D((x + 100) * scale, (y + 100) * scale, (z + 100) * scale);
+            const noiseZ = generateNoise3D((x - 200) * scale, (y - 200) * scale, (z - 200) * 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_VELOCITY_X] += noiseX * strength * deltaTime;
+            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] += noiseY * strength * deltaTime;
+            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Z] += noiseZ * strength * deltaTime;
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXBehaviorVelocityNoise };

package/dist/color/FXColor.Internal.d.ts

@@ -0,0 +1,7 @@
+import type { Color } from "three";
+import type { FXColor } from "./FXColor";
+/** Color configuration as Three.js Color, hex number, hex string, or FXColor */
+export type FXColorConfig = Color | number | string | FXColor;
+/** Predefined color names */
+export type FXColorName = "black" | "white" | "red" | "green" | "blue" | "yellow" | "cyan" | "magenta" | "gray" | "grey" | "silver" | "maroon" | "olive" | "lime" | "aqua" | "teal" | "navy" | "fuchsia" | "purple" | "orange" | "pink" | "brown" | "gold" | "violet" | "indigo" | "coral" | "salmon" | "khaki" | "plum" | "orchid" | "tan" | "beige" | "mint" | "lavender" | "crimson" | "azure" | "ivory" | "snow";
+export declare const COLORS: Record<string, number | undefined>;

package/dist/color/FXColor.Internal.js

@@ -0,0 +1,42 @@
+const COLORS = {
+    black: 0x000000,
+    white: 0xffffff,
+    red: 0xff0000,
+    green: 0x008000,
+    blue: 0x0000ff,
+    yellow: 0xffff00,
+    cyan: 0x00ffff,
+    magenta: 0xff00ff,
+    gray: 0x808080,
+    grey: 0x808080,
+    silver: 0xc0c0c0,
+    maroon: 0x800000,
+    olive: 0x808000,
+    lime: 0x00ff00,
+    aqua: 0x00ffff,
+    teal: 0x008080,
+    navy: 0x000080,
+    fuchsia: 0xff00ff,
+    purple: 0x800080,
+    orange: 0xffa500,
+    pink: 0xffc0cb,
+    brown: 0xa52a2a,
+    gold: 0xffd700,
+    violet: 0xee82ee,
+    indigo: 0x4b0082,
+    coral: 0xff7f50,
+    salmon: 0xfa8072,
+    khaki: 0xf0e68c,
+    plum: 0xdda0dd,
+    orchid: 0xda70d6,
+    tan: 0xd2b48c,
+    beige: 0xf5f5dc,
+    mint: 0x98fb98,
+    lavender: 0xe6e6fa,
+    crimson: 0xdc143c,
+    azure: 0xf0ffff,
+    ivory: 0xfffff0,
+    snow: 0xfffafa,
+};
+
+export { COLORS };

package/dist/color/FXColor.d.ts

@@ -0,0 +1,234 @@
+import { Color, Vector4 } from "three";
+import type { FXColorConfig, FXColorName } from "./FXColor.Internal";
+/** RGBA color with RGB, HSL, hex, and named color support */
+export declare class FXColor {
+    private rInternal;
+    private gInternal;
+    private bInternal;
+    private aInternal;
+    private hInternal;
+    private sInternal;
+    private lInternal;
+    private dirtyInternal;
+    private rgbDirty;
+    private hslDirty;
+    constructor();
+    /**
+     * @param r - Red (0-1)
+     * @param g - Green (0-1)
+     * @param b - Blue (0-1)
+     * @param a - Alpha (0-1)
+     */
+    constructor(r: number, g: number, b: number, a?: number);
+    /**
+     * @param colorName - Named color
+     * @param a - Alpha (0-1)
+     */
+    constructor(colorName: FXColorName, a?: number);
+    /**
+     * @param threeColor - Three.js Color object
+     * @param a - Alpha (0-1)
+     */
+    constructor(threeColor: Color, a?: number);
+    /**
+     * @param hexRGB - Hex RGB value (e.g., 0xff0000)
+     * @param a - Alpha (0-1)
+     */
+    constructor(hexRGB: number, a?: number);
+    /**
+     * @param hexString - Hex string (e.g., "#ffffff" or "#ffffffff")
+     */
+    constructor(hexString?: string);
+    /**
+     * @param uiColor - FXColor object to copy from
+     */
+    constructor(uiColor?: FXColor);
+    /**
+     * @param uiColorConfig - FXColorConfig object
+     */
+    constructor(uiColorConfig?: FXColorConfig);
+    /** Black (0x000000) */
+    static get black(): FXColor;
+    /** White (0xffffff) */
+    static get white(): FXColor;
+    /** Red (0xff0000) */
+    static get red(): FXColor;
+    /** Green (0x008000) */
+    static get green(): FXColor;
+    /** Blue (0x0000ff) */
+    static get blue(): FXColor;
+    /** Yellow (0xffff00) */
+    static get yellow(): FXColor;
+    /** Cyan (0x00ffff) */
+    static get cyan(): FXColor;
+    /** Magenta (0xff00ff) */
+    static get magenta(): FXColor;
+    /** Gray (0x808080) */
+    static get gray(): FXColor;
+    /** Grey (0x808080) */
+    static get grey(): FXColor;
+    /** Silver (0xc0c0c0) */
+    static get silver(): FXColor;
+    /** Maroon (0x800000) */
+    static get maroon(): FXColor;
+    /** Olive (0x808000) */
+    static get olive(): FXColor;
+    /** Lime (0x00ff00) */
+    static get lime(): FXColor;
+    /** Aqua (0x00ffff) */
+    static get aqua(): FXColor;
+    /** Teal (0x008080) */
+    static get teal(): FXColor;
+    /** Navy (0x000080) */
+    static get navy(): FXColor;
+    /** Fuchsia (0xff00ff) */
+    static get fuchsia(): FXColor;
+    /** Purple (0x800080) */
+    static get purple(): FXColor;
+    /** Orange (0xffa500) */
+    static get orange(): FXColor;
+    /** Pink (0xffc0cb) */
+    static get pink(): FXColor;
+    /** Brown (0xa52a2a) */
+    static get brown(): FXColor;
+    /** Gold (0xffd700) */
+    static get gold(): FXColor;
+    /** Violet (0xee82ee) */
+    static get violet(): FXColor;
+    /** Indigo (0x4b0082) */
+    static get indigo(): FXColor;
+    /** Coral (0xff7f50) */
+    static get coral(): FXColor;
+    /** Salmon (0xfa8072) */
+    static get salmon(): FXColor;
+    /** Khaki (0xf0e68c) */
+    static get khaki(): FXColor;
+    /** Plum (0xdda0dd) */
+    static get plum(): FXColor;
+    /** Orchid (0xda70d6) */
+    static get orchid(): FXColor;
+    /** Tan (0xd2b48c) */
+    static get tan(): FXColor;
+    /** Beige (0xf5f5dc) */
+    static get beige(): FXColor;
+    /** Mint (0x98fb98) */
+    static get mint(): FXColor;
+    /** Lavender (0xe6e6fa) */
+    static get lavender(): FXColor;
+    /** Crimson (0xdc143c) */
+    static get crimson(): FXColor;
+    /** Azure (0xf0ffff) */
+    static get azure(): FXColor;
+    /** Ivory (0xfffff0) */
+    static get ivory(): FXColor;
+    /** Snow (0xfffafa) */
+    static get snow(): FXColor;
+    /** Red component (0 to 1) */
+    get r(): number;
+    /** Green component (0 to 1) */
+    get g(): number;
+    /** Blue component (0 to 1) */
+    get b(): number;
+    /** Alpha component (0 to 1) */
+    get a(): number;
+    /** Hue component (0 to 360) */
+    get hue(): number;
+    /** Saturation component (0 to 1) */
+    get saturation(): number;
+    /** Lightness component (0 to 1) */
+    get lightness(): number;
+    /** Red component (0 to 1) */
+    set r(value: number);
+    /** Green component (0 to 1) */
+    set g(value: number);
+    /** Blue component (0 to 1) */
+    set b(value: number);
+    /** Alpha component (0 to 1) */
+    set a(value: number);
+    /** Hue component (0 to 360) */
+    set hue(value: number);
+    /** Saturation component (0 to 1) */
+    set saturation(value: number);
+    /** Lightness component (0 to 1) */
+    set lightness(value: number);
+    /** Sets to white (default) */
+    set(): this;
+    /**
+     * @param r - Red (0-1)
+     * @param g - Green (0-1)
+     * @param b - Blue (0-1)
+     * @param a - Alpha (0-1)
+     */
+    set(r: number, g: number, b: number, a?: number): this;
+    /**
+     * @param colorName - Named color
+     * @param a - Alpha (0-1)
+     */
+    set(colorName: FXColorName, a?: number): this;
+    /**
+     * @param threeColor - Three.js Color object
+     * @param a - Alpha (0-1)
+     */
+    set(threeColor: Color, a?: number): this;
+    /**
+     * @param hexRGB - Hex RGB value (e.g., 0xff0000)
+     * @param a - Alpha (0-1)
+     */
+    set(hexRGB: number, a?: number): this;
+    /**
+     * @param hexString - Hex string (e.g., "#ffffff" or "#ffffffff")
+     */
+    set(hexString: string): this;
+    /**
+     * @param uiColor - FXColor object to copy from
+     */
+    set(uiColor: FXColor): this;
+    /**
+     * @param uiColorConfig - FXColorConfig object
+     */
+    set(uiColorConfig?: FXColorConfig): this;
+    /** Sets RGBA components directly */
+    setRGBA(r: number, g: number, b: number, a?: number): this;
+    /** Returns RGBA as 32-bit hex (RRGGBBAA) */
+    getHexRGBA(): number;
+    /** Returns RGB as 24-bit hex (RRGGBB) */
+    getHexRGB(): number;
+    /** Returns RGB as hex string ("#ffffff") */
+    getHexStringRGB(): string;
+    /** Returns RGBA as hex string ("#ffffffff") */
+    getHexStringRGBA(): string;
+    /** Sets from 32-bit hex RGBA (RRGGBBAA) */
+    setHexRGBA(hex: number): this;
+    /** Sets from 24-bit hex RGB (RRGGBB) */
+    setHexRGB(hex: number, a?: number): this;
+    /**
+     * Sets from hex string.
+     *
+     * @param hexString - Format: "#ffffff" or "#ffffffff"
+     * @throws If format invalid
+     */
+    setHexString(hexString: string): this;
+    /** Sets from HSL values */
+    setHSL(h: number, s: number, l: number, a?: number): this;
+    /**
+     * Sets from predefined name.
+     *
+     * @throws If color name unknown
+     */
+    setColorName(colorName: FXColorName, a?: number): this;
+    /** Sets from linear (GLSL) color space */
+    setGLSLColor(r: number, g: number, b: number, a?: number): this;
+    /** Sets from Three.js Color */
+    setThreeColor(threeColor: Color, a?: number): this;
+    /** Returns CSS color string ("rgba(255, 0, 0, 1)") */
+    toCSSColor(): string;
+    /** Converts to linear (GLSL) color space */
+    toGLSLColor(result?: Vector4): Vector4;
+    /** Converts to Three.js Color (without alpha) */
+    toThreeColor(result?: Color): Color;
+    /** Copies from another color */
+    copy(color: FXColor | Color): this;
+    /** Returns copy of this color */
+    clone(): FXColor;
+    private ensureHSLUpdatedFromRGB;
+}