babylon.quarks 0.17.4 → 0.17.6

package/dist/types/index.d.ts

@@ -1,19 +1,2829 @@
-export { BatchedRenderer } from './BatchedRenderer';
-export type { VFXBatchSettings } from './BatchedRenderer';
-export { BatchedParticleRenderer } from './BatchedParticleRenderer';
-export { VFXBatch, RenderMode } from './VFXBatch';
-export type { StoredBatchSettings } from './VFXBatch';
-export { SpriteBatch } from './SpriteBatch';
-export { TrailBatch } from './TrailBatch';
-export { ParticleSystem } from './ParticleSystem';
-export type { ParticleSystemParameters, BurstParameters } from './ParticleSystem';
-export { ParticleEmitter } from './ParticleEmitter';
-export { QuarksUtil } from './QuarksUtil';
-export { QuarksLoader } from './QuarksLoader';
-export type { QuarksLoaderOptions } from './QuarksLoader';
-export { QuarksPrefab } from './QuarksPrefab';
-export { MeshSurfaceEmitter, MeshSurfaceEmitterPlugin } from './MeshSurfaceEmitter';
-export * from './shaders/';
-export * from './materials/';
-export * from 'quarks.core';
-export type { IParticleSystem, IParticle, Particle, EmissionState, RendererEmitterSettings, TrailSettings, StretchedBillBoardSettings, BillBoardSettings, MeshSettings, IEmitter, ParticleSystemEvent, ParticleSystemEventType, SerializationOptions, Behavior, EmitterShape, ValueGenerator, FunctionValueGenerator, ColorGenerator, FunctionColorGenerator, RotationGenerator, Vector3Generator, } from 'quarks.core';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { Scene } from '@babylonjs/core/scene';
+import { Texture } from '@babylonjs/core/Materials/Textures/texture';
+import { BaseTexture } from '@babylonjs/core/Materials/Textures/baseTexture';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { Node } from '@babylonjs/core/node';
+import { PBRMaterial } from '@babylonjs/core/Materials/PBR/pbrMaterial';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+
+declare const WebGLCoordinateSystem = 2000;
+declare const WebGPUCoordinateSystem = 2001;
+declare class Matrix4 {
+    elements: number[];
+    readonly isMatrix4 = true;
+    constructor(n11?: number, n12?: number, n13?: number, n14?: number, n21?: number, n22?: number, n23?: number, n24?: number, n31?: number, n32?: number, n33?: number, n34?: number, n41?: number, n42?: number, n43?: number, n44?: number);
+    /**
+     * @deprecated Use {@link Matrix4#copyPosition .copyPosition()} instead.
+     */
+    extractPosition(m: Matrix4): Matrix4;
+    /**
+     * Sets this matrix to a x b and stores the result into the flat array r.
+     * r can be either a regular Array or a TypedArray.
+     *
+     * @deprecated This method has been removed completely.
+     */
+    multiplyToArray(a: Matrix4, b: Matrix4, r: number[]): Matrix4;
+    /**
+     * @deprecated Use {@link Matrix4#makeRotationFromQuaternion .makeRotationFromQuaternion()} instead.
+     */
+    setRotationFromQuaternion(q: Quaternion): Matrix4;
+    set(n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number): this;
+    identity(): this;
+    clone(): Matrix4;
+    copy(m: Matrix4): this;
+    copyPosition(m: Matrix4): this;
+    setFromMatrix3(m: Matrix3): this;
+    extractBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): this;
+    makeBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): this;
+    extractRotation(m: Matrix4): this;
+    makeRotationFromEuler(euler: Euler): this;
+    makeRotationFromQuaternion(q: Quaternion): this;
+    lookAt(eye: Vector3, target: Vector3, up: Vector3): this;
+    multiply(m: Matrix4): this;
+    premultiply(m: Matrix4): this;
+    multiplyMatrices(a: Matrix4, b: Matrix4): this;
+    multiplyScalar(s: number): this;
+    determinant(): number;
+    transpose(): this;
+    setPosition(x: number | Vector3, y?: number, z?: number): this;
+    invert(): this;
+    scale(v: Vector3): this;
+    getMaxScaleOnAxis(): number;
+    makeTranslation(x: number | Vector3, y?: number, z?: number): this;
+    makeRotationX(theta: number): this;
+    makeRotationY(theta: number): this;
+    makeRotationZ(theta: number): this;
+    makeRotationAxis(axis: Vector3, angle: number): this;
+    makeScale(x: number, y: number, z: number): this;
+    makeShear(xy: number, xz: number, yx: number, yz: number, zx: number, zy: number): this;
+    compose(position: Vector3, quaternion: Quaternion, scale: Vector3): this;
+    decompose(position: Vector3, quaternion: Quaternion, scale: Vector3): this;
+    makePerspective(left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: number): this;
+    makeOrthographic(left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: number): this;
+    equals(matrix: Matrix4): boolean;
+    fromArray(array: number[], offset?: number): this;
+    toArray(array?: number[], offset?: number): number[];
+}
+
+declare class Vector2 {
+    x: number;
+    y: number;
+    static isVector2: boolean;
+    constructor(x?: number, y?: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    set(x: number, y: number): this;
+    setScalar(scalar: number): this;
+    setX(x: number): this;
+    setY(y: number): this;
+    setComponent(index: number, value: number): this;
+    getComponent(index: number): number;
+    clone(): Vector2;
+    copy(v: Vector2): this;
+    add(v: Vector2): this;
+    addScalar(s: number): this;
+    addVectors(a: Vector2, b: Vector2): this;
+    addScaledVector(v: Vector2, s: number): this;
+    sub(v: Vector2): this;
+    subScalar(s: number): this;
+    subVectors(a: Vector2, b: Vector2): this;
+    multiply(v: Vector2): this;
+    multiplyScalar(scalar: number): this;
+    divide(v: Vector2): this;
+    divideScalar(scalar: number): this;
+    applyMatrix3(m: Matrix3): this;
+    min(v: Vector2): this;
+    max(v: Vector2): this;
+    clamp(min: Vector2, max: Vector2): this;
+    clampScalar(minVal: number, maxVal: number): this;
+    clampLength(min: number, max: number): this;
+    floor(): this;
+    ceil(): this;
+    round(): this;
+    roundToZero(): this;
+    negate(): this;
+    dot(v: Vector2): number;
+    cross(v: Vector2): number;
+    lengthSq(): number;
+    length(): number;
+    manhattanLength(): number;
+    normalize(): this;
+    angle(): number;
+    angleTo(v: Vector2): number;
+    distanceTo(v: Vector2): number;
+    distanceToSquared(v: Vector2): number;
+    manhattanDistanceTo(v: Vector2): number;
+    setLength(length: number): this;
+    lerp(v: Vector2, alpha: number): this;
+    lerpVectors(v1: Vector2, v2: Vector2, alpha: number): this;
+    equals(v: Vector2): boolean;
+    fromArray(array: number[], offset?: number): this;
+    toArray(array?: number[], offset?: number): number[];
+    rotateAround(center: Vector2, angle: number): this;
+    random(): this;
+    [Symbol.iterator](): Generator<number, void, unknown>;
+}
+
+declare class Matrix3 {
+    elements: number[];
+    constructor(n11?: number, n12?: number, n13?: number, n21?: number, n22?: number, n23?: number, n31?: number, n32?: number, n33?: number);
+    set(n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number): this;
+    identity(): this;
+    copy(m: Matrix3): this;
+    extractBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): this;
+    setFromMatrix4(m: Matrix4): this;
+    multiply(m: Matrix3): this;
+    premultiply(m: Matrix3): this;
+    multiplyMatrices(a: Matrix3, b: Matrix3): this;
+    multiplyScalar(s: number): this;
+    determinant(): number;
+    invert(): this;
+    transpose(): this;
+    getNormalMatrix(matrix4: Matrix4): this;
+    transposeIntoArray(r: number[]): this;
+    setUvTransform(tx: number, ty: number, sx: number, sy: number, rotation: number, cx: number, cy: number): this;
+    scale(sx: number, sy: number): this;
+    rotate(theta: number): this;
+    translate(tx: number, ty: number): this;
+    makeTranslation(x: number | Vector2, y: number): this;
+    makeRotation(theta: number): this;
+    makeScale(x: number, y: number): this;
+    equals(matrix: Matrix3): boolean;
+    fromArray(array: number[], offset?: number): this;
+    toArray(array?: number[], offset?: number): number[];
+    clone(): Matrix3;
+}
+
+declare class Vector3 {
+    x: number;
+    y: number;
+    z: number;
+    readonly isVector3 = true;
+    constructor(x?: number, y?: number, z?: number);
+    set(x: number, y: number, z: number): this;
+    setScalar(scalar: number): this;
+    setX(x: number): this;
+    setY(y: number): this;
+    setZ(z: number): this;
+    setComponent(index: number, value: number): this;
+    getComponent(index: number): number;
+    clone(): Vector3;
+    copy(v: Vector3): this;
+    add(v: Vector3): this;
+    addScalar(s: number): this;
+    addVectors(a: Vector3, b: Vector3): this;
+    addScaledVector(v: Vector3, s: number): this;
+    sub(v: Vector3): this;
+    subScalar(s: number): this;
+    subVectors(a: Vector3, b: Vector3): this;
+    multiply(v: Vector3): this;
+    multiplyScalar(scalar: number): this;
+    multiplyVectors(a: Vector3, b: Vector3): this;
+    applyEuler(euler: Euler): this;
+    applyAxisAngle(axis: Vector3, angle: number): this;
+    applyMatrix3(m: Matrix3): this;
+    applyNormalMatrix(m: Matrix3): this;
+    applyMatrix4(m: Matrix4): this;
+    applyQuaternion(q: Quaternion): this;
+    transformDirection(m: Matrix4): this;
+    divide(v: Vector3): this;
+    divideScalar(scalar: number): this;
+    min(v: Vector3): this;
+    max(v: Vector3): this;
+    clamp(min: Vector3, max: Vector3): this;
+    clampScalar(minVal: number, maxVal: number): this;
+    clampLength(min: number, max: number): this;
+    floor(): this;
+    ceil(): this;
+    round(): this;
+    roundToZero(): this;
+    negate(): this;
+    dot(v: Vector3): number;
+    lengthSq(): number;
+    length(): number;
+    manhattanLength(): number;
+    normalize(): this;
+    setLength(length: number): this;
+    lerp(v: Vector3, alpha: number): this;
+    lerpVectors(v1: Vector3, v2: Vector3, alpha: number): this;
+    cross(v: Vector3): this;
+    crossVectors(a: Vector3, b: Vector3): this;
+    projectOnVector(v: Vector3): this;
+    projectOnPlane(planeNormal: Vector3): this;
+    reflect(normal: Vector3): this;
+    angleTo(v: Vector3): number;
+    distanceTo(v: Vector3): number;
+    distanceToSquared(v: Vector3): number;
+    manhattanDistanceTo(v: Vector3): number;
+    setFromSphericalCoords(radius: number, phi: number, theta: number): this;
+    setFromCylindricalCoords(radius: number, theta: number, y: number): this;
+    setFromMatrixPosition(m: Matrix4): this;
+    setFromMatrixScale(m: Matrix4): this;
+    setFromMatrixColumn(m: Matrix4, index: number): this;
+    setFromMatrix3Column(m: Matrix3, index: number): this;
+    setFromEuler(e: Euler): this;
+    equals(v: Vector3): boolean;
+    fromArray(array: number[], offset?: number): this;
+    toArray(array?: number[], offset?: number): number[];
+    random(): this;
+    randomDirection(): this;
+    abs(): this;
+    [Symbol.iterator](): Generator<number, void, unknown>;
+}
+
+declare class Quaternion {
+    _x: number;
+    _y: number;
+    _z: number;
+    _w: number;
+    isQuaternion: boolean;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    static slerpFlat(dst: number[], dstOffset: number, src0: number[], srcOffset0: number, src1: number[], srcOffset1: number, t: number): void;
+    static multiplyQuaternionsFlat(dst: number[], dstOffset: number, src0: number[], srcOffset0: number, src1: number[], srcOffset1: number): number[];
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get w(): number;
+    set w(value: number);
+    set(x: number, y: number, z: number, w: number): this;
+    clone(): Quaternion;
+    copy(quaternion: Quaternion): this;
+    setFromEuler(euler: Euler, update?: boolean): this;
+    setFromAxisAngle(axis: Vector3, angle: number): this;
+    setFromRotationMatrix(m: Matrix4): this;
+    setFromUnitVectors(vFrom: Vector3, vTo: Vector3): this;
+    angleTo(q: Quaternion): number;
+    rotateTowards(q: Quaternion, step: number): this;
+    identity(): this;
+    invert(): this;
+    conjugate(): this;
+    dot(v: Quaternion): number;
+    lengthSq(): number;
+    length(): number;
+    normalize(): this;
+    multiply(q: Quaternion): this;
+    premultiply(q: Quaternion): this;
+    multiplyQuaternions(a: Quaternion, b: Quaternion): this;
+    slerp(qb: Quaternion, t: number): this;
+    slerpQuaternions(qa: Quaternion, qb: Quaternion, t: number): this;
+    random(): this;
+    equals(quaternion: Quaternion): boolean;
+    fromArray(array: number[], offset?: number): this;
+    toArray(array?: number[], offset?: number): number[];
+    toJSON(): number[];
+    _onChange(callback: () => void): this;
+    _onChangeCallback(): void;
+    [Symbol.iterator](): Generator<number, void, unknown>;
+}
+
+type EulerOrder = 'XYZ' | 'YXZ' | 'ZXY' | 'ZYX' | 'YZX' | 'XZY' | 'XYX' | 'YZY' | 'ZXZ' | 'XZX' | 'YXY' | 'ZYZ';
+declare class Euler {
+    _x: number;
+    _y: number;
+    _z: number;
+    _order: EulerOrder;
+    isEuler: boolean;
+    static DEFAULT_ORDER: EulerOrder;
+    constructor(x?: number, y?: number, z?: number, order?: EulerOrder);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get order(): EulerOrder;
+    set order(value: EulerOrder);
+    set(x: number, y: number, z: number, order?: EulerOrder): this;
+    clone(): Euler;
+    copy(euler: Euler): this;
+    setFromRotationMatrix(m: Matrix4, order?: EulerOrder, update?: boolean): this;
+    setFromQuaternion(q: Quaternion, order: EulerOrder, update?: boolean): this;
+    setFromVector3(v: Vector3, order?: EulerOrder): this;
+    reorder(newOrder: EulerOrder): this;
+    equals(euler: Euler): boolean;
+    fromArray(array: any[]): this;
+    toArray(array?: any[], offset?: number): any[];
+    _onChange(callback: (euler?: Euler) => void): this;
+    _onChangeCallback(euler?: Euler): void;
+    [Symbol.iterator](): Generator<number | EulerOrder, void, unknown>;
+}
+
+declare class Vector4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    set(x: number, y: number, z: number, w: number): Vector4;
+    setScalar(scalar: number): Vector4;
+    setX(x: number): Vector4;
+    setY(y: number): Vector4;
+    setZ(z: number): Vector4;
+    setW(w: number): Vector4;
+    setComponent(index: number, value: number): Vector4;
+    getComponent(index: number): number;
+    clone(): Vector4;
+    copy(v: Vector4): Vector4;
+    add(v: Vector4): Vector4;
+    addScalar(scalar: number): Vector4;
+    addVectors(a: Vector4, b: Vector4): Vector4;
+    addScaledVector(v: Vector4, s: number): Vector4;
+    sub(v: Vector4): Vector4;
+    subScalar(scalar: number): Vector4;
+    subVectors(a: Vector4, b: Vector4): Vector4;
+    multiply(v: Vector4): Vector4;
+    multiplyScalar(scalar: number): Vector4;
+    applyMatrix4(m: Matrix4): this;
+    divideScalar(scalar: number): Vector4;
+    setAxisAngleFromQuaternion(q: Quaternion): this;
+    setAxisAngleFromRotationMatrix(m: Matrix3): this;
+    min(v: Vector4): this;
+    max(v: Vector4): this;
+    clamp(min: Vector4, max: Vector4): this;
+    clampScalar(minVal: number, maxVal: number): this;
+    clampLength(min: number, max: number): Vector4;
+    floor(): this;
+    ceil(): this;
+    round(): this;
+    roundToZero(): this;
+    negate(): this;
+    dot(v: Vector4): number;
+    lengthSq(): number;
+    length(): number;
+    manhattanLength(): number;
+    normalize(): Vector4;
+    setLength(length: number): Vector4;
+    lerp(v: Vector4, alpha: number): this;
+    lerpVectors(v1: Vector4, v2: Vector4, alpha: number): this;
+    equals(v: Vector4): boolean;
+    fromArray(array: number[], offset?: number): this;
+    toArray(array?: number[], offset?: number): number[];
+    random(): this;
+    [Symbol.iterator](): Generator<number, void, unknown>;
+}
+
+declare const DEG2RAD: number;
+declare const RAD2DEG: number;
+declare function generateUUID(): string;
+declare function clamp(value: number, min: number, max: number): number;
+declare function euclideanModulo(n: number, m: number): number;
+declare function mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number;
+declare function inverseLerp(x: number, y: number, value: number): number;
+declare function lerp(x: number, y: number, t: number): number;
+declare function damp(x: number, y: number, lambda: number, dt: number): number;
+declare function pingpong(x: number, length?: number): number;
+declare function smoothstep(x: number, min: number, max: number): number;
+declare function smootherstep(x: number, min: number, max: number): number;
+declare function randInt(low: number, high: number): number;
+declare function randFloat(low: number, high: number): number;
+declare function randFloatSpread(range: number): number;
+declare function seededRandom(s: number): number;
+declare function degToRad(degrees: number): number;
+declare function radToDeg(radians: number): number;
+declare function isPowerOfTwo(value: number): boolean;
+declare function ceilPowerOfTwo(value: number): number;
+declare function floorPowerOfTwo(value: number): number;
+declare function setQuaternionFromProperEuler(q: Quaternion, a: number, b: number, c: number, order: EulerOrder): void;
+declare function denormalize(value: number, array: number[]): number;
+declare function normalize(value: number, array: number[]): number;
+declare const MathUtils: {
+    DEG2RAD: number;
+    RAD2DEG: number;
+    generateUUID: typeof generateUUID;
+    clamp: typeof clamp;
+    euclideanModulo: typeof euclideanModulo;
+    mapLinear: typeof mapLinear;
+    inverseLerp: typeof inverseLerp;
+    lerp: typeof lerp;
+    damp: typeof damp;
+    pingpong: typeof pingpong;
+    smoothstep: typeof smoothstep;
+    smootherstep: typeof smootherstep;
+    randInt: typeof randInt;
+    randFloat: typeof randFloat;
+    randFloatSpread: typeof randFloatSpread;
+    seededRandom: typeof seededRandom;
+    degToRad: typeof degToRad;
+    radToDeg: typeof radToDeg;
+    isPowerOfTwo: typeof isPowerOfTwo;
+    ceilPowerOfTwo: typeof ceilPowerOfTwo;
+    floorPowerOfTwo: typeof floorPowerOfTwo;
+    setQuaternionFromProperEuler: typeof setQuaternionFromProperEuler;
+    normalize: typeof normalize;
+    denormalize: typeof denormalize;
+};
+
+declare class Bezier {
+    p: number[];
+    constructor(p1: number, p2: number, p3: number, p4: number);
+    genValue(t: number): number;
+    derivativeCoefficients(points: number[]): number[][];
+    getSlope(t: number): number;
+    controlCurve(d0: number, d1: number): void;
+    hull(t: number): number[];
+    split(t: number): {
+        left: Bezier;
+        right: Bezier;
+        span: number[];
+    };
+    clone(): Bezier;
+    toJSON(): {
+        p0: number;
+        p1: number;
+        p2: number;
+        p3: number;
+    };
+    static fromJSON(json: {
+        p0: number;
+        p1: number;
+        p2: number;
+        p3: number;
+    }): Bezier;
+}
+
+type FunctionJSON = {
+    [a: string]: any;
+};
+
+/**
+ * Per-particle scratch storage that lets stochastic generators "remember" a
+ * random sample they rolled at spawn time, so subsequent frames produce the
+ * same value for the same particle.
+ *
+ * Each `Particle` owns one `GeneratorMemory` (see `Particle.memory`) that
+ * starts empty and is cleared on `Particle.reset()` when the particle is
+ * recycled. A particle's memory is independent from every other particle's.
+ *
+ * ## Lifecycle (per spawn)
+ *
+ * For every generator the particle system uses (startColor, startSpeed,
+ * startLife, startSize, startRotation, etc.), the spawn path calls — in a
+ * fixed, deterministic order:
+ *
+ * 1. `generator.startGen(particle.memory)` — gives the generator a chance to
+ *    allocate a slot. A generator that needs a per-particle random sample
+ *    captures the current length as its slot index, pushes the rolled value,
+ *    and stores the index on itself (typically `this.indexCount`).
+ * 2. `generator.genValue(particle.memory, …)` — reads back `memory[indexCount]`
+ *    to produce the per-frame value. Called once per frame for the particle's
+ *    lifetime.
+ *
+ * Concrete patterns implemented across the codebase:
+ *
+ * - **Stateless / deterministic** (`ConstantValue`, `PiecewiseBezier`,
+ *   `Gradient`, `RandomColor`) — `startGen` is a no-op; `genValue` derives
+ *   output from inputs (`t`, params) alone.
+ * - **Sample-once stochastic** (`IntervalValue`, `ColorRange`,
+ *   `RandomColorBetweenGradient`, `RandomQuatGenerator`) — `startGen` pushes
+ *   one random sample into memory; `genValue` reads it. This is what keeps a
+ *   given particle's "random" startSize/color/rotation fixed for its life.
+ * - **Composite** (`AxisAngleGenerator`, `Vector3Function`, `EulerGenerator`)
+ *   — `startGen` forwards to children so each child claims its own slot.
+ *
+ * ## Invariants
+ *
+ * - Every spawn must call `startGen` for the same set of generators in the
+ *   same order. The slot index a generator captures during one particle's
+ *   spawn must match what it reads for *that* particle on later frames.
+ * - `indexCount` lives on the generator (shared across particles), not on
+ *   memory. It is overwritten on every spawn; that is safe because each
+ *   `genValue` call during a spawn happens before the next spawn's `startGen`.
+ * - The values stored in memory are not aliased — each particle's memory is
+ *   its own array, so two particles can hold different samples at the same
+ *   slot without interference.
+ */
+type GeneratorMemory = any[];
+
+declare class RandomColor implements ColorGenerator {
+    a: Vector4;
+    b: Vector4;
+    constructor(a: Vector4, b: Vector4);
+    startGen(memory: GeneratorMemory): void;
+    genColor(memory: GeneratorMemory, color: Vector4): Vector4;
+    type: 'value';
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): RandomColor;
+    clone(): ColorGenerator;
+}
+
+declare class ColorRange implements ColorGenerator {
+    a: Vector4;
+    b: Vector4;
+    constructor(a: Vector4, b: Vector4);
+    indexCount: number;
+    startGen(memory: GeneratorMemory): void;
+    genColor(memory: GeneratorMemory, color: Vector4): Vector4;
+    type: 'value';
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): ColorRange;
+    clone(): ColorGenerator;
+}
+
+interface ObjectValueType<T> {
+    copy(value: T): ObjectValueType<T>;
+    lerp(value: T, pos: number): ObjectValueType<T>;
+    clone(): ObjectValueType<T>;
+}
+declare class ContinuousLinearFunction<T extends ObjectValueType<T> | number> {
+    keys: Array<[T, number]>;
+    type: 'function';
+    subType: 'Number' | 'Vector3' | 'Vector4' | 'Color';
+    constructor(keys: Array<[T, number]>, subType: 'Number' | 'Vector3' | 'Vector4' | 'Color');
+    findKey(t: number): number;
+    getStartX(index: number): number;
+    getEndX(index: number): number;
+    genValue(value: T, t: number): T;
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): ContinuousLinearFunction<any>;
+    clone(): ContinuousLinearFunction<any>;
+}
+
+declare class Gradient implements FunctionColorGenerator {
+    type: 'function';
+    color: ContinuousLinearFunction<Vector3>;
+    alpha: ContinuousLinearFunction<number>;
+    constructor(color?: Array<[Vector3, number]>, alpha?: Array<[number, number]>);
+    genColor(memory: GeneratorMemory, color: Vector4, t: number): Vector4;
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): Gradient;
+    clone(): FunctionColorGenerator;
+    startGen(memory: GeneratorMemory): void;
+}
+
+declare class RandomColorBetweenGradient implements FunctionColorGenerator {
+    gradient1: Gradient;
+    gradient2: Gradient;
+    type: 'function';
+    private indexCount;
+    constructor(gradient1: Gradient, gradient2: Gradient);
+    startGen(memory: GeneratorMemory): void;
+    genColor(memory: GeneratorMemory, color: Vector4, t: number): Vector4;
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): RandomColorBetweenGradient;
+    clone(): RandomColorBetweenGradient;
+}
+
+interface ColorGenerator {
+    type: 'value';
+    startGen(memory: GeneratorMemory): void;
+    genColor(memory: GeneratorMemory, color: Vector4): Vector4;
+    toJSON(): FunctionJSON;
+    clone(): ColorGenerator;
+}
+interface FunctionColorGenerator {
+    type: 'function';
+    startGen(memory: GeneratorMemory): void;
+    genColor(memory: GeneratorMemory, color: Vector4, t: number): Vector4;
+    toJSON(): FunctionJSON;
+    clone(): FunctionColorGenerator;
+}
+declare class ConstantColor implements ColorGenerator {
+    color: Vector4;
+    constructor(color: Vector4);
+    startGen(memory: GeneratorMemory): void;
+    genColor(memoryGenerator: GeneratorMemory, color: Vector4): Vector4;
+    type: 'value';
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): ConstantColor;
+    clone(): ColorGenerator;
+}
+declare function ColorGeneratorFromJSON(json: FunctionJSON): RandomColor | ColorRange | Gradient | RandomColorBetweenGradient | ConstantColor;
+
+/**
+ * `startGen`/`genValue` follow the per-particle slot pattern documented in
+ * `GeneratorMemory.ts`: spawn calls `startGen(memory)` once (claim a slot or
+ * no-op), then `genValue(memory)` per frame.
+ */
+interface ValueGenerator {
+    type: 'value';
+    startGen(memory: any): void;
+    genValue(memory: any): number;
+    toJSON(): FunctionJSON;
+    clone(): ValueGenerator;
+}
+interface FunctionValueGenerator {
+    type: 'function';
+    startGen(memory: GeneratorMemory): void;
+    genValue(memory: GeneratorMemory, t: number): number;
+    toJSON(): FunctionJSON;
+    clone(): FunctionValueGenerator;
+}
+declare function ValueGeneratorFromJSON(json: FunctionJSON): FunctionValueGenerator | ValueGenerator;
+
+declare class ConstantValue implements ValueGenerator {
+    value: number;
+    type: 'value';
+    constructor(value: number);
+    startGen(memory: GeneratorMemory): void;
+    genValue(memory: GeneratorMemory): number;
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): ConstantValue;
+    clone(): ValueGenerator;
+}
+
+declare class IntervalValue implements ValueGenerator {
+    a: number;
+    b: number;
+    constructor(a: number, b: number);
+    indexCount: number;
+    startGen(memory: GeneratorMemory): void;
+    genValue(memory: GeneratorMemory): number;
+    type: 'value';
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): IntervalValue;
+    clone(): ValueGenerator;
+}
+
+declare abstract class PiecewiseFunction<T> {
+    functions: Array<[T, number]>;
+    protected constructor();
+    findFunction(t: number): number;
+    getStartX(index: number): number;
+    setStartX(index: number, x: number): void;
+    getEndX(index: number): number;
+    setEndX(index: number, x: number): void;
+    insertFunction(t: number, func: T): void;
+    removeFunction(index: number): T;
+    getFunction(index: number): T;
+    setFunction(index: number, func: T): void;
+    get numOfFunctions(): number;
+}
+
+declare class PiecewiseBezier extends PiecewiseFunction<Bezier> implements FunctionValueGenerator {
+    constructor(curves?: Array<[Bezier, number]>);
+    genValue(memory: GeneratorMemory, t?: number): number;
+    toSVG(length: number, segments: number): string;
+    type: 'function';
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): PiecewiseBezier;
+    clone(): FunctionValueGenerator;
+    startGen(memory: GeneratorMemory): void;
+}
+
+interface RotationGenerator {
+    type: 'rotation';
+    startGen(memory: GeneratorMemory): void;
+    genValue(memory: GeneratorMemory, q: Quaternion, delta: number, t: number): Quaternion;
+    toJSON(): FunctionJSON;
+    clone(): RotationGenerator;
+}
+declare function RotationGeneratorFromJSON(json: FunctionJSON): RotationGenerator;
+
+declare class RandomQuatGenerator implements RotationGenerator {
+    type: 'rotation';
+    constructor();
+    indexCount: number;
+    startGen(memory: GeneratorMemory): void;
+    genValue(memory: GeneratorMemory, quat: Quaternion, delta: number, t: number): Quaternion;
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): RotationGenerator;
+    clone(): RotationGenerator;
+}
+
+declare class AxisAngleGenerator implements RotationGenerator {
+    axis: Vector3;
+    angle: FunctionValueGenerator | ValueGenerator;
+    type: 'rotation';
+    constructor(axis: Vector3, angle: FunctionValueGenerator | ValueGenerator);
+    startGen(memory: GeneratorMemory): void;
+    genValue(memory: GeneratorMemory, quat: Quaternion, delta: number, t?: number): Quaternion;
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): AxisAngleGenerator;
+    clone(): RotationGenerator;
+}
+
+declare class EulerGenerator implements RotationGenerator {
+    angleX: FunctionValueGenerator | ValueGenerator;
+    angleY: FunctionValueGenerator | ValueGenerator;
+    angleZ: FunctionValueGenerator | ValueGenerator;
+    type: 'rotation';
+    eular: Euler;
+    constructor(angleX: FunctionValueGenerator | ValueGenerator, angleY: FunctionValueGenerator | ValueGenerator, angleZ: FunctionValueGenerator | ValueGenerator, eulerOrder?: EulerOrder);
+    startGen(memory: GeneratorMemory): void;
+    genValue(memory: GeneratorMemory, quat: Quaternion, delta: number, t?: number): Quaternion;
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): EulerGenerator;
+    clone(): RotationGenerator;
+}
+
+interface Vector3Generator {
+    type: 'vec3function';
+    startGen(memory: GeneratorMemory): void;
+    genValue(memory: GeneratorMemory, vec: Vector3, t?: number): Vector3;
+    toJSON(): FunctionJSON;
+    clone(): Vector3Generator;
+}
+declare function Vector3GeneratorFromJSON(json: FunctionJSON): Vector3Generator;
+
+declare class Vector3Function implements Vector3Generator {
+    x: FunctionValueGenerator | ValueGenerator;
+    y: FunctionValueGenerator | ValueGenerator;
+    z: FunctionValueGenerator | ValueGenerator;
+    type: 'vec3function';
+    constructor(x: FunctionValueGenerator | ValueGenerator, y: FunctionValueGenerator | ValueGenerator, z: FunctionValueGenerator | ValueGenerator);
+    startGen(memory: GeneratorMemory): void;
+    genValue(memory: GeneratorMemory, vec: Vector3, t?: number): Vector3;
+    toJSON(): FunctionJSON;
+    static fromJSON(json: FunctionJSON): Vector3Generator;
+    clone(): Vector3Generator;
+}
+
+declare function GeneratorFromJSON(json: FunctionJSON): FunctionValueGenerator | ValueGenerator | RotationGenerator | Vector3Generator;
+
+interface EmissionState {
+    burstIndex: number;
+    burstWaveIndex: number;
+    burstParticleIndex: number;
+    burstParticleCount: number;
+    isBursting: boolean;
+    time: number;
+    waitEmiting: number;
+    travelDistance: number;
+    previousWorldPos?: Vector3;
+}
+interface Resource {
+}
+interface JsonMetaData {
+    textures: {
+        [uuid: string]: Resource;
+    };
+    geometries: {
+        [uuid: string]: Resource;
+    };
+}
+interface SerializationOptions {
+    /**
+     * Use URL for image.
+     * @type {boolean}
+     */
+    useUrlForImage?: boolean;
+}
+type RendererEmitterSettings = TrailSettings | MeshSettings | BillBoardSettings | StretchedBillBoardSettings;
+interface StretchedBillBoardSettings {
+    /**
+     * how stretched the particle is in the direction of the camera based on the speed of the particle.
+     * @type {number}
+     */
+    speedFactor: number;
+    /**
+     * how stretched the particle is in the direction of the camera based on the size of the particle.
+     * @type {number}
+     */
+    lengthFactor: number;
+}
+interface BillBoardSettings {
+}
+interface TrailSettings {
+    /**
+     * Start length of the trail.
+     * @type {ValueGenerator | FunctionValueGenerator}
+     */
+    startLength: ValueGenerator | FunctionValueGenerator;
+    /**
+     * Whether to follow the local origin.
+     * @type {boolean}
+     */
+    followLocalOrigin: boolean;
+}
+interface MeshSettings {
+    /**
+     * Rotation axis.
+     * @type {Vector3}
+     */
+    rotationAxis?: Vector3;
+    /**
+     * Initial rotation around the X-axis.
+     * @type {ValueGenerator | FunctionValueGenerator}
+     */
+    startRotationX: ValueGenerator | FunctionValueGenerator;
+    /**
+     * Initial rotation around the Y-axis.
+     * @type {ValueGenerator | FunctionValueGenerator}
+     */
+    startRotationY: ValueGenerator | FunctionValueGenerator;
+    /**
+     * Initial rotation around the Z-axis.
+     * @type {ValueGenerator | FunctionValueGenerator}
+     */
+    startRotationZ: ValueGenerator | FunctionValueGenerator;
+}
+interface IEmitter {
+    system: IParticleSystem;
+    uuid: string;
+    visible: boolean;
+    matrixWorld: any;
+}
+type ParticleSystemEventType = "emitEnd" | "destroy" | "particleDied";
+interface ParticleSystemEvent {
+    type: ParticleSystemEventType;
+    particleSystem: IParticleSystem;
+    particle?: IParticle;
+}
+interface IParticleSystem {
+    /**
+     * Whether the ParticleSystem should be automatically disposed when it finishes emitting particles.
+     * @type {string}
+     */
+    autoDestroy: boolean;
+    /**
+     * Whether the system is in world space.
+     * @type {boolean}
+     */
+    worldSpace: boolean;
+    /**
+     * World-space velocity of the emitter, updated each frame by the runtime.
+     * @type {Vector3}
+     */
+    emitterVelocity?: Vector3;
+    /**
+     * Number of particles.
+     * @type {number}
+     */
+    particleNum: number;
+    /**
+     * Duration of the system.
+     * @type {number}
+     */
+    duration: number;
+    /**
+     * Whether the system is looping.
+     * @type {boolean}
+     */
+    looping: boolean;
+    /**
+     * Array of particles.
+     * @type {Array<IParticle>}
+     */
+    particles: Array<IParticle>;
+    /**
+     * Emitter for the particles.
+     * @type {IEmitter}
+     */
+    emitter: IEmitter;
+    /**
+     * Optional renderer.
+     * @type {BatchedRenderer}
+     */
+    rendererEmitterSettings: RendererEmitterSettings;
+    emissionState: EmissionState;
+    paused: boolean;
+    pause(): void;
+    stop(): void;
+    play(): void;
+    restart(): void;
+    endEmit(): void;
+    clone(): IParticleSystem;
+    toJSON(metaData: any, options: SerializationOptions): any;
+    emit(delta: number, subEmissionState: EmissionState, matrix: Matrix4): void;
+    addEventListener(event: ParticleSystemEventType, callback: (event: ParticleSystemEvent) => void): void;
+    removeEventListener(event: ParticleSystemEventType, callback: (event: ParticleSystemEvent) => void): void;
+    removeAllEventListeners(event: ParticleSystemEventType): void;
+}
+
+declare class LinkedListNode<T> {
+    data: T;
+    next: LinkedListNode<T> | null;
+    prev: LinkedListNode<T> | null;
+    constructor(data: T);
+    hasPrev(): boolean;
+    hasNext(): boolean;
+}
+declare class LinkedList<T> {
+    length: number;
+    head: LinkedListNode<T> | null;
+    tail: LinkedListNode<T> | null;
+    constructor();
+    isEmpty(): boolean;
+    clear(): void;
+    front(): T | null;
+    back(): T | null;
+    /**
+     * remove at head in O(1)
+     */
+    dequeue(): T | undefined;
+    /**
+     * remove at tail in O(1)
+     */
+    pop(): T | undefined;
+    /**
+     * add at head in O(1)
+     */
+    queue(data: T): void;
+    /**
+     * add at tail in O(1)
+     */
+    push(data: T): void;
+    insertBefore(node: LinkedListNode<T>, data: T): void;
+    remove(data: T): void;
+    /**
+     * Returns an iterator over the values
+     */
+    values(): Generator<T, void, unknown>;
+}
+
+interface IParticle {
+    /**
+     * Position of the particle.
+     * @type {Vector3}
+     */
+    position: Vector3;
+    /**
+     * Velocity of the particle.
+     * @type {Vector3}
+     */
+    velocity: Vector3;
+    /**
+     * Age of the particle.
+     * @type {number}
+     */
+    age: number;
+    /**
+     * Life duration of the particle.
+     * @type {number}
+     */
+    life: number;
+    /**
+     * Size of the particle.
+     * @type {Vector3}
+     */
+    size: Vector3;
+    /**
+     * Rotation of the particle.
+     * @type {number | Quaternion}
+     */
+    rotation?: number | Quaternion;
+    /**
+     * UV tile index.
+     * @type {number}
+     */
+    uvTile: number;
+    /**
+     * Color of the particle.
+     * @type {Vector4}
+     */
+    color: Vector4;
+    /**
+     * the memory of the particle.
+     */
+    memory: GeneratorMemory;
+    /**
+     * Indicates if the particle has died.
+     * @type {boolean}
+     */
+    get died(): boolean;
+}
+interface Particle extends IParticle {
+    /**
+     * Speed modifier of the particle.
+     * @type {number}
+     */
+    speedModifier: number;
+    /**
+     * Emission state of the particle.
+     * @type {EmissionState}
+     */
+    emissionState?: EmissionState;
+    /**
+     * Parent matrix for transformation.
+     * @type {Matrix4}
+     */
+    parentMatrix?: Matrix4;
+    /**
+     * Initial speed of the particle.
+     * @type {number}
+     */
+    startSpeed: number;
+    /**
+     * Initial color of the particle.
+     * @type {Vector4}
+     */
+    startColor: Vector4;
+    /**
+     * Initial size of the particle.
+     * @type {Vector3}
+     */
+    startSize: Vector3;
+    reset(): void;
+}
+/**
+ * Particle implementation for node-based particle systems.
+ */
+declare class NodeParticle implements IParticle {
+    /**
+     * Position of the particle.
+     * @type {Vector3}
+     */
+    position: Vector3;
+    /**
+     * Velocity of the particle.
+     * @type {Vector3}
+     */
+    velocity: Vector3;
+    /**
+     * Age of the particle.
+     * @type {number}
+     */
+    age: number;
+    /**
+     * Life duration of the particle.
+     * @type {number}
+     */
+    life: number;
+    /**
+     * Size of the particle.
+     * @type {Vector3}
+     */
+    size: Vector3;
+    /**
+     * Angular velocity of the particle.
+     * @type {number | Quaternion}
+     */
+    angularVelocity?: number | Quaternion;
+    /**
+     * Rotation of the particle.
+     * @type {number | Quaternion}
+     */
+    rotation: number | Quaternion;
+    /**
+     * Color of the particle.
+     * @type {Vector4}
+     */
+    color: Vector4;
+    /**
+     * UV tile index.
+     * @type {number}
+     */
+    uvTile: number;
+    /**
+     * Indicates if the particle has died.
+     * @type {boolean}
+     */
+    get died(): boolean;
+    /**
+     * Resets the particle properties to initial values.
+     */
+    reset(): void;
+    memory: never[];
+}
+/**
+ * Particle implementation for sprite-based particle.
+ */
+declare class SpriteParticle implements Particle {
+    /**
+     * Parent matrix for transformation.
+     * @type {Matrix4}
+     */
+    parentMatrix?: Matrix4;
+    /**
+     * Initial speed of the particle.
+     * @type {number}
+     */
+    startSpeed: number;
+    /**
+     * Initial color of the particle.
+     * @type {Vector4}
+     */
+    startColor: Vector4;
+    /**
+     * Initial size of the particle.
+     * @type {Vector3}
+     */
+    startSize: Vector3;
+    /**
+     * Position of the particle.
+     * @type {Vector3}
+     */
+    position: Vector3;
+    /**
+     * Velocity of the particle.
+     * @type {Vector3}
+     */
+    velocity: Vector3;
+    /**
+     * Age of the particle.
+     * @type {number}
+     */
+    age: number;
+    /**
+     * Life duration of the particle.
+     * @type {number}
+     */
+    life: number;
+    /**
+     * Size of the particle.
+     * @type {Vector3}
+     */
+    size: Vector3;
+    /**
+     * Speed modifier of the particle.
+     * @type {number}
+     */
+    speedModifier: number;
+    /**
+     * Angular velocity of the particle.
+     * @type {number | Quaternion}
+     */
+    angularVelocity?: number | Quaternion;
+    /**
+     * Rotation of the particle.
+     * @type {number | Quaternion}
+     */
+    rotation: number | Quaternion;
+    /**
+     * Color of the particle.
+     * @type {Vector4}
+     */
+    color: Vector4;
+    /**
+     * UV tile index.
+     * @type {number}
+     */
+    uvTile: number;
+    /**
+     * Indicates if the particle has died.
+     * @type {boolean}
+     */
+    get died(): boolean;
+    reset(): void;
+    memory: never[];
+}
+declare class RecordState {
+    position: Vector3;
+    size: number;
+    color: Vector4;
+    /**
+     * Creates a new record state.
+     * @param {Vector3} position - The position of the particle.
+     * @param {number} size - The size of the particle.
+     * @param {Vector4} color - The color of the particle.
+     */
+    constructor(position: Vector3, size: number, color: Vector4);
+}
+/**
+ * Particle implementation for trail-based particles.
+ */
+declare class TrailParticle implements Particle {
+    /**
+     * Parent matrix for transformation.
+     * @type {Matrix4}
+     */
+    parentMatrix?: Matrix4;
+    /**
+     * Initial speed of the particle.
+     * @type {number}
+     */
+    startSpeed: number;
+    /**
+     * Initial color of the particle.
+     * @type {Vector4}
+     */
+    startColor: Vector4;
+    /**
+     * Initial size of the particle.
+     * @type {Vector3}
+     */
+    startSize: Vector3;
+    /**
+     * Position of the particle.
+     * @type {Vector3}
+     */
+    position: Vector3;
+    /**
+     * Local position of the particle.
+     * @type {Vector3}
+     */
+    localPosition?: Vector3;
+    /**
+     * Velocity of the particle.
+     * @type {Vector3}
+     */
+    velocity: Vector3;
+    /**
+     * Age of the particle.
+     * @type {number}
+     */
+    age: number;
+    /**
+     * Life duration of the particle.
+     * @type {number}
+     */
+    life: number;
+    /**
+     * Size of the particle.
+     * @type {Vector3}
+     */
+    size: Vector3;
+    /**
+     * Length of the trail.
+     * @type {number}
+     */
+    length: number;
+    /**
+     * Speed modifier of the particle.
+     * @type {number}
+     */
+    speedModifier: number;
+    /**
+     * Color of the particle.
+     * @type {Vector4}
+     */
+    color: Vector4;
+    /**
+     * Previous states of the particle.
+     * @type {LinkedList<RecordState>}
+     */
+    previous: LinkedList<RecordState>;
+    /**
+     * UV tile index.
+     * @type {number}
+     */
+    uvTile: number;
+    /**
+     * Updates the particle state.
+     */
+    update(): void;
+    /**
+     * Indicates if the particle has died.
+     * @type {boolean}
+     */
+    get died(): boolean;
+    /**
+     * Resets the particle properties and clears the previous states.
+     */
+    reset(): void;
+    memory: never[];
+}
+
+interface ShapeJSON {
+    type: string;
+    radius?: number;
+    arc?: number;
+    thickness?: number;
+    donutRadius?: number;
+    angle?: number;
+    width?: number;
+    height?: number;
+    column?: number;
+    row?: number;
+    mesh?: string;
+    mode?: number;
+    particleSystem?: string;
+    spread?: number;
+    speed?: any;
+}
+/**
+ * Enum representing the emitter modes for particles.
+ */
+declare enum EmitterMode {
+    /**
+     * Emit particles randomly over the specified duration.
+     */
+    Random = 0,
+    /**
+     * Emit particles in a continuous loop.
+     */
+    Loop = 1,
+    /**
+     * Emit particles back and forth in a ping-pong manner.
+     */
+    PingPong = 2,
+    /**
+     * Emit particles in bursts.
+     */
+    Burst = 3
+}
+declare function getValueFromEmitterMode(mode: EmitterMode, currentValue: number, spread: number, emissionState: EmissionState): number;
+interface EmitterShape {
+    type: string;
+    initialize(particle: Particle, emissionState: EmissionState): void;
+    toJSON(): ShapeJSON;
+    update(system: IParticleSystem, delta: number): void;
+    clone(): EmitterShape;
+}
+
+/**
+ * Interface representing the parameters for a cone emitter.
+ */
+interface ConeEmitterParameters {
+    /**
+     * The radius of the cone base.
+     */
+    radius?: number;
+    /**
+     * The arc of the cone.
+     */
+    arc?: number;
+    /**
+     * The thickness of the cone. 1 is a full cone, 0 is a cone with 0 thickness.
+     */
+    thickness?: number;
+    /**
+     * The angle of the cone, ranging from 0 to Math.PI / 2.
+     */
+    angle?: number;
+    /**
+     * The mode of the emitter.
+     * {@link EmitterMode}
+     */
+    mode?: EmitterMode;
+    /**
+     * The length of the segment at which the emitter point converges at the start and end, when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    spread?: number;
+    /**
+     * The speed of the emitter start point when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    speed?: ValueGenerator | FunctionValueGenerator;
+}
+declare class ConeEmitter implements EmitterShape {
+    type: string;
+    radius: number;
+    arc: number;
+    thickness: number;
+    angle: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    private currentValue;
+    constructor(parameters?: ConeEmitterParameters);
+    update(system: IParticleSystem, delta: number): void;
+    initialize(p: Particle, emissionState: EmissionState): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: ShapeJSON): ConeEmitter;
+    clone(): EmitterShape;
+}
+
+/**
+ * Interface representing the parameters for a circle emitter.
+ */
+interface CircleEmitterParameters {
+    /**
+     * The radius of the circle.
+     */
+    radius?: number;
+    /**
+     * The arc of the circle.
+     */
+    arc?: number;
+    /**
+     * The thickness of the ring.
+     * 1 is a full circle, 0 is a ring with 0 radius.
+     */
+    thickness?: number;
+    /**
+     * The mode of the emitter.
+     * {@link EmitterMode}
+     */
+    mode?: EmitterMode;
+    /**
+     * The length of segment of which emitter point converges at the start and end, when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    spread?: number;
+    /**
+     * The speed of the emitter start point travels when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    speed?: ValueGenerator | FunctionValueGenerator;
+}
+/**
+ * a particle emitter that emits particles from a circle.
+ */
+declare class CircleEmitter implements EmitterShape {
+    type: string;
+    radius: number;
+    arc: number;
+    thickness: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    private currentValue;
+    constructor(parameters?: CircleEmitterParameters);
+    update(system: IParticleSystem, delta: number): void;
+    initialize(p: Particle, emissionState: EmissionState): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): CircleEmitter;
+    clone(): EmitterShape;
+}
+
+/**
+ * Interface representing the parameters for a donut emitter.
+ */
+interface DonutEmitterParameters {
+    /**
+     * The radius of the donut.
+     */
+    radius?: number;
+    /**
+     * The arc of the donut.
+     */
+    arc?: number;
+    /**
+     * The thickness of the ring. 1 is a full donut, 0 is a ring with 0 radius.
+     */
+    thickness?: number;
+    /**
+     * The radius of the hole in the center of the donut.
+     */
+    donutRadius?: number;
+    /**
+     * The mode of the emitter.
+     * {@link EmitterMode}
+     */
+    mode?: EmitterMode;
+    /**
+     * The length of the segment at which the emitter point converges at the start and end, when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    spread?: number;
+    /**
+     * The speed of the emitter start point when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    speed?: ValueGenerator | FunctionValueGenerator;
+}
+declare class DonutEmitter implements EmitterShape {
+    type: string;
+    radius: number;
+    donutRadius: number;
+    arc: number;
+    thickness: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    _m1: Matrix4;
+    constructor(parameters?: DonutEmitterParameters);
+    private currentValue;
+    update(system: IParticleSystem, delta: number): void;
+    initialize(p: Particle, emissionState: EmissionState): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): DonutEmitter;
+    clone(): EmitterShape;
+}
+
+/**
+ * A point emitter emits particles from a single point.
+ */
+declare class PointEmitter implements EmitterShape {
+    type: string;
+    _m1: Matrix4;
+    constructor();
+    update(system: IParticleSystem, delta: number): void;
+    initialize(p: Particle): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): PointEmitter;
+    clone(): EmitterShape;
+}
+
+/**
+ * Interface representing the parameters for a sphere emitter.
+ */
+interface SphereEmitterParameters {
+    /**
+     * The radius of the sphere.
+     */
+    radius?: number;
+    /**
+     * The arc of the sphere.
+     */
+    arc?: number;
+    /**
+     * The thickness of the sphere. 1 is a full sphere, 0 is a thin shell.
+     */
+    thickness?: number;
+    /**
+     * The mode of the emitter.
+     * {@link EmitterMode}
+     */
+    mode?: EmitterMode;
+    /**
+     * The length of the segment at which the emitter point converges at the start and end, when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    spread?: number;
+    /**
+     * The speed of the emitter start point when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    speed?: ValueGenerator | FunctionValueGenerator;
+}
+declare class SphereEmitter implements EmitterShape {
+    type: string;
+    radius: number;
+    arc: number;
+    thickness: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    _m1: Matrix4;
+    constructor(parameters?: SphereEmitterParameters);
+    private currentValue;
+    update(system: IParticleSystem, delta: number): void;
+    initialize(p: Particle, emissionState: EmissionState): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): SphereEmitter;
+    clone(): EmitterShape;
+}
+
+/**
+ * Interface representing the parameters for a hemisphere emitter.
+ */
+interface HemisphereEmitterParameters {
+    /**
+     * The radius of the hemisphere.
+     */
+    radius?: number;
+    /**
+     * The arc of the hemisphere.
+     */
+    arc?: number;
+    /**
+     * The thickness of the hemisphere. 1 is a full hemisphere, 0 is a thin shell.
+     */
+    thickness?: number;
+    /**
+     * The mode of the emitter.
+     * {@link EmitterMode}
+     */
+    mode?: EmitterMode;
+    /**
+     * The length of the segment at which the emitter point converges at the start and end, when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    spread?: number;
+    /**
+     * The speed of the emitter start point when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    speed?: ValueGenerator | FunctionValueGenerator;
+}
+declare class HemisphereEmitter implements EmitterShape {
+    type: string;
+    radius: number;
+    arc: number;
+    thickness: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    _m1: Matrix4;
+    constructor(parameters?: HemisphereEmitterParameters);
+    private currentValue;
+    update(system: IParticleSystem, delta: number): void;
+    initialize(p: Particle, emissionState: EmissionState): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): HemisphereEmitter;
+    clone(): EmitterShape;
+}
+
+/**
+ * Interface representing the parameters for a grid emitter.
+ */
+interface GridEmitterParameters {
+    /**
+     * The width of the grid.
+     */
+    width?: number;
+    /**
+     * The height of the grid.
+     */
+    height?: number;
+    /**
+     * The number of columns in the grid.
+     */
+    column?: number;
+    /**
+     * The number of rows in the grid.
+     */
+    row?: number;
+}
+declare class GridEmitter implements EmitterShape {
+    type: string;
+    width: number;
+    height: number;
+    column: number;
+    row: number;
+    constructor(parameters?: GridEmitterParameters);
+    initialize(p: Particle): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): GridEmitter;
+    clone(): EmitterShape;
+    update(system: IParticleSystem, delta: number): void;
+}
+
+/**
+ * Interface representing the parameters for a rectangle emitter.
+ */
+interface RectangleEmitterParameters {
+    /**
+     * The width of the rectangle.
+     */
+    width?: number;
+    /**
+     * The height of the rectangle.
+     */
+    height?: number;
+    /**
+     * The thickness of the ring.
+     * 1 is a full rectangle, 0 is a ring with 0 radius.
+     */
+    thickness?: number;
+    /**
+     * The mode of the emitter.
+     * {@link EmitterMode}
+     */
+    mode?: EmitterMode;
+    /**
+     * The length of segment of which emitter point converges at the start and end, when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    spread?: number;
+    /**
+     * The speed of the emitter start point travels when mode is EmitterMode.Loop or EmitterMode.PingPong.
+     * {@link EmitterMode}
+     */
+    speed?: ValueGenerator | FunctionValueGenerator;
+}
+/**
+ * a particle emitter that emits particles from a rectangle.
+ */
+declare class RectangleEmitter implements EmitterShape {
+    type: string;
+    width: number;
+    height: number;
+    thickness: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    private currentValue;
+    private _m1;
+    constructor(parameters?: RectangleEmitterParameters);
+    update(system: IParticleSystem, delta: number): void;
+    initialize(p: Particle, emissionState: EmissionState): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): RectangleEmitter;
+    clone(): EmitterShape;
+}
+
+interface Constructable<T> {
+    new (...args: any): T;
+}
+type FieldType = 'vec3' | 'value' | 'number' | 'range' | 'colorFunc' | 'valueFunc' | 'rotationFunc' | 'radian' | 'mesh' | 'particleSystem' | 'boolean' | 'string' | 'geometry' | 'emitterMode' | 'vec3Func';
+type ParameterType = FieldType | 'self';
+type ParameterPair = [string, Array<ParameterType>];
+
+interface EmitterShapePlugin {
+    type: string;
+    constructor: Constructable<EmitterShape>;
+    params: ParameterPair[];
+    loadJSON: (json: any, meta: JsonMetaData) => EmitterShape;
+}
+declare const EmitterShapes: {
+    [key: string]: EmitterShapePlugin;
+};
+declare function EmitterFromJSON(json: ShapeJSON, meta: JsonMetaData): EmitterShape;
+
+/**
+ * Interface for particle behaviors.
+ * a behavior is a function that modifies a particle's properties over time.
+ */
+interface Behavior {
+    type: string;
+    initialize(particle: Particle, particleSystem: IParticleSystem): void;
+    update(particle: Particle, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    clone(): Behavior;
+    reset(): void;
+}
+interface BehaviorPlugin {
+    type: string;
+    constructor: Constructable<Behavior>;
+    params: ParameterPair[];
+    loadJSON: (json: any, particleSystem: IParticleSystem) => Behavior;
+}
+declare const BehaviorTypes: {
+    [key: string]: BehaviorPlugin;
+};
+declare function BehaviorFromJSON(json: any, particleSystem: IParticleSystem): Behavior | null;
+
+/**
+ * Color particles by their life.
+ */
+declare class ColorOverLife implements Behavior {
+    color: FunctionColorGenerator;
+    type: string;
+    constructor(color: FunctionColorGenerator);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Apply rotation to particles over their life.
+ */
+declare class RotationOverLife implements Behavior {
+    angularVelocity: ValueGenerator | FunctionValueGenerator;
+    type: string;
+    constructor(angularVelocity: ValueGenerator | FunctionValueGenerator);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    frameUpdate(delta: number): void;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Apply rotation to particles over their life.
+ */
+declare class Rotation3DOverLife implements Behavior {
+    angularVelocity: RotationGenerator;
+    type: string;
+    private tempQuat;
+    private tempQuat2;
+    constructor(angularVelocity: RotationGenerator);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    frameUpdate(delta: number): void;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Apply a force to particles over their life.
+ */
+declare class ForceOverLife implements Behavior {
+    x: FunctionValueGenerator | ValueGenerator;
+    y: FunctionValueGenerator | ValueGenerator;
+    z: FunctionValueGenerator | ValueGenerator;
+    type: string;
+    _temp: Vector3;
+    ps: IParticleSystem;
+    initialize(particle: Particle, particleSystem: IParticleSystem): void;
+    constructor(x: FunctionValueGenerator | ValueGenerator, y: FunctionValueGenerator | ValueGenerator, z: FunctionValueGenerator | ValueGenerator);
+    update(particle: Particle, delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    _tempScale: Vector3;
+    _tempQ: Quaternion;
+    frameUpdate(delta: number): void;
+    clone(): Behavior;
+    reset(): void;
+}
+
+type VelocityOverLifeSpace = 'local' | 'world';
+/**
+ * Move particles with a direct velocity over their life (Unity's "Velocity over Lifetime").
+ * Applied as a positional displacement, so it is not affected by speed modifiers,
+ * forces, or speed limits. Orbital speeds rotate particles around the emitter axes.
+ */
+declare class VelocityOverLife implements Behavior {
+    linearX: FunctionValueGenerator | ValueGenerator;
+    linearY: FunctionValueGenerator | ValueGenerator;
+    linearZ: FunctionValueGenerator | ValueGenerator;
+    orbitalX: FunctionValueGenerator | ValueGenerator;
+    orbitalY: FunctionValueGenerator | ValueGenerator;
+    orbitalZ: FunctionValueGenerator | ValueGenerator;
+    space: VelocityOverLifeSpace;
+    type: string;
+    ps: IParticleSystem;
+    constructor(linearX?: FunctionValueGenerator | ValueGenerator, linearY?: FunctionValueGenerator | ValueGenerator, linearZ?: FunctionValueGenerator | ValueGenerator, orbitalX?: FunctionValueGenerator | ValueGenerator, orbitalY?: FunctionValueGenerator | ValueGenerator, orbitalZ?: FunctionValueGenerator | ValueGenerator, space?: VelocityOverLifeSpace);
+    _temp: Vector3;
+    _tempEmitterPos: Vector3;
+    _tempQ: Quaternion;
+    _tempQInv: Quaternion;
+    _tempScale: Vector3;
+    _tempScaleInv: Vector3;
+    _tempRot: Quaternion;
+    _tempAxis: Vector3;
+    initialize(particle: Particle, particleSystem: IParticleSystem): void;
+    frameUpdate(delta: number): void;
+    update(particle: Particle, delta: number): void;
+    private orbit;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+type InheritVelocityMode = 'initial' | 'current';
+/**
+ * Make particles inherit the emitter's movement velocity (Unity's "Inherit Velocity").
+ * 'initial' adds the emitter velocity to the particle velocity once at spawn;
+ * 'current' displaces particles by the current emitter velocity every frame.
+ */
+declare class InheritVelocity implements Behavior {
+    multiplier: FunctionValueGenerator | ValueGenerator;
+    mode: InheritVelocityMode;
+    type: string;
+    ps: IParticleSystem;
+    constructor(multiplier?: FunctionValueGenerator | ValueGenerator, mode?: InheritVelocityMode);
+    _temp: Vector3;
+    _tempPos: Vector3;
+    _tempQInv: Quaternion;
+    _tempScaleInv: Vector3;
+    initialize(particle: Particle, particleSystem: IParticleSystem): void;
+    frameUpdate(delta: number): void;
+    update(particle: Particle, delta: number): void;
+    private decomposeInverse;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ *  Apply size to particles based on their life.
+ */
+declare class SizeOverLife implements Behavior {
+    size: FunctionValueGenerator | Vector3Generator;
+    type: string;
+    initialize(particle: Particle): void;
+    constructor(size: FunctionValueGenerator | Vector3Generator);
+    update(particle: Particle): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    frameUpdate(delta: number): void;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Apply speed to particles based on their life.
+ */
+declare class SpeedOverLife implements Behavior {
+    speed: FunctionValueGenerator;
+    type: string;
+    initialize(particle: Particle): void;
+    constructor(speed: FunctionValueGenerator);
+    update(particle: Particle): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    frameUpdate(delta: number): void;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * apply tile number of particle texture by particles' life.
+ */
+declare class FrameOverLife implements Behavior {
+    frame: FunctionValueGenerator;
+    type: string;
+    constructor(frame: FunctionValueGenerator);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Orbit particles around an axis over their life.
+ */
+declare class OrbitOverLife implements Behavior {
+    orbitSpeed: FunctionValueGenerator | ValueGenerator;
+    axis: Vector3;
+    type: string;
+    rotation: Quaternion;
+    temp: Vector3;
+    constructor(orbitSpeed: FunctionValueGenerator | ValueGenerator, axis?: Vector3);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Apply width to particles based on their length.
+ */
+declare class WidthOverLength implements Behavior {
+    width: FunctionValueGenerator;
+    type: string;
+    initialize(particle: Particle): void;
+    constructor(width: FunctionValueGenerator);
+    update(particle: Particle): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Apply a global force to particles.
+ */
+declare class ApplyForce implements Behavior {
+    direction: Vector3;
+    magnitude: ValueGenerator;
+    type: string;
+    magnitudeValue: number;
+    memory: {
+        data: never[];
+        dataCount: number;
+    };
+    constructor(direction: Vector3, magnitude: ValueGenerator);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Apply a gravity force to particles.
+ * the gravity force is calculated as:
+ * F = G * m1 * m2 / r^2
+ */
+declare class GravityForce implements Behavior {
+    center: Vector3;
+    magnitude: number;
+    type: string;
+    temp: Vector3;
+    constructor(center: Vector3, magnitude: number);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Change the emit direction of particles.
+ */
+declare class ChangeEmitDirection implements Behavior {
+    angle: ValueGenerator;
+    type: string;
+    _temp: Vector3;
+    _q: Quaternion;
+    memory: {
+        data: never[];
+        dataCount: number;
+    };
+    constructor(angle: ValueGenerator);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+declare enum SubParticleEmitMode {
+    Death = 0,
+    Birth = 1,
+    Frame = 2
+}
+/**
+ * Emit a sub particle system from particles.
+ */
+declare class EmitSubParticleSystem implements Behavior {
+    private particleSystem;
+    useVelocityAsBasis: boolean;
+    subParticleSystem: IEmitter | undefined;
+    mode: SubParticleEmitMode;
+    emitProbability: number;
+    type: string;
+    private q_;
+    private v_;
+    private v2_;
+    private subEmissions;
+    constructor(particleSystem: IParticleSystem, useVelocityAsBasis: boolean, subParticleSystem: IEmitter | undefined, mode?: SubParticleEmitMode, emitProbability?: number);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    private emit;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any, particleSystem: IParticleSystem): Behavior;
+    clone(): Behavior;
+    reset(): void;
+    private setMatrixFromParticle;
+}
+
+/**
+ * A random() function, must return a numer in the interval [0,1), just like Math.random().
+ */
+type RandomFn = () => number;
+/** Deterministic simplex noise generator suitable for 2D, 3D and 4D spaces. */
+declare class SimplexNoise {
+    private p;
+    private perm;
+    private permMod12;
+    /**
+     * Creates a new `SimplexNoise` instance.
+     * This involves some setup. You can save a few cpu cycles by reusing the same instance.
+     * @param randomOrSeed A random number generator or a seed (string|number).
+     * Defaults to Math.random (random irreproducible initialization).
+     */
+    constructor(randomOrSeed?: RandomFn | string | number);
+    /**
+     * Samples the noise field in 2 dimensions
+     * @param x
+     * @param y
+     * @returns a number in the interval [-1, 1]
+     */
+    noise2D(x: number, y: number): number;
+    /**
+     * Samples the noise field in 3 dimensions
+     * @param x
+     * @param y
+     * @param z
+     * @returns a number in the interval [-1, 1]
+     */
+    noise3D(x: number, y: number, z: number): number;
+    /**
+     * Samples the noise field in 4 dimensions
+     * @param x
+     * @param y
+     * @param z
+     * @returns a number in the interval [-1, 1]
+     */
+    noise4D(x: number, y: number, z: number, w: number): number;
+}
+
+/**
+ * Apply turbulence to particles.
+ */
+declare class TurbulenceField implements Behavior {
+    scale: Vector3;
+    octaves: number;
+    velocityMultiplier: Vector3;
+    timeScale: Vector3;
+    type: string;
+    generator: SimplexNoise;
+    timeOffset: Vector3;
+    temp: Vector3;
+    temp2: Vector3;
+    constructor(scale: Vector3, octaves: number, velocityMultiplier: Vector3, timeScale: Vector3);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    toJSON(): any;
+    frameUpdate(delta: number): void;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Apply noise to particles.
+ */
+declare class Noise implements Behavior {
+    frequency: FunctionValueGenerator | ValueGenerator;
+    power: FunctionValueGenerator | ValueGenerator;
+    positionAmount: FunctionValueGenerator | ValueGenerator;
+    rotationAmount: FunctionValueGenerator | ValueGenerator;
+    type: string;
+    duration: number;
+    constructor(frequency: FunctionValueGenerator | ValueGenerator, power: FunctionValueGenerator | ValueGenerator, positionAmount?: FunctionValueGenerator | ValueGenerator, rotationAmount?: FunctionValueGenerator | ValueGenerator);
+    initialize(particle: Particle): void;
+    update(particle: Particle, _: number): void;
+    toJSON(): any;
+    frameUpdate(delta: number): void;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+interface Sequencer {
+    transform(position: Vector3, index: number): void;
+    toJSON(): any;
+    clone(): Sequencer;
+}
+declare function SequencerFromJSON(json: any): Sequencer;
+
+/**
+ * Apply sequences to particles.
+ * {@link Sequencer}
+ */
+declare class ApplySequences implements Behavior {
+    static BEZIER: Bezier;
+    type: string;
+    sequencers: Array<[IntervalValue, Sequencer]>;
+    time: number;
+    index: number;
+    pCount: number;
+    delay: number;
+    tempV: Vector3;
+    constructor(delayBetweenParticles: number);
+    initialize(particle: Particle): void;
+    reset(): void;
+    update(particle: Particle, delta: number): void;
+    frameUpdate(delta: number): void;
+    appendSequencer(range: IntervalValue, sequencer: Sequencer): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+}
+
+interface PhysicsResolver {
+    resolve(pos: Vector3, normal: Vector3): boolean;
+}
+declare function setPhysicsResolver(resolver: PhysicsResolver): void;
+declare function getPhysicsResolver(): PhysicsResolver;
+/**
+ * Apply collision to particles from a physics resolver.
+ */
+declare class ApplyCollision implements Behavior {
+    resolver: PhysicsResolver;
+    bounce: number;
+    type: string;
+    tempV: Vector3;
+    constructor(resolver: PhysicsResolver, bounce: number);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Color particles by their speed.
+ */
+declare class ColorBySpeed implements Behavior {
+    color: FunctionColorGenerator;
+    speedRange: IntervalValue;
+    type: string;
+    constructor(color: FunctionColorGenerator, speedRange: IntervalValue);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Apply size to particles based on their speed.
+ */
+declare class SizeBySpeed implements Behavior {
+    size: FunctionValueGenerator | Vector3Generator;
+    speedRange: IntervalValue;
+    type: string;
+    initialize(particle: Particle): void;
+    constructor(size: FunctionValueGenerator | Vector3Generator, speedRange: IntervalValue);
+    update(particle: Particle): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    frameUpdate(delta: number): void;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Apply rotation to particles based on their speed.
+ */
+declare class RotationBySpeed implements Behavior {
+    angularVelocity: ValueGenerator | FunctionValueGenerator;
+    speedRange: IntervalValue;
+    type: string;
+    private tempQuat;
+    constructor(angularVelocity: ValueGenerator | FunctionValueGenerator, speedRange: IntervalValue);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    frameUpdate(delta: number): void;
+    clone(): Behavior;
+    reset(): void;
+}
+
+/**
+ * Limit the speed of particles over their life.
+ */
+declare class LimitSpeedOverLife implements Behavior {
+    speed: FunctionValueGenerator;
+    dampen: number;
+    type: string;
+    initialize(particle: Particle): void;
+    constructor(speed: FunctionValueGenerator, dampen: number);
+    update(particle: Particle, delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    frameUpdate(delta: number): void;
+    clone(): Behavior;
+    reset(): void;
+}
+
+declare class TextureSequencer implements Sequencer {
+    scaleX: number;
+    scaleY: number;
+    position: Vector3;
+    locations: Vector2[];
+    constructor(scaleX?: number, scaleY?: number, position?: Vector3);
+    transform(position: Vector3, index: number): void;
+    static fromJSON(json: any): Sequencer;
+    clone(): Sequencer;
+    toJSON(): any;
+    fromImage(img: CanvasImageSource, threshold: number): void;
+}
+
+interface Plugin {
+    id: string;
+    initialize: () => void;
+    emitterShapes: Array<EmitterShapePlugin>;
+    behaviors: Array<BehaviorPlugin>;
+}
+declare const Plugins: Array<Plugin>;
+declare function loadPlugin(plugin: Plugin): void;
+declare function unloadPlugin(pluginId: string): void;
+
+interface IAnimationData {
+    /** Start time in seconds */
+    startTime: number;
+    /** Duration in seconds */
+    duration: number;
+    /** Target object */
+    target: any;
+}
+interface IPrefab {
+    /**
+     * The name of the prefab.
+     */
+    name: string;
+    /**
+     * The children of the prefab.
+     */
+    animationData: IAnimationData[];
+}
+
+declare enum RenderMode {
+    BillBoard = 0,
+    StretchedBillBoard = 1,
+    Mesh = 2,
+    Trail = 3,
+    HorizontalBillBoard = 4,
+    VerticalBillBoard = 5
+}
+interface StoredBatchSettings {
+    instancingGeometry: Float32Array;
+    instancingIndices: Uint32Array | Uint16Array;
+    instancingUVs?: Float32Array;
+    instancingNormals?: Float32Array;
+    renderMode: RenderMode;
+    renderOrder: number;
+    uTileCount: number;
+    vTileCount: number;
+    blendTiles: boolean;
+    softParticles: boolean;
+    softNearFade: number;
+    softFarFade: number;
+    materialBlendMode: number;
+    materialTransparent: boolean;
+    materialDepthTest: boolean;
+    materialDepthWrite: boolean;
+    materialAlphaTest: number;
+    texture: any;
+    layerMask: number;
+}
+declare abstract class VFXBatch {
+    mesh: Mesh;
+    systems: Set<IParticleSystem>;
+    settings: StoredBatchSettings;
+    protected maxParticles: number;
+    protected scene: Scene;
+    protected constructor(settings: VFXBatchSettings, scene: Scene);
+    addSystem(system: IParticleSystem): void;
+    removeSystem(system: IParticleSystem): void;
+    getVisibleSystems(): IParticleSystem[];
+    applyDepthTexture(depthTexture: BaseTexture | null): void;
+    abstract setupBuffers(): void;
+    abstract expandBuffers(target: number): void;
+    abstract rebuildMaterial(): void;
+    abstract update(): void;
+    dispose(): void;
+}
+
+interface VFXBatchSettings {
+    instancingGeometry: Float32Array;
+    instancingIndices: Uint32Array | Uint16Array;
+    instancingUVs?: Float32Array;
+    instancingNormals?: Float32Array;
+    renderMode: RenderMode;
+    renderOrder: number;
+    uTileCount: number;
+    vTileCount: number;
+    blendTiles: boolean;
+    softParticles: boolean;
+    softNearFade: number;
+    softFarFade: number;
+    materialBlendMode: number;
+    materialTransparent: boolean;
+    materialDepthTest: boolean;
+    materialDepthWrite: boolean;
+    materialAlphaTest: number;
+    texture: Texture | null;
+    layerMask: number;
+}
+interface AdaptivePerformanceOptions {
+    targetFrameMs: number;
+    minQuality: number;
+    maxQuality: number;
+    decreaseStep: number;
+    increaseStep: number;
+}
+interface AdaptivePerformanceState extends AdaptivePerformanceOptions {
+    enabled: boolean;
+    currentQuality: number;
+    lastFrameCpuMs: number;
+}
+declare class BatchedRenderer extends TransformNode {
+    batches: Array<VFXBatch>;
+    systemToBatchIndex: Map<IParticleSystem, number>;
+    depthTexture: BaseTexture | null;
+    private adaptivePerformanceState;
+    private lastAppliedQuality;
+    constructor(name: string, scene: Scene);
+    private static clamp;
+    private static equals;
+    addSystem(system: IParticleSystem): void;
+    deleteSystem(system: IParticleSystem): void;
+    updateSystem(system: IParticleSystem): void;
+    setDepthTexture(depthTexture: BaseTexture | null): void;
+    configureAdaptivePerformance(options?: Partial<AdaptivePerformanceOptions>): void;
+    disableAdaptivePerformance(resetQuality?: boolean): void;
+    getAdaptivePerformanceState(): AdaptivePerformanceState;
+    private applyAdaptiveQuality;
+    update(delta: number): void;
+    dispose(): void;
+}
+
+declare const BatchedParticleRenderer: typeof BatchedRenderer;
+
+declare class SpriteBatch extends VFXBatch {
+    private offsetBuffer;
+    private rotationBuffer;
+    private sizeBuffer;
+    private colorBuffer;
+    private uvTileBuffer;
+    private velocityBuffer?;
+    private offsetVB;
+    private rotationVB;
+    private sizeVB;
+    private colorVB;
+    private uvTileVB;
+    private velocityVB?;
+    constructor(settings: VFXBatchSettings, scene: Scene);
+    setupBuffers(): void;
+    private buildExpandableBuffers;
+    expandBuffers(target: number): void;
+    rebuildMaterial(): void;
+    private vector_;
+    private vector2_;
+    private vector3_;
+    private quaternion_;
+    private quaternion2_;
+    private quaternion3_;
+    private rotationMat_;
+    private rotationMat2_;
+    private lastStretchedSpeedFactor;
+    update(): void;
+    dispose(): void;
+}
+
+declare class TrailBatch extends VFXBatch {
+    private positionBuffer;
+    private previousBuffer;
+    private nextBuffer;
+    private uvBuffer;
+    private sideBuffer;
+    private widthBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private previousVB;
+    private nextVB;
+    private sideVB;
+    private widthVB;
+    private getTrailHistoryCount;
+    constructor(settings: VFXBatchSettings, scene: Scene);
+    setupBuffers(): void;
+    private buildGeometryBuffers;
+    expandBuffers(target: number): void;
+    rebuildMaterial(): void;
+    private vector_;
+    private vector2_;
+    private vector3_;
+    private quaternion_;
+    update(): void;
+    dispose(): void;
+}
+
+declare class ParticleEmitter extends TransformNode {
+    system: IParticleSystem;
+    private _matrixWorld;
+    get matrixWorld(): Matrix4;
+    get visible(): boolean;
+    set visible(value: boolean);
+    get uuid(): string;
+    constructor(system: IParticleSystem, scene?: Scene);
+    dispose(): void;
+    extractFromCache(cache: any): any[];
+    clone(name?: string): ParticleEmitter;
+    toJSON(meta?: any, options?: SerializationOptions): any;
+}
+
+interface BurstParameters {
+    time: number;
+    count: ValueGenerator | FunctionValueGenerator;
+    cycle: number;
+    interval: number;
+    probability: number;
+}
+interface ParticleSystemParameters {
+    autoDestroy?: boolean;
+    looping?: boolean;
+    prewarm?: boolean;
+    duration?: number;
+    startDelay?: ValueGenerator | FunctionValueGenerator;
+    shape?: EmitterShape;
+    startLife?: ValueGenerator | FunctionValueGenerator;
+    startSpeed?: ValueGenerator | FunctionValueGenerator;
+    startRotation?: ValueGenerator | FunctionValueGenerator | RotationGenerator;
+    startSize?: ValueGenerator | FunctionValueGenerator | Vector3Generator;
+    startLength?: ValueGenerator | FunctionValueGenerator;
+    startColor?: ColorGenerator | FunctionColorGenerator;
+    emissionOverTime?: ValueGenerator | FunctionValueGenerator;
+    emissionOverDistance?: ValueGenerator | FunctionValueGenerator;
+    emissionBursts?: Array<BurstParameters>;
+    onlyUsedByOther?: boolean;
+    behaviors?: Array<Behavior>;
+    instancingGeometry?: Float32Array;
+    instancingIndices?: Uint32Array | Uint16Array;
+    instancingUVs?: Float32Array;
+    instancingNormals?: Float32Array;
+    renderMode?: RenderMode;
+    rendererEmitterSettings?: RendererEmitterSettings;
+    speedFactor?: number;
+    material?: any;
+    texture?: Texture | null;
+    startTileIndex?: ValueGenerator;
+    uTileCount?: number;
+    vTileCount?: number;
+    blendTiles?: boolean;
+    softParticles?: boolean;
+    softFarFade?: number;
+    softNearFade?: number;
+    renderOrder?: number;
+    worldSpace?: boolean;
+    blendMode?: number;
+    transparent?: boolean;
+    depthTest?: boolean;
+    depthWrite?: boolean;
+    alphaTest?: number;
+    layerMask?: number;
+    scene?: Scene;
+}
+interface BurstParametersJSON {
+    time: number;
+    count: FunctionJSON | number;
+    cycle: number;
+    interval: number;
+    probability: number;
+}
+interface ParticleSystemJSONParameters {
+    version: string;
+    autoDestroy: boolean;
+    looping: boolean;
+    prewarm: boolean;
+    duration: number;
+    startDelay?: FunctionJSON;
+    shape: any;
+    startLife: FunctionJSON;
+    startSpeed: FunctionJSON;
+    startRotation: FunctionJSON;
+    startSize: FunctionJSON;
+    startColor: FunctionJSON;
+    emissionOverTime: FunctionJSON;
+    emissionOverDistance: FunctionJSON;
+    emissionBursts?: Array<BurstParametersJSON>;
+    onlyUsedByOther: boolean;
+    rendererEmitterSettings: RendererEmitterSettings;
+    instancingGeometry?: any;
+    renderMode: number;
+    renderOrder?: number;
+    speedFactor?: number;
+    texture?: string;
+    material?: string;
+    layers?: number;
+    startTileIndex: FunctionJSON | number;
+    uTileCount: number;
+    vTileCount: number;
+    blendTiles?: boolean;
+    softParticles?: boolean;
+    softFarFade?: number;
+    softNearFade?: number;
+    blending?: number;
+    transparent?: boolean;
+    depthTest?: boolean;
+    depthWrite?: boolean;
+    alphaTest?: number;
+    behaviors: Array<any>;
+    worldSpace: boolean;
+}
+interface BabylonMetaData {
+    textures: {
+        [uuid: string]: Texture | null;
+    };
+    materials: {
+        [uuid: string]: any;
+    };
+    geometries: {
+        [uuid: string]: any;
+    };
+    images?: {
+        [uuid: string]: any;
+    };
+    shapes?: {
+        [uuid: string]: any;
+    };
+    skeletons?: {
+        [uuid: string]: any;
+    };
+    animations?: {
+        [uuid: string]: any;
+    };
+    nodes?: {
+        [uuid: string]: any;
+    };
+}
+declare class ParticleSystem implements IParticleSystem {
+    private static serializationCounter;
+    autoDestroy: boolean;
+    prewarm: boolean;
+    looping: boolean;
+    duration: number;
+    startDelay: ValueGenerator | FunctionValueGenerator;
+    startLife: ValueGenerator | FunctionValueGenerator;
+    startSpeed: ValueGenerator | FunctionValueGenerator;
+    startRotation: ValueGenerator | FunctionValueGenerator | RotationGenerator;
+    startSize: ValueGenerator | FunctionValueGenerator | Vector3Generator;
+    startColor: ColorGenerator | FunctionColorGenerator;
+    startTileIndex: ValueGenerator;
+    rendererEmitterSettings: RendererEmitterSettings;
+    emissionOverTime: ValueGenerator | FunctionValueGenerator;
+    emissionOverDistance: ValueGenerator | FunctionValueGenerator;
+    emissionBursts: Array<BurstParameters>;
+    onlyUsedByOther: boolean;
+    worldSpace: boolean;
+    particleNum: number;
+    paused: boolean;
+    particles: Array<Particle>;
+    emitterShape: EmitterShape;
+    emitter: ParticleEmitter;
+    rendererSettings: VFXBatchSettings;
+    neededToUpdateRender: boolean;
+    behaviors: Array<Behavior>;
+    emissionState: EmissionState;
+    emitterVelocity: Vector3;
+    private prewarmed;
+    private emitEnded;
+    private markForDestroy;
+    private startDelayTimeLeft;
+    private previousEmitterPos?;
+    private tempEmitterPos;
+    private temp;
+    private normalMatrix;
+    private memory;
+    private listeners;
+    private readonly layerMaskProxy;
+    private materialRef;
+    private qualityFactor;
+    private useFastTrailHistory;
+    /** @internal **/
+    _renderer?: BatchedRenderer;
+    set time(time: number);
+    get time(): number;
+    get layers(): {
+        mask: number;
+    };
+    get texture(): Texture | null;
+    set texture(texture: Texture | null);
+    get material(): any;
+    set material(material: any);
+    get uTileCount(): number;
+    set uTileCount(u: number);
+    get vTileCount(): number;
+    set vTileCount(v: number);
+    get blendTiles(): boolean;
+    set blendTiles(v: boolean);
+    get softParticles(): boolean;
+    set softParticles(v: boolean);
+    get softNearFade(): number;
+    set softNearFade(v: number);
+    get softFarFade(): number;
+    set softFarFade(v: number);
+    get instancingGeometry(): Float32Array;
+    set instancingGeometry(geometry: Float32Array);
+    get blending(): number;
+    set blending(blending: number);
+    get renderMode(): RenderMode;
+    set renderMode(renderMode: RenderMode);
+    get renderOrder(): number;
+    set renderOrder(renderOrder: number);
+    constructor(parameters: ParticleSystemParameters);
+    private applyMaterialSettings;
+    pause(): void;
+    play(): void;
+    stop(): void;
+    private refreshTrailHistoryMode;
+    private ensureTrailHistoryCapacity;
+    private resetTrailHistory;
+    private getTrailHistoryCount;
+    private updateFastTrailHistory;
+    setQualityFactor(qualityFactor: number): void;
+    private spawn;
+    endEmit(): void;
+    dispose(): void;
+    restart(): void;
+    private firstTimeUpdate;
+    /** @internal */
+    update(delta: number): void;
+    emit(delta: number, emissionState: EmissionState, emitterMatrix: Matrix4): void;
+    toJSON(metaData?: BabylonMetaData | string, _options?: SerializationOptions): ParticleSystemJSONParameters;
+    static fromJSON(json: ParticleSystemJSONParameters, meta: BabylonMetaData, dependencies?: {
+        [uuid: string]: Behavior;
+    }, scene?: Scene): ParticleSystem;
+    private static nextSerializationId;
+    private static createFallbackNormals;
+    private toRendererSettingsJSON;
+    private ensureGeometryMeta;
+    private ensureMaterialMeta;
+    private static resolveGeometryData;
+    addBehavior(behavior: Behavior): void;
+    getRendererSettings(): VFXBatchSettings;
+    addEventListener(event: ParticleSystemEventType, callback: (event: ParticleSystemEvent) => void): void;
+    removeAllEventListeners(event: ParticleSystemEventType): void;
+    removeEventListener(event: ParticleSystemEventType, callback: (event: ParticleSystemEvent) => void): void;
+    private fire;
+    clone(): ParticleSystem;
+}
+
+declare class QuarksUtil {
+    static runOnAllParticleEmitters(root: Node, callback: (emitter: ParticleEmitter) => void): void;
+    static addToBatchRenderer(root: Node, batchRenderer: BatchedRenderer): void;
+    static play(root: Node): void;
+    static stop(root: Node): void;
+    static pause(root: Node): void;
+    static restart(root: Node): void;
+    static setAutoDestroy(root: Node, autoDestroy: boolean): void;
+    static endEmit(root: Node): void;
+    private static traverseNode;
+}
+
+interface QuarksLoaderOptions {
+    baseUrl?: string;
+}
+declare class QuarksLoader {
+    private scene;
+    private options;
+    constructor(scene: Scene, options?: QuarksLoaderOptions);
+    load(url: string): Promise<TransformNode>;
+    parse(json: any, baseUrl?: string): TransformNode;
+    private parseGeometries;
+    private parseSphereGeometry;
+    private parseBufferGeometry;
+    private extractInterleavedAttribute;
+    private int32ArrayToFloat32;
+    private parseImages;
+    private parseTextures;
+    private mapWrapMode;
+    private parseMaterials;
+    private getGeometry;
+    private getMaterial;
+    private createPlaceholderNode;
+    private createMeshNode;
+    private parseObject;
+    private parseParticleSystem;
+    private linkReferences;
+}
+
+interface QuarksTimelineClip {
+    uuid?: string;
+    duration?: number;
+    play?: () => void;
+    pause?: () => void;
+    stop?: () => void;
+    setTime?: (time: number) => void;
+}
+interface AnimationData extends IAnimationData {
+    type: 'three' | 'ps';
+    target: TransformNode;
+    loop: boolean;
+    clip?: QuarksTimelineClip;
+    clipUUID?: string;
+}
+declare class QuarksPrefab extends TransformNode implements IPrefab {
+    type: string;
+    animationData: Array<AnimationData>;
+    isPlaying: boolean;
+    currentTime: number;
+    timeScale: number;
+    duration: number;
+    private _lastUpdateTimeMs;
+    private _batchedRenderer?;
+    private _tempAnimationJSON;
+    constructor(name?: string, scene?: Scene);
+    registerBatchedRenderer(renderer: BatchedRenderer): void;
+    addParticleSystemAnimation(emitter: ParticleEmitter, startTime?: number, duration?: number, loop?: boolean): AnimationData;
+    addThreeAnimation(target: TransformNode, clip?: QuarksTimelineClip, startTime?: number, duration?: number, loop?: boolean, clipUUID?: string): AnimationData;
+    removeAnimation(index: number): void;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    update(forceDelta?: number): void;
+    setTime(time: number): void;
+    getDuration(): number;
+    resolveReferences(root: TransformNode): void;
+    toJSON(): any;
+    static fromJSON(json: any, scene?: Scene): QuarksPrefab;
+    private resolveTimelineClip;
+    private updateDuration;
+}
+
+declare class MeshSurfaceEmitter implements EmitterShape {
+    type: string;
+    private _triangleIndexToArea;
+    private _mesh?;
+    private _positions?;
+    private _indices?;
+    private _meshReferenceId?;
+    get mesh(): Mesh | undefined;
+    set mesh(mesh: Mesh | undefined);
+    constructor(mesh?: Mesh, meshReferenceId?: string);
+    initialize(p: Particle): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): MeshSurfaceEmitter;
+    clone(): EmitterShape;
+    update(_system: IParticleSystem, _delta: number): void;
+}
+declare const MeshSurfaceEmitterPlugin: Plugin;
+
+declare function registerShaderChunks(): void;
+declare function getShaderChunk(chunkName: string): string | undefined;
+declare function getRegisteredShaderChunks(): Readonly<Record<string, string>>;
+
+declare const _default$7: "\n// Per-vertex attributes\nattribute vec3 position;\nattribute vec2 uv;\n\n// Per-instance attributes\nattribute vec3 offset;\nattribute vec4 color;\nattribute vec3 size;\nattribute float rotation;\nattribute float uvTile;\n\n// Uniforms\nuniform mat4 world;\nuniform mat4 view;\nuniform mat4 projection;\nuniform mat4 worldViewProjection;\n\n#ifdef UV_TILE\nuniform float tileCountX;\nuniform float tileCountY;\n#endif\n\n// Varyings\nvarying vec2 vUV;\nvarying vec4 vColor;\n#ifdef TILE_BLEND\nvarying vec2 vUV2;\nvarying float vTileBlend;\n#endif\n#ifdef SOFT_PARTICLES\nvarying vec4 projPosition;\nvarying float linearDepth;\n#endif\n\nvoid main() {\n    float c = cos(rotation);\n    float s = sin(rotation);\n\n    vec2 alignedPosition = position.xy * size.xy;\n    vec2 rotatedPosition;\n    rotatedPosition.x = c * alignedPosition.x - s * alignedPosition.y;\n    rotatedPosition.y = s * alignedPosition.x + c * alignedPosition.y;\n\n#ifdef HORIZONTAL\n    vec4 mvPosition = world * vec4(offset, 1.0);\n    mvPosition.x += rotatedPosition.x;\n    mvPosition.z -= rotatedPosition.y;\n    mvPosition = view * mvPosition;\n#elif defined(VERTICAL)\n    vec4 mvPosition = world * vec4(offset, 1.0);\n    mvPosition.y += rotatedPosition.y;\n    mvPosition = view * mvPosition;\n    mvPosition.x += rotatedPosition.x;\n#else\n    vec4 mvPosition = view * world * vec4(offset, 1.0);\n    mvPosition.xy += rotatedPosition;\n#endif\n\n    gl_Position = projection * mvPosition;\n#ifdef SOFT_PARTICLES\n    projPosition = gl_Position;\n    linearDepth = -mvPosition.z;\n#endif\n\n    #ifdef UV_TILE\n        vec2 tc = vec2(tileCountX, tileCountY);\n        float baseTile = floor(uvTile);\n        float tileU = mod(baseTile, tc.x) / tc.x;\n        float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;\n        vUV = uv / tc + vec2(tileU, tileV);\n        #ifdef TILE_BLEND\n            float nextTile = ceil(uvTile);\n            float nextU = mod(nextTile, tc.x) / tc.x;\n            float nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;\n            vUV2 = uv / tc + vec2(nextU, nextV);\n            vTileBlend = fract(uvTile);\n        #endif\n    #else\n        vUV = uv;\n    #endif\n\n    vColor = color;\n}\n";
+
+declare const _default$6: "\nvarying vec2 vUV;\nvarying vec4 vColor;\n\n#ifdef TILE_BLEND\nvarying vec2 vUV2;\nvarying float vTileBlend;\n#endif\n\n#ifdef USE_MAP\nuniform sampler2D map;\n#endif\n\n#ifdef SOFT_PARTICLES\nuniform sampler2D depthTexture;\nuniform vec2 softParams;\nuniform vec4 projParams;\nvarying vec4 projPosition;\nvarying float linearDepth;\n#endif\n\n#ifdef USE_ALPHATEST\nuniform float alphaTest;\n#endif\n\nvoid main() {\n    vec4 baseColor = vColor;\n\n#ifdef USE_MAP\n    vec4 texColor = texture2D(map, vUV);\n    #ifdef TILE_BLEND\n        vec4 texColor2 = texture2D(map, vUV2);\n        texColor = mix(texColor, texColor2, vTileBlend);\n    #endif\n    baseColor *= texColor;\n#endif\n\n#ifdef USE_COLOR_AS_ALPHA\n    baseColor.a *= (baseColor.r + baseColor.g + baseColor.b) / 3.0;\n#endif\n\n#ifdef USE_ALPHATEST\n    if (baseColor.a < alphaTest) discard;\n#else\n    if (baseColor.a < 0.01) discard;\n#endif\n\n    gl_FragColor = baseColor;\n\n#ifdef SOFT_PARTICLES\n    vec2 p2 = projPosition.xy / projPosition.w;\n    p2 = 0.5 * p2 + 0.5;\n    float readDepth = texture2D(depthTexture, p2.xy).r;\n    float zNear = projParams.x;\n    float zFar = projParams.y;\n    float viewDepth = (zFar * zNear) / (zFar - readDepth * (zFar - zNear));\n    float fade = clamp(softParams.y * ((viewDepth - softParams.x) - linearDepth), 0.0, 1.0);\n    gl_FragColor *= fade;\n#endif\n}\n";
+
+declare const _default$5: "\n// Per-vertex attributes\nattribute vec3 position;\nattribute vec2 uv;\n\n// Per-instance attributes\nattribute vec3 offset;\nattribute vec4 color;\nattribute vec3 size;\nattribute vec4 rotation;\nattribute float uvTile;\n\n// Uniforms\nuniform mat4 worldViewProjection;\n\n#ifdef UV_TILE\nuniform float tileCountX;\nuniform float tileCountY;\n#endif\n\n// Varyings\nvarying vec2 vUV;\nvarying vec4 vColor;\n\nvec3 applyQuaternion(vec3 v, vec4 q) {\n    vec3 qVec = q.xyz;\n    float qW = q.w;\n    vec3 t = 2.0 * cross(qVec, v);\n    return v + qW * t + cross(qVec, t);\n}\n\nvoid main() {\n    vec3 rotatedPosition = applyQuaternion(position * size, rotation);\n    vec3 worldPos = rotatedPosition + offset;\n\n    gl_Position = worldViewProjection * vec4(worldPos, 1.0);\n\n    #ifdef UV_TILE\n        vec2 tc = vec2(tileCountX, tileCountY);\n        float baseTile = floor(uvTile);\n        float tileU = mod(baseTile, tc.x) / tc.x;\n        float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;\n        vUV = uv / tc + vec2(tileU, tileV);\n    #else\n        vUV = uv;\n    #endif\n\n    vColor = color;\n}\n";
+
+declare const _default$4: "\nattribute vec3 position;\nattribute vec2 uv;\nattribute vec3 normal;\nattribute vec3 offset;\nattribute vec4 color;\nattribute vec3 size;\nattribute vec4 rotation;\nattribute float uvTile;\n\nuniform mat4 world;\nuniform mat4 view;\nuniform mat4 projection;\n\n#ifdef UV_TILE\nuniform float tileCountX;\nuniform float tileCountY;\n#endif\n\nvarying vec2 vUV;\nvarying vec4 vColor;\nvarying vec3 vNormal;\nvarying vec3 vWorldPos;\n\n#ifdef TILE_BLEND\nvarying vec2 vUV2;\nvarying float vTileBlend;\n#endif\n\n#ifdef SOFT_PARTICLES\nvarying vec4 projPosition;\nvarying float linearDepth;\n#endif\n\nvec3 applyQuaternion(vec3 v, vec4 q) {\n    vec3 qVec = q.xyz;\n    float qW = q.w;\n    vec3 t = 2.0 * cross(qVec, v);\n    return v + qW * t + cross(qVec, t);\n}\n\nvoid main() {\n    vec3 scaledPosition = position * size;\n    vec3 rotatedPosition = applyQuaternion(scaledPosition, rotation);\n    vec3 rotatedNormal = normalize(applyQuaternion(normal, rotation));\n    vec3 localPos = rotatedPosition + offset;\n\n    vec4 worldPos = world * vec4(localPos, 1.0);\n    vec4 viewPos = view * worldPos;\n    gl_Position = projection * viewPos;\n\n    vWorldPos = worldPos.xyz;\n    vNormal = normalize((world * vec4(rotatedNormal, 0.0)).xyz);\n\n#ifdef SOFT_PARTICLES\n    projPosition = gl_Position;\n    linearDepth = -viewPos.z;\n#endif\n\n#ifdef UV_TILE\n    vec2 tc = vec2(tileCountX, tileCountY);\n    float baseTile = floor(uvTile);\n    float tileU = mod(baseTile, tc.x) / tc.x;\n    float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;\n    vUV = uv / tc + vec2(tileU, tileV);\n    #ifdef TILE_BLEND\n        float nextTile = ceil(uvTile);\n        float nextU = mod(nextTile, tc.x) / tc.x;\n        float nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;\n        vUV2 = uv / tc + vec2(nextU, nextV);\n        vTileBlend = fract(uvTile);\n    #endif\n#else\n    vUV = uv;\n#endif\n\n    vColor = color;\n}\n";
+
+declare const _default$3: "\nvarying vec2 vUV;\nvarying vec4 vColor;\nvarying vec3 vNormal;\n\nuniform vec3 lightDirection;\nuniform vec3 lightColor;\nuniform vec3 ambientColor;\n\n#ifdef TILE_BLEND\nvarying vec2 vUV2;\nvarying float vTileBlend;\n#endif\n\n#ifdef USE_MAP\nuniform sampler2D map;\n#endif\n\n#ifdef SOFT_PARTICLES\nuniform sampler2D depthTexture;\nuniform vec2 softParams;\nuniform vec4 projParams;\nvarying vec4 projPosition;\nvarying float linearDepth;\n#endif\n\n#ifdef USE_ALPHATEST\nuniform float alphaTest;\n#endif\n\nvoid main() {\n    vec4 baseColor = vColor;\n\n#ifdef USE_MAP\n    vec4 texColor = texture2D(map, vUV);\n    #ifdef TILE_BLEND\n        vec4 texColor2 = texture2D(map, vUV2);\n        texColor = mix(texColor, texColor2, vTileBlend);\n    #endif\n    baseColor *= texColor;\n#endif\n\n#ifdef USE_ALPHATEST\n    if (baseColor.a < alphaTest) discard;\n#else\n    if (baseColor.a < 0.01) discard;\n#endif\n\n    vec3 N = normalize(vNormal);\n    vec3 L = normalize(-lightDirection);\n    float NdotL = max(dot(N, L), 0.0);\n    vec3 litColor = ambientColor + lightColor * NdotL;\n\n    gl_FragColor = vec4(baseColor.rgb * litColor, baseColor.a);\n\n#ifdef SOFT_PARTICLES\n    vec2 p2 = projPosition.xy / projPosition.w;\n    p2 = 0.5 * p2 + 0.5;\n    float readDepth = texture2D(depthTexture, p2.xy).r;\n    float zNear = projParams.x;\n    float zFar = projParams.y;\n    float viewDepth = (zFar * zNear) / (zFar - readDepth * (zFar - zNear));\n    float fade = clamp(softParams.y * ((viewDepth - softParams.x) - linearDepth), 0.0, 1.0);\n    gl_FragColor *= fade;\n#endif\n}\n";
+
+declare const _default$2: "\n// Per-vertex attributes\nattribute vec3 position;\nattribute vec2 uv;\n\n// Per-instance attributes\nattribute vec3 offset;\nattribute vec4 color;\nattribute vec3 size;\nattribute float rotation;\nattribute float uvTile;\nattribute vec4 velocity;\n\n// Uniforms\nuniform mat4 world;\nuniform mat4 view;\nuniform mat4 projection;\nuniform float speedFactor;\n\n#ifdef UV_TILE\nuniform float tileCountX;\nuniform float tileCountY;\n#endif\n\n// Varyings\nvarying vec2 vUV;\nvarying vec4 vColor;\n#ifdef TILE_BLEND\nvarying vec2 vUV2;\nvarying float vTileBlend;\n#endif\n#ifdef SOFT_PARTICLES\nvarying vec4 projPosition;\nvarying float linearDepth;\n#endif\n\nvoid main() {\n    float lengthFactor = velocity.w;\n    float avgSize = (size.x + size.y) * 0.5;\n    vec4 mvPosition = view * world * vec4(offset, 1.0);\n    vec3 viewVelocity = mat3(view * world) * velocity.xyz;\n    float vlength = length(viewVelocity);\n    if (vlength < 0.0001) {\n        vlength = 0.0001;\n        viewVelocity = vec3(0.0, 0.0, 1.0);\n    }\n    mvPosition.xyz += position.y * normalize(cross(mvPosition.xyz, viewVelocity)) * avgSize;\n    mvPosition.xyz -= (position.x + 0.5) * viewVelocity * (1.0 + lengthFactor / vlength) * avgSize;\n    gl_Position = projection * mvPosition;\n#ifdef SOFT_PARTICLES\n    projPosition = gl_Position;\n    linearDepth = -mvPosition.z;\n#endif\n\n    #ifdef UV_TILE\n        vec2 tc = vec2(tileCountX, tileCountY);\n        float baseTile = floor(uvTile);\n        float tileU = mod(baseTile, tc.x) / tc.x;\n        float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;\n        vUV = uv / tc + vec2(tileU, tileV);\n        #ifdef TILE_BLEND\n            float nextTile = ceil(uvTile);\n            float nextU = mod(nextTile, tc.x) / tc.x;\n            float nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;\n            vUV2 = uv / tc + vec2(nextU, nextV);\n            vTileBlend = fract(uvTile);\n        #endif\n    #else\n        vUV = uv;\n    #endif\n\n    vColor = color;\n}\n";
+
+declare const _default$1: "\nattribute vec3 position;\nattribute vec3 previous;\nattribute vec3 next;\nattribute float side;\nattribute float width;\nattribute vec2 uv;\nattribute vec4 color;\n\nuniform mat4 view;\nuniform mat4 projection;\nuniform float lineWidth;\nuniform vec2 resolution;\nuniform float sizeAttenuation;\n\nvarying vec2 vUV;\nvarying vec4 vColor;\n\nvec2 fix(vec4 i, float aspect) {\n    vec2 res = i.xy / i.w;\n    res.x *= aspect;\n    return res;\n}\n\nvoid main() {\n    float aspect = resolution.x / resolution.y;\n    vec4 finalPosition = projection * view * vec4(position, 1.0);\n    vec4 prevPos = projection * view * vec4(previous, 1.0);\n    vec4 nextPos = projection * view * vec4(next, 1.0);\n\n    vec2 currentP = fix(finalPosition, aspect);\n    vec2 prevP = fix(prevPos, aspect);\n    vec2 nextP = fix(nextPos, aspect);\n\n    float w = lineWidth * width;\n    vec2 dir;\n    if (distance(nextP, currentP) < 0.0001) {\n        dir = normalize(currentP - prevP);\n    } else if (distance(prevP, currentP) < 0.0001) {\n        dir = normalize(nextP - currentP);\n    } else {\n        vec2 dir1 = normalize(currentP - prevP);\n        vec2 dir2 = normalize(nextP - currentP);\n        dir = normalize(dir1 + dir2);\n    }\n    vec4 normal = vec4(-dir.y, dir.x, 0.0, 1.0);\n    normal.xy *= 0.5 * w;\n    normal *= projection;\n    if (sizeAttenuation == 0.0) {\n        normal.xy *= finalPosition.w;\n        normal.xy /= (vec4(resolution, 0.0, 1.0) * projection).xy;\n    }\n    finalPosition.xy += normal.xy * side;\n    gl_Position = finalPosition;\n    vUV = uv;\n    vColor = color;\n}\n";
+
+declare const _default: "\nvarying vec2 vUV;\nvarying vec4 vColor;\n\n#ifdef USE_MAP\nuniform sampler2D map;\n#endif\n\nvoid main() {\n    vec4 baseColor = vColor;\n\n#ifdef USE_MAP\n    vec4 texColor = texture2D(map, vUV);\n    baseColor *= texColor;\n#endif\n\n    if (baseColor.a < 0.01) discard;\n\n    gl_FragColor = baseColor;\n}\n";
+
+type BabylonParticleMaterialParameters = Record<string, any>;
+declare class ParticleMeshStandardMaterial extends StandardMaterial {
+    readonly isParticleMeshStandardMaterial = true;
+    constructor(name: string, scene?: Scene, parameters?: BabylonParticleMaterialParameters);
+}
+declare class ParticleMeshPhysicsMaterial extends PBRMaterial {
+    readonly isParticleMeshPhysicsMaterial = true;
+    constructor(name: string, scene?: Scene, parameters?: BabylonParticleMaterialParameters);
+}
+
+export { ApplyCollision, ApplyForce, ApplySequences, AxisAngleGenerator, BatchedParticleRenderer, BatchedRenderer, BehaviorFromJSON, BehaviorTypes, Bezier, ChangeEmitDirection, CircleEmitter, ColorBySpeed, ColorGeneratorFromJSON, ColorOverLife, ColorRange, ConeEmitter, ConstantColor, ConstantValue, DEG2RAD, DonutEmitter, EmitSubParticleSystem, EmitterFromJSON, EmitterMode, EmitterShapes, Euler, EulerGenerator, ForceOverLife, FrameOverLife, GeneratorFromJSON, Gradient, GravityForce, GridEmitter, HemisphereEmitter, InheritVelocity, IntervalValue, LimitSpeedOverLife, MathUtils, Matrix3, Matrix4, MeshSurfaceEmitter, MeshSurfaceEmitterPlugin, NodeParticle, Noise, OrbitOverLife, ParticleEmitter, ParticleMeshPhysicsMaterial, ParticleMeshStandardMaterial, ParticleSystem, PiecewiseBezier, PiecewiseFunction, Plugins, PointEmitter, QuarksLoader, QuarksPrefab, QuarksUtil, Quaternion, RAD2DEG, RandomColor, RandomColorBetweenGradient, RandomQuatGenerator, RecordState, RectangleEmitter, RenderMode, Rotation3DOverLife, RotationBySpeed, RotationGeneratorFromJSON, RotationOverLife, SequencerFromJSON, SizeBySpeed, SizeOverLife, SpeedOverLife, SphereEmitter, SpriteBatch, SpriteParticle, SubParticleEmitMode, TextureSequencer, TrailBatch, TrailParticle, TurbulenceField, VFXBatch, ValueGeneratorFromJSON, Vector2, Vector3, Vector3Function, Vector3GeneratorFromJSON, Vector4, VelocityOverLife, WebGLCoordinateSystem, WebGPUCoordinateSystem, WidthOverLength, ceilPowerOfTwo, clamp, damp, degToRad, denormalize, euclideanModulo, floorPowerOfTwo, generateUUID, getPhysicsResolver, getRegisteredShaderChunks, getShaderChunk, getValueFromEmitterMode, inverseLerp, isPowerOfTwo, lerp, loadPlugin, _default$4 as localParticlePhysicsVertShader, _default$5 as localParticleVertShader, mapLinear, normalize, _default$6 as particleFragShader, _default$3 as particlePhysicsFragShader, _default$7 as particleVertShader, pingpong, radToDeg, randFloat, randFloatSpread, randInt, registerShaderChunks, seededRandom, setPhysicsResolver, setQuaternionFromProperEuler, smootherstep, smoothstep, _default$2 as stretchedBillboardVertShader, _default as trailFragShader, _default$1 as trailVertShader, unloadPlugin };
+export type { AdaptivePerformanceOptions, AdaptivePerformanceState, AnimationData, BabylonMetaData, BabylonParticleMaterialParameters, Behavior, BehaviorPlugin, BillBoardSettings, BurstParameters, BurstParametersJSON, CircleEmitterParameters, ColorGenerator, ConeEmitterParameters, Constructable, DonutEmitterParameters, EmissionState, EmitterShape, EmitterShapePlugin, EulerOrder, FieldType, FunctionColorGenerator, FunctionJSON, FunctionValueGenerator, GeneratorMemory, GridEmitterParameters, HemisphereEmitterParameters, IAnimationData, IEmitter, IParticle, IParticleSystem, IPrefab, InheritVelocityMode, JsonMetaData, MeshSettings, ParameterPair, ParameterType, Particle, ParticleSystemEvent, ParticleSystemEventType, ParticleSystemJSONParameters, ParticleSystemParameters, Plugin, QuarksLoaderOptions, QuarksTimelineClip, RectangleEmitterParameters, RendererEmitterSettings, Resource, RotationGenerator, Sequencer, SerializationOptions, ShapeJSON, SphereEmitterParameters, StoredBatchSettings, StretchedBillBoardSettings, TrailSettings, VFXBatchSettings, ValueGenerator, Vector3Generator, VelocityOverLifeSpace };