sparcoon 0.0.1

package/dist/color/FXColor.js

@@ -0,0 +1,636 @@
+import { MathUtils, Color, Vector4 } from 'three';
+import { assertValidNumber } from '../miscellaneous/asserts.js';
+import { srgbToLinear, linearToSRGB } from '../miscellaneous/math.js';
+import { COLORS } from './FXColor.Internal.js';
+
+/** RGBA color with RGB, HSL, hex, and named color support */
+class FXColor {
+    constructor(...args) {
+        this._private_rInternal = 1;
+        this._private_gInternal = 1;
+        this._private_bInternal = 1;
+        this._private_aInternal = 1;
+        this._private_hInternal = 0;
+        this._private_sInternal = 0;
+        this._private_lInternal = 1;
+        this._private_dirtyInternal = false;
+        this._private_rgbDirty = false;
+        this._private_hslDirty = false;
+        if (args.length > 0) {
+            this.set(...args);
+        }
+    }
+    /** Black (0x000000) */
+    static get black() {
+        return new FXColor("black");
+    }
+    /** White (0xffffff) */
+    static get white() {
+        return new FXColor("white");
+    }
+    /** Red (0xff0000) */
+    static get red() {
+        return new FXColor("red");
+    }
+    /** Green (0x008000) */
+    static get green() {
+        return new FXColor("green");
+    }
+    /** Blue (0x0000ff) */
+    static get blue() {
+        return new FXColor("blue");
+    }
+    /** Yellow (0xffff00) */
+    static get yellow() {
+        return new FXColor("yellow");
+    }
+    /** Cyan (0x00ffff) */
+    static get cyan() {
+        return new FXColor("cyan");
+    }
+    /** Magenta (0xff00ff) */
+    static get magenta() {
+        return new FXColor("magenta");
+    }
+    /** Gray (0x808080) */
+    static get gray() {
+        return new FXColor("gray");
+    }
+    /** Grey (0x808080) */
+    static get grey() {
+        return new FXColor("grey");
+    }
+    /** Silver (0xc0c0c0) */
+    static get silver() {
+        return new FXColor("silver");
+    }
+    /** Maroon (0x800000) */
+    static get maroon() {
+        return new FXColor("maroon");
+    }
+    /** Olive (0x808000) */
+    static get olive() {
+        return new FXColor("olive");
+    }
+    /** Lime (0x00ff00) */
+    static get lime() {
+        return new FXColor("lime");
+    }
+    /** Aqua (0x00ffff) */
+    static get aqua() {
+        return new FXColor("aqua");
+    }
+    /** Teal (0x008080) */
+    static get teal() {
+        return new FXColor("teal");
+    }
+    /** Navy (0x000080) */
+    static get navy() {
+        return new FXColor("navy");
+    }
+    /** Fuchsia (0xff00ff) */
+    static get fuchsia() {
+        return new FXColor("fuchsia");
+    }
+    /** Purple (0x800080) */
+    static get purple() {
+        return new FXColor("purple");
+    }
+    /** Orange (0xffa500) */
+    static get orange() {
+        return new FXColor("orange");
+    }
+    /** Pink (0xffc0cb) */
+    static get pink() {
+        return new FXColor("pink");
+    }
+    /** Brown (0xa52a2a) */
+    static get brown() {
+        return new FXColor("brown");
+    }
+    /** Gold (0xffd700) */
+    static get gold() {
+        return new FXColor("gold");
+    }
+    /** Violet (0xee82ee) */
+    static get violet() {
+        return new FXColor("violet");
+    }
+    /** Indigo (0x4b0082) */
+    static get indigo() {
+        return new FXColor("indigo");
+    }
+    /** Coral (0xff7f50) */
+    static get coral() {
+        return new FXColor("coral");
+    }
+    /** Salmon (0xfa8072) */
+    static get salmon() {
+        return new FXColor("salmon");
+    }
+    /** Khaki (0xf0e68c) */
+    static get khaki() {
+        return new FXColor("khaki");
+    }
+    /** Plum (0xdda0dd) */
+    static get plum() {
+        return new FXColor("plum");
+    }
+    /** Orchid (0xda70d6) */
+    static get orchid() {
+        return new FXColor("orchid");
+    }
+    /** Tan (0xd2b48c) */
+    static get tan() {
+        return new FXColor("tan");
+    }
+    /** Beige (0xf5f5dc) */
+    static get beige() {
+        return new FXColor("beige");
+    }
+    /** Mint (0x98fb98) */
+    static get mint() {
+        return new FXColor("mint");
+    }
+    /** Lavender (0xe6e6fa) */
+    static get lavender() {
+        return new FXColor("lavender");
+    }
+    /** Crimson (0xdc143c) */
+    static get crimson() {
+        return new FXColor("crimson");
+    }
+    /** Azure (0xf0ffff) */
+    static get azure() {
+        return new FXColor("azure");
+    }
+    /** Ivory (0xfffff0) */
+    static get ivory() {
+        return new FXColor("ivory");
+    }
+    /** Snow (0xfffafa) */
+    static get snow() {
+        return new FXColor("snow");
+    }
+    /** Red component (0 to 1) */
+    get r() {
+        this._private_ensureRGBUpdatedFromHSL();
+        return this._private_rInternal;
+    }
+    /** Green component (0 to 1) */
+    get g() {
+        this._private_ensureRGBUpdatedFromHSL();
+        return this._private_gInternal;
+    }
+    /** Blue component (0 to 1) */
+    get b() {
+        this._private_ensureRGBUpdatedFromHSL();
+        return this._private_bInternal;
+    }
+    /** Alpha component (0 to 1) */
+    get a() {
+        return this._private_aInternal;
+    }
+    /** Hue component (0 to 360) */
+    get hue() {
+        this._private_ensureHSLUpdatedFromRGB();
+        return this._private_hInternal;
+    }
+    /** Saturation component (0 to 1) */
+    get saturation() {
+        this._private_ensureHSLUpdatedFromRGB();
+        return this._private_sInternal;
+    }
+    /** Lightness component (0 to 1) */
+    get lightness() {
+        this._private_ensureHSLUpdatedFromRGB();
+        return this._private_lInternal;
+    }
+    /** @internal */
+    get dirty() {
+        return this._private_dirtyInternal;
+    }
+    /** Red component (0 to 1) */
+    set r(value) {
+        assertValidNumber(value, "UIColor.r");
+        value = MathUtils.clamp(value, 0, 1);
+        this._private_ensureRGBUpdatedFromHSL();
+        if (value !== this._private_rInternal) {
+            this._private_rInternal = value;
+            this._private_hslDirty = true;
+            this._private_dirtyInternal = true;
+        }
+    }
+    /** Green component (0 to 1) */
+    set g(value) {
+        assertValidNumber(value, "UIColor.g");
+        value = MathUtils.clamp(value, 0, 1);
+        this._private_ensureRGBUpdatedFromHSL();
+        if (value !== this._private_gInternal) {
+            this._private_gInternal = value;
+            this._private_hslDirty = true;
+            this._private_dirtyInternal = true;
+        }
+    }
+    /** Blue component (0 to 1) */
+    set b(value) {
+        assertValidNumber(value, "UIColor.b");
+        value = MathUtils.clamp(value, 0, 1);
+        this._private_ensureRGBUpdatedFromHSL();
+        if (value !== this._private_bInternal) {
+            this._private_bInternal = value;
+            this._private_hslDirty = true;
+            this._private_dirtyInternal = true;
+        }
+    }
+    /** Alpha component (0 to 1) */
+    set a(value) {
+        assertValidNumber(value, "UIColor.a");
+        value = MathUtils.clamp(value, 0, 1);
+        if (value !== this._private_aInternal) {
+            this._private_aInternal = value;
+            this._private_dirtyInternal = true;
+        }
+    }
+    /** Hue component (0 to 360) */
+    set hue(value) {
+        assertValidNumber(value, "UIColor.hue");
+        value = MathUtils.clamp(value, 0, 360);
+        this._private_ensureHSLUpdatedFromRGB();
+        if (value !== this._private_hInternal) {
+            this._private_hInternal = value;
+            this._private_rgbDirty = true;
+            this._private_dirtyInternal = true;
+        }
+    }
+    /** Saturation component (0 to 1) */
+    set saturation(value) {
+        assertValidNumber(value, "UIColor.saturation");
+        value = MathUtils.clamp(value, 0, 1);
+        this._private_ensureHSLUpdatedFromRGB();
+        if (value !== this._private_sInternal) {
+            this._private_sInternal = value;
+            this._private_rgbDirty = true;
+            this._private_dirtyInternal = true;
+        }
+    }
+    /** Lightness component (0 to 1) */
+    set lightness(value) {
+        assertValidNumber(value, "UIColor.lightness");
+        value = MathUtils.clamp(value, 0, 1);
+        this._private_ensureHSLUpdatedFromRGB();
+        if (value !== this._private_lInternal) {
+            this._private_lInternal = value;
+            this._private_rgbDirty = true;
+            this._private_dirtyInternal = true;
+        }
+    }
+    /** @internal */
+    setDirtyFalse() {
+        this._private_dirtyInternal = false;
+    }
+    set(...args) {
+        if (args.length === 0 || args[0] === undefined) {
+            return this.setRGBA(1, 1, 1, 1);
+        }
+        if (args.length >= 3 && typeof args[0] === "number") {
+            const [r, g, b, a = 1] = args;
+            return this.setRGBA(r, g, b, a);
+        }
+        const [firstArgument, a = 1] = args;
+        if (typeof firstArgument === "string") {
+            return firstArgument.startsWith("#")
+                ? this.setHexString(firstArgument)
+                : this.setColorName(firstArgument, a);
+        }
+        if (firstArgument instanceof FXColor) {
+            return this.copy(firstArgument);
+        }
+        if (firstArgument instanceof Color) {
+            return this.setThreeColor(firstArgument, a);
+        }
+        if (typeof firstArgument === "number") {
+            return this.setHexRGB(firstArgument, a);
+        }
+        throw new Error("UIColor.set: cannot create color from provided arguments");
+    }
+    /** Sets RGBA components directly */
+    setRGBA(r, g, b, a = this._private_aInternal) {
+        assertValidNumber(r, "UIColor.setRGBA.r");
+        assertValidNumber(g, "UIColor.setRGBA.g");
+        assertValidNumber(b, "UIColor.setRGBA.b");
+        assertValidNumber(a, "UIColor.setRGBA.a");
+        r = MathUtils.clamp(r, 0, 1);
+        g = MathUtils.clamp(g, 0, 1);
+        b = MathUtils.clamp(b, 0, 1);
+        a = MathUtils.clamp(a, 0, 1);
+        this._private_ensureRGBUpdatedFromHSL();
+        if (r !== this._private_rInternal ||
+            g !== this._private_gInternal ||
+            b !== this._private_bInternal ||
+            a !== this._private_aInternal) {
+            this._private_rInternal = r;
+            this._private_gInternal = g;
+            this._private_bInternal = b;
+            this._private_aInternal = a;
+            this._private_hslDirty = true;
+            this._private_dirtyInternal = true;
+        }
+        return this;
+    }
+    /** Returns RGBA as 32-bit hex (RRGGBBAA) */
+    getHexRGBA() {
+        this._private_ensureRGBUpdatedFromHSL();
+        return ((Math.round(this._private_rInternal * 255) << 24) |
+            (Math.round(this._private_gInternal * 255) << 16) |
+            (Math.round(this._private_bInternal * 255) << 8) |
+            Math.round(this._private_aInternal * 255));
+    }
+    /** Returns RGB as 24-bit hex (RRGGBB) */
+    getHexRGB() {
+        this._private_ensureRGBUpdatedFromHSL();
+        return ((Math.round(this._private_rInternal * 255) << 16) |
+            (Math.round(this._private_gInternal * 255) << 8) |
+            Math.round(this._private_bInternal * 255));
+    }
+    /** Returns RGB as hex string ("#ffffff") */
+    getHexStringRGB() {
+        const hex = this.getHexRGB();
+        return `#${hex.toString(16).padStart(6, "0")}`;
+    }
+    /** Returns RGBA as hex string ("#ffffffff") */
+    getHexStringRGBA() {
+        const hex = this.getHexRGBA();
+        return `#${hex.toString(16).padStart(8, "0")}`;
+    }
+    /** Sets from 32-bit hex RGBA (RRGGBBAA) */
+    setHexRGBA(hex) {
+        assertValidNumber(hex, "UIColor.setHexRGBA.hex");
+        this._private_ensureRGBUpdatedFromHSL();
+        const r = ((hex >> 16) & 0xff) / 255;
+        const g = ((hex >> 8) & 0xff) / 255;
+        const b = (hex & 0xff) / 255;
+        const a = ((hex >> 24) & 0xff) / 255;
+        if (r !== this._private_rInternal ||
+            g !== this._private_gInternal ||
+            b !== this._private_bInternal ||
+            a !== this._private_aInternal) {
+            this._private_rInternal = r;
+            this._private_gInternal = g;
+            this._private_bInternal = b;
+            this._private_aInternal = a;
+            this._private_hslDirty = true;
+            this._private_dirtyInternal = true;
+        }
+        return this;
+    }
+    /** Sets from 24-bit hex RGB (RRGGBB) */
+    setHexRGB(hex, a = this._private_aInternal) {
+        assertValidNumber(hex, "UIColor.setHexRGB.hex");
+        assertValidNumber(a, "UIColor.setHexRGB.a");
+        a = MathUtils.clamp(a, 0, 1);
+        this._private_ensureRGBUpdatedFromHSL();
+        const r = ((hex >> 16) & 0xff) / 255;
+        const g = ((hex >> 8) & 0xff) / 255;
+        const b = (hex & 0xff) / 255;
+        if (r !== this._private_rInternal ||
+            g !== this._private_gInternal ||
+            b !== this._private_bInternal ||
+            a !== this._private_aInternal) {
+            this._private_rInternal = r;
+            this._private_gInternal = g;
+            this._private_bInternal = b;
+            this._private_aInternal = a;
+            this._private_hslDirty = true;
+            this._private_dirtyInternal = true;
+        }
+        return this;
+    }
+    /**
+     * Sets from hex string.
+     *
+     * @param hexString - Format: "#ffffff" or "#ffffffff"
+     * @throws If format invalid
+     */
+    setHexString(hexString) {
+        if (!hexString.startsWith("#")) {
+            throw new Error(`UIColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
+        }
+        const hex = hexString.slice(1);
+        if (hex.length === 6) {
+            const hexNumber = parseInt(hex, 16);
+            if (isNaN(hexNumber)) {
+                throw new Error(`UIColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
+            }
+            return this.setHexRGB(hexNumber);
+        }
+        else if (hex.length === 8) {
+            const hexNumber = parseInt(hex, 16);
+            if (isNaN(hexNumber)) {
+                throw new Error(`UIColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
+            }
+            return this.setHexRGBA(hexNumber);
+        }
+        else {
+            throw new Error(`UIColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
+        }
+    }
+    /** Sets from HSL values */
+    setHSL(h, s, l, a = this._private_aInternal) {
+        assertValidNumber(h, "UIColor.setHSL.h");
+        assertValidNumber(s, "UIColor.setHSL.s");
+        assertValidNumber(l, "UIColor.setHSL.l");
+        assertValidNumber(a, "UIColor.setHSL.a");
+        h = MathUtils.clamp(h, 0, 360);
+        s = MathUtils.clamp(s, 0, 1);
+        l = MathUtils.clamp(l, 0, 1);
+        a = MathUtils.clamp(a, 0, 1);
+        this._private_ensureHSLUpdatedFromRGB();
+        if (h !== this._private_hInternal ||
+            s !== this._private_sInternal ||
+            l !== this._private_lInternal ||
+            a !== this._private_aInternal) {
+            this._private_hInternal = h;
+            this._private_sInternal = s;
+            this._private_lInternal = l;
+            this._private_aInternal = a;
+            this._private_rgbDirty = true;
+            this._private_dirtyInternal = true;
+        }
+        return this;
+    }
+    /**
+     * Sets from predefined name.
+     *
+     * @throws If color name unknown
+     */
+    setColorName(colorName, a = this._private_aInternal) {
+        assertValidNumber(a, "UIColor.setColorName.a");
+        a = MathUtils.clamp(a, 0, 1);
+        const normalizedName = colorName.toLowerCase().trim();
+        const hex = COLORS[normalizedName];
+        if (hex === undefined) {
+            throw new Error(`UIColor.setColorName.colorName: unknown color name`);
+        }
+        return this.setHexRGB(hex, a);
+    }
+    /** Sets from linear (GLSL) color space */
+    setGLSLColor(r, g, b, a = this._private_aInternal) {
+        assertValidNumber(r, "UIColor.setGLSLColor.r");
+        assertValidNumber(g, "UIColor.setGLSLColor.g");
+        assertValidNumber(b, "UIColor.setGLSLColor.b");
+        assertValidNumber(a, "UIColor.setGLSLColor.a");
+        a = MathUtils.clamp(a, 0, 1);
+        this._private_ensureRGBUpdatedFromHSL();
+        const sRGBR = linearToSRGB(r);
+        const sRGBG = linearToSRGB(g);
+        const sRGBB = linearToSRGB(b);
+        if (sRGBR !== this._private_rInternal ||
+            sRGBG !== this._private_gInternal ||
+            sRGBB !== this._private_bInternal ||
+            a !== this._private_aInternal) {
+            this._private_rInternal = sRGBR;
+            this._private_gInternal = sRGBG;
+            this._private_bInternal = sRGBB;
+            this._private_aInternal = a;
+            this._private_hslDirty = true;
+            this._private_dirtyInternal = true;
+        }
+        return this;
+    }
+    /** Sets from Three.js Color */
+    setThreeColor(threeColor, a = this._private_aInternal) {
+        assertValidNumber(a, "UIColor.setThreeColor.a");
+        a = MathUtils.clamp(a, 0, 1);
+        this._private_ensureRGBUpdatedFromHSL();
+        if (threeColor.r !== this._private_rInternal ||
+            threeColor.g !== this._private_gInternal ||
+            threeColor.b !== this._private_bInternal ||
+            a !== this._private_aInternal) {
+            this._private_rInternal = threeColor.r;
+            this._private_gInternal = threeColor.g;
+            this._private_bInternal = threeColor.b;
+            this._private_aInternal = a;
+            this._private_hslDirty = true;
+            this._private_dirtyInternal = true;
+        }
+        return this;
+    }
+    /** Returns CSS color string ("rgba(255, 0, 0, 1)") */
+    toCSSColor() {
+        this._private_ensureRGBUpdatedFromHSL();
+        const r = Math.round(this._private_rInternal * 255);
+        const g = Math.round(this._private_gInternal * 255);
+        const b = Math.round(this._private_bInternal * 255);
+        return `rgba(${r}, ${g}, ${b}, ${this._private_aInternal})`;
+    }
+    /** Converts to linear (GLSL) color space */
+    toGLSLColor(result = new Vector4()) {
+        this._private_ensureRGBUpdatedFromHSL();
+        result.x = srgbToLinear(this._private_rInternal);
+        result.y = srgbToLinear(this._private_gInternal);
+        result.z = srgbToLinear(this._private_bInternal);
+        result.w = this._private_aInternal;
+        return result;
+    }
+    /** Converts to Three.js Color (without alpha) */
+    toThreeColor(result = new Color()) {
+        this._private_ensureRGBUpdatedFromHSL();
+        result.r = this._private_rInternal;
+        result.g = this._private_gInternal;
+        result.b = this._private_bInternal;
+        return result;
+    }
+    /** Copies from another color */
+    copy(color) {
+        if (color instanceof FXColor) {
+            this._private_ensureRGBUpdatedFromHSL();
+            color._private_ensureRGBUpdatedFromHSL();
+            if (this._private_rInternal !== color._private_rInternal ||
+                this._private_gInternal !== color._private_gInternal ||
+                this._private_bInternal !== color._private_bInternal ||
+                this._private_aInternal !== color._private_aInternal) {
+                this._private_rInternal = color._private_rInternal;
+                this._private_gInternal = color._private_gInternal;
+                this._private_bInternal = color._private_bInternal;
+                this._private_aInternal = color._private_aInternal;
+                this._private_hslDirty = true;
+                this._private_dirtyInternal = true;
+            }
+        }
+        else {
+            this._private_ensureRGBUpdatedFromHSL();
+            if (this._private_rInternal !== color.r ||
+                this._private_gInternal !== color.g ||
+                this._private_bInternal !== color.b ||
+                this._private_aInternal !== 1) {
+                this._private_rInternal = color.r;
+                this._private_gInternal = color.g;
+                this._private_bInternal = color.b;
+                this._private_aInternal = 1;
+                this._private_hslDirty = true;
+                this._private_dirtyInternal = true;
+            }
+        }
+        return this;
+    }
+    /** Returns copy of this color */
+    clone() {
+        this._private_ensureRGBUpdatedFromHSL();
+        return new FXColor(this._private_rInternal, this._private_gInternal, this._private_bInternal, this._private_aInternal);
+    }
+    /** @internal */
+    _private_ensureRGBUpdatedFromHSL() {
+        if (this._private_rgbDirty) {
+            const { _private_hInternal: h, _private_sInternal: s, _private_lInternal: l } = this;
+            const c = (1 - Math.abs(2 * l - 1)) * s;
+            const hp = h / 60;
+            const x = c * (1 - Math.abs((hp % 2) - 1));
+            let [r, g, b] = hp < 1
+                ? [c, x, 0]
+                : hp < 2
+                    ? [x, c, 0]
+                    : hp < 3
+                        ? [0, c, x]
+                        : hp < 4
+                            ? [0, x, c]
+                            : hp < 5
+                                ? [x, 0, c]
+                                : [c, 0, x];
+            const m = l - c / 2;
+            this._private_rInternal = r + m;
+            this._private_gInternal = g + m;
+            this._private_bInternal = b + m;
+            this._private_rgbDirty = false;
+        }
+    }
+    _private_ensureHSLUpdatedFromRGB() {
+        if (this._private_hslDirty) {
+            const { _private_rInternal: r, _private_gInternal: g, _private_bInternal: b } = this;
+            const max = Math.max(r, g, b);
+            const min = Math.min(r, g, b);
+            const d = max - min;
+            const l = (max + min) / 2;
+            let h = 0;
+            if (d !== 0) {
+                if (max === r) {
+                    h = (g - b) / d + (g < b ? 6 : 0);
+                }
+                else if (max === g) {
+                    h = (b - r) / d + 2;
+                }
+                else {
+                    h = (r - g) / d + 4;
+                }
+                h *= 60;
+            }
+            const s = d === 0 ? 0 : d / (1 - Math.abs(2 * l - 1));
+            this._private_hInternal = h;
+            this._private_sInternal = s;
+            this._private_lInternal = l;
+            this._private_hslDirty = false;
+        }
+    }
+}
+
+export { FXColor };

package/dist/elements/FXEmitter.Internal.d.ts

@@ -0,0 +1,10 @@
+export interface FXEmitterOptions {
+    expectedCapacity: number;
+    capacityStep: number;
+}
+export interface FXEmitterPlayOptions {
+    duration: number;
+}
+export declare const EMITTER_DEFAULT_EXPECTED_CAPACITY = 32;
+export declare const EMITTER_DEFAULT_CAPACITY_STEP = 32;
+export declare const EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES = true;

package/dist/elements/FXEmitter.Internal.js

@@ -0,0 +1,5 @@
+const EMITTER_DEFAULT_EXPECTED_CAPACITY = 32;
+const EMITTER_DEFAULT_CAPACITY_STEP = 32;
+const EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES = true;
+
+export { EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES, EMITTER_DEFAULT_CAPACITY_STEP, EMITTER_DEFAULT_EXPECTED_CAPACITY };

package/dist/elements/FXEmitter.d.ts

@@ -0,0 +1,29 @@
+import { Object3D } from "three";
+import type { FXBehaviorModule } from "../behaviorModules/FXBehaviorModule";
+import type { FXRenderingModule } from "../renderingModules/FXRenderingModule";
+import type { FXSpawnModule } from "../spawnModules/FXSpawnModule";
+import type { FXEmitterPlayOptions } from "./FXEmitter.Internal";
+export interface FXEmitterOptions {
+    expectedCapacity: number;
+    capacityStep: number;
+    automaticallyDestroyModules: boolean;
+}
+export declare class FXEmitter extends Object3D {
+    private readonly spawnSequence;
+    private readonly behaviorSequence;
+    private readonly renderingSequence;
+    automaticallyDestroyModules: boolean;
+    private readonly mesh;
+    private emissionRate;
+    private emissionAccumulator;
+    private emissionDuration;
+    private emissionElapsed;
+    constructor(spawnSequence: FXSpawnModule[], behaviorSequence: readonly FXBehaviorModule[], renderingSequence: readonly FXRenderingModule[], options?: Partial<FXEmitterOptions>);
+    static onWillRender: (deltaTime: number) => void;
+    destroy(): void;
+    burst(count: number): void;
+    reset(): void;
+    play(rate: number, options?: Partial<FXEmitterPlayOptions>): void;
+    stop(): void;
+    private readonly onRendering;
+}