babylon.quarks 0.18.1 → 0.20.0

package/dist/types/index.d.ts

@@ -1,70 +1,11 @@
+import { BaseTexture } from '@babylonjs/core/Materials/Textures/baseTexture';
+import { Texture } from '@babylonjs/core/Materials/Textures/texture';
 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[];
-}
+import { Node } from '@babylonjs/core/node';
 
 declare class Vector2 {
     x: number;
@@ -127,41 +68,59 @@ declare class Vector2 {
     [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;
+declare class Quaternion {
+    _x: number;
+    _y: number;
+    _z: number;
+    _w: number;
+    readonly 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;
-    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;
+    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[];
-    clone(): Matrix3;
+    toJSON(): number[];
+    _onChange(callback: () => void): this;
+    _onChangeCallback(): void;
+    [Symbol.iterator](): Generator<number, void, unknown>;
 }
 
 declare class Vector3 {
     x: number;
     y: number;
     z: number;
-    readonly isVector3 = true;
+    readonly isVector3: boolean;
     constructor(x?: number, y?: number, z?: number);
     set(x: number, y: number, z: number): this;
     setScalar(scalar: number): this;
@@ -234,52 +193,94 @@ declare class Vector3 {
     [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;
+declare class Matrix3 {
+    elements: number[];
+    readonly isMatrix3: boolean;
+    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;
-    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;
+    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 const WebGLCoordinateSystem = 2000;
+declare const WebGPUCoordinateSystem = 2001;
+declare class Matrix4 {
+    elements: number[];
+    readonly isMatrix4: boolean;
+    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[];
-    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';
@@ -288,7 +289,7 @@ declare class Euler {
     _y: number;
     _z: number;
     _order: EulerOrder;
-    isEuler: boolean;
+    readonly isEuler: boolean;
     static DEFAULT_ORDER: EulerOrder;
     constructor(x?: number, y?: number, z?: number, order?: EulerOrder);
     get x(): number;
@@ -314,11 +315,87 @@ declare class Euler {
     [Symbol.iterator](): Generator<number | EulerOrder, void, unknown>;
 }
 
-declare class Vector4 {
-    x: number;
-    y: number;
-    z: number;
+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;
+};
+
+/**
+ * A `Vector3` whose components live in a shared `Float32Array` at a fixed
+ * offset rather than in three own properties.
+ *
+ * Every `Vector3` method routes through `x` / `y` / `z`, so replacing those
+ * with accessors inherits the whole API unchanged — including `clone()`, which
+ * still returns a detached plain `Vector3`.
+ *
+ * The accessors are installed on the prototype below rather than written as
+ * `get x()` in the class body, because TypeScript forbids overriding an
+ * inherited property with an accessor (TS2611). Runtime behaviour is the same:
+ * one shared property descriptor for every instance.
+ */
+declare class Vector3View extends Vector3 {
+    data: Float32Array;
+    offset: number;
+    x: number;
+    y: number;
+    z: number;
+    constructor(data: Float32Array, offset: number);
+    /** Points the view at a new backing array and row offset. */
+    bind(data: Float32Array, offset: number): void;
+}
+
+declare class Vector4 {
+    x: number;
+    y: number;
+    z: number;
     w: number;
+    readonly isVector4: boolean;
     constructor(x?: number, y?: number, z?: number, w?: number);
     get width(): number;
     set width(value: number);
@@ -372,83 +449,22 @@ declare class Vector4 {
     [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;
+/**
+ * A `Vector4` backed by a shared `Float32Array` at a fixed offset. Replacing
+ * the four component accessors inherits every `Vector4` method as-is; they are
+ * installed on the prototype because TypeScript forbids overriding an
+ * inherited property with an accessor in the class body (TS2611).
+ */
+declare class Vector4View extends Vector4 {
+    data: Float32Array;
+    offset: number;
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(data: Float32Array, offset: number);
+    /** Points the view at a new backing array and row offset. */
+    bind(data: Float32Array, offset: number): void;
 }
 
 type FunctionJSON = {
@@ -504,16 +520,83 @@ type FunctionJSON = {
  */
 type GeneratorMemory = any[];
 
-declare class RandomColor implements ColorGenerator {
-    a: Vector4;
-    b: Vector4;
-    constructor(a: Vector4, b: Vector4);
+interface RotationGenerator {
+    type: 'rotation';
     startGen(memory: GeneratorMemory): void;
-    genColor(memory: GeneratorMemory, color: Vector4): Vector4;
+    genValue(memory: GeneratorMemory, q: Quaternion, delta: number, t: number): Quaternion;
+    toJSON(): FunctionJSON;
+    clone(): RotationGenerator;
+}
+declare function RotationGeneratorFromJSON(json: FunctionJSON): RotationGenerator;
+
+/**
+ * `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;
+    /** See FunctionValueGenerator.refreshTable. */
+    refreshTable?(): void;
     toJSON(): FunctionJSON;
-    static fromJSON(json: FunctionJSON): RandomColor;
-    clone(): ColorGenerator;
+    clone(): ValueGenerator;
+}
+interface FunctionValueGenerator {
+    type: 'function';
+    startGen(memory: GeneratorMemory): void;
+    genValue(memory: GeneratorMemory, t: number): number;
+    /**
+     * Optional hook for generators that can precompute a sampled table of
+     * themselves. Called once per frame by behaviors that evaluate the
+     * generator per particle, before any genValue of that frame, so a curve
+     * edited between frames is picked up.
+     */
+    refreshTable?(): void;
+    toJSON(): FunctionJSON;
+    clone(): FunctionValueGenerator;
+}
+declare function ValueGeneratorFromJSON(json: FunctionJSON): FunctionValueGenerator | ValueGenerator;
+
+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 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;
 }
 
 declare class ColorRange implements ColorGenerator {
@@ -553,13 +636,41 @@ declare class Gradient implements FunctionColorGenerator {
     color: ContinuousLinearFunction<Vector3>;
     alpha: ContinuousLinearFunction<number>;
     constructor(color?: Array<[Vector3, number]>, alpha?: Array<[number, number]>);
+    /** Sample count of the tables built by {@link refreshTable}. */
+    static readonly TABLE_SIZE = 257;
+    /** Sampled RGBA copy of the gradient, or null while none has been built. */
+    private table;
+    /** Keys the tables were built from, used to detect edits. Float64 for the same reason as PiecewiseBezier's. */
+    private tableSignature;
+    /**
+     * Rebuilds the sampled table when the gradient changed, otherwise does
+     * nothing. See PiecewiseBezier.refreshTable — same reasoning, and the same
+     * signature check so a gradient edited in an editor is picked up.
+     */
+    refreshTable(): void;
+    /** Drops the sampled table, so later reads go back to evaluating the keys. */
+    clearTable(): void;
     genColor(memory: GeneratorMemory, color: Vector4, t: number): Vector4;
+    /** Evaluates the gradient keys themselves, ignoring any sampled table. */
+    genColorExact(color: Vector4, t: number): Vector4;
     toJSON(): FunctionJSON;
     static fromJSON(json: FunctionJSON): Gradient;
     clone(): FunctionColorGenerator;
     startGen(memory: GeneratorMemory): void;
 }
 
+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 RandomColorBetweenGradient implements FunctionColorGenerator {
     gradient1: Gradient;
     gradient2: Gradient;
@@ -584,6 +695,8 @@ interface FunctionColorGenerator {
     type: 'function';
     startGen(memory: GeneratorMemory): void;
     genColor(memory: GeneratorMemory, color: Vector4, t: number): Vector4;
+    /** See FunctionValueGenerator.refreshTable. */
+    refreshTable?(): void;
     toJSON(): FunctionJSON;
     clone(): FunctionColorGenerator;
 }
@@ -597,28 +710,7 @@ declare class ConstantColor implements ColorGenerator {
     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 function ColorGeneratorFromJSON(json: FunctionJSON): ColorRange | Gradient | RandomColor | RandomColorBetweenGradient | ConstantColor;
 
 declare class ConstantValue implements ValueGenerator {
     value: number;
@@ -631,8 +723,35 @@ declare class ConstantValue implements ValueGenerator {
     clone(): ValueGenerator;
 }
 
-declare class IntervalValue implements ValueGenerator {
-    a: number;
+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;
+    /** See FunctionValueGenerator.refreshTable. */
+    refreshTable?(): void;
+    toJSON(): FunctionJSON;
+    clone(): Vector3Generator;
+}
+declare function Vector3GeneratorFromJSON(json: FunctionJSON): Vector3Generator;
+
+declare function GeneratorFromJSON(json: FunctionJSON): FunctionValueGenerator | ValueGenerator | RotationGenerator | Vector3Generator;
+
+declare class IntervalValue implements ValueGenerator {
+    a: number;
     b: number;
     constructor(a: number, b: number);
     indexCount: number;
@@ -660,8 +779,40 @@ declare abstract class PiecewiseFunction<T> {
 }
 
 declare class PiecewiseBezier extends PiecewiseFunction<Bezier> implements FunctionValueGenerator {
+    /** Sample count of the table built by {@link refreshTable}. */
+    static readonly TABLE_SIZE = 257;
     constructor(curves?: Array<[Bezier, number]>);
+    /**
+     * Sampled copy of the curve, or null while none has been built.
+     * See {@link refreshTable}.
+     */
+    private table;
+    /**
+     * Control points the table was built from, used to detect edits. Float64 on purpose: the
+     * points are doubles, and a Float32Array rounds most of them (0.2, almost any exported value),
+     * so the comparison never matched and the table was resampled on every call.
+     */
+    private tableSignature;
+    /**
+     * Rebuilds the sampled table when the curve changed, otherwise does nothing.
+     *
+     * Evaluating this curve means a piece lookup plus a cubic; a particle system
+     * does that once per particle per frame. Sampling it once and interpolating
+     * costs two loads and a lerp instead. Sampling error at
+     * {@link PiecewiseBezier.TABLE_SIZE} points stays around 1e-5 for the shapes
+     * a curve editor produces — far below what a colour or a size can show.
+     *
+     * The curve is public and mutable (a curve editor writes straight into
+     * `functions` and a Bezier's `p`), so this compares the control points
+     * against the ones the table was built from and only resamples on a real
+     * change. That is a handful of float compares per frame.
+     */
+    refreshTable(): void;
+    /** Drops the sampled table, so later reads go back to evaluating the curve. */
+    clearTable(): void;
     genValue(memory: GeneratorMemory, t?: number): number;
+    /** Evaluates the curve itself, ignoring any sampled table. */
+    genValueExact(t: number): number;
     toSVG(length: number, segments: number): string;
     type: 'function';
     toJSON(): FunctionJSON;
@@ -670,15 +821,6 @@ declare class PiecewiseBezier extends PiecewiseFunction<Bezier> implements Funct
     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();
@@ -690,41 +832,6 @@ declare class RandomQuatGenerator implements 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;
@@ -738,7 +845,103 @@ declare class Vector3Function implements Vector3Generator {
     clone(): Vector3Generator;
 }
 
-declare function GeneratorFromJSON(json: FunctionJSON): FunctionValueGenerator | ValueGenerator | RotationGenerator | Vector3Generator;
+/**
+ * Column storage for the vector-valued particle attributes.
+ *
+ * The three-component and four-component fields of a particle used to be six
+ * separate objects per particle, so walking a system meant chasing pointers
+ * across the heap. Here each attribute is one flat `Float32Array` shared by
+ * every particle in a system, and a particle holds views into its own row. The
+ * numbers a simulation step touches are then contiguous and prefetchable, while
+ * `particle.position.x` keeps working exactly as before.
+ *
+ * Scalar attributes (age, life, rotation, …) stay as plain properties on the
+ * particle: a monomorphic own property is already a single load, so moving them
+ * here would add an indirection rather than remove one.
+ */
+declare class ParticleStore {
+    private static readonly EMPTY;
+    /** Number of particle rows the arrays can hold. */
+    capacity: number;
+    position: Float32Array;
+    /**
+     * Where each particle was when the current simulation step began.
+     *
+     * The step is fixed while frames are not, so a frame is usually drawn some
+     * way past the last step. The renderer closes that gap by continuing the
+     * motion the last step produced — and the only way to know that motion for
+     * every kind of behavior, not just the ones that move a particle by its
+     * velocity, is to have kept where it started.
+     */
+    previousPosition: Float32Array;
+    /**
+     * Size and colour at the start of the current step, for the same reason as
+     * {@link previousPosition}. These are read off a curve at `age / life`
+     * rather than integrated, and at the lifetimes an explosion uses — a fifth
+     * of a second, a dozen steps in total — a whole step of fade lands on one
+     * frame and none on the next.
+     */
+    previousSize: Float32Array;
+    previousColor: Float32Array;
+    /**
+     * Velocity at the start of the current step. A stretched billboard's shape
+     * is its velocity — the streak points along it and is as long as it — so a
+     * velocity that only changes on steps makes the sprite's outline pop at the
+     * step rate even while its position moves smoothly.
+     *
+     * Empty until {@link keepPreviousVelocity} asks for it, because only that
+     * one render mode reads it and an unused column is not free: it sits
+     * between the columns that are hot and costs them their locality.
+     */
+    previousVelocity: Float32Array;
+    velocity: Float32Array;
+    size: Float32Array;
+    startSize: Float32Array;
+    color: Float32Array;
+    startColor: Float32Array;
+    /**
+     * age, life and speedModifier interleaved, {@link SCALAR_STRIDE} per row.
+     *
+     * Double precision, unlike the vector columns: age accumulates `+= delta`
+     * for the particle's whole life and is compared against life to decide
+     * death, so rounding it to float32 shifts when particles die and makes
+     * tightly balanced emitters flicker.
+     */
+    scalars: Float64Array;
+    /** Values per row in {@link scalars}. */
+    static readonly SCALAR_STRIDE = 3;
+    /** Offsets within a {@link scalars} row. */
+    static readonly AGE = 0;
+    static readonly LIFE = 1;
+    static readonly SPEED_MODIFIER = 2;
+    constructor(capacity?: number);
+    /**
+     * Grows the arrays so `count` rows fit, preserving the existing contents.
+     *
+     * @param count - Number of rows that must be addressable.
+     * @returns `true` when the arrays were replaced, meaning every particle
+     * bound to this store has to be re-bound.
+     */
+    ensureCapacity(count: number): boolean;
+    /**
+     * Exchanges the contents of two rows.
+     *
+     * Used to keep row order aligned with the owning system's particle order, so
+     * the live particles stay a contiguous range that a renderer can copy in one
+     * go rather than gathering particle by particle.
+     */
+    /**
+     * Starts keeping {@link previousVelocity}. Harmless to call every step;
+     * returns true on the call that allocated, which replaces the array and so
+     * leaves every particle's view of it pointing at the old one.
+     */
+    keepPreviousVelocity(): boolean;
+    swapRows(a: number, b: number): void;
+    private static growDouble;
+    private static swap3;
+    private static swap4;
+    private static grow;
+}
 
 interface EmissionState {
     burstIndex: number;
@@ -794,6 +997,31 @@ interface TrailSettings {
      * @type {boolean}
      */
     followLocalOrigin: boolean;
+    /**
+     * Run the texture's U from the particle (0) back to the tail (1), the way
+     * Unity's stretched trails map it. Off, U runs from the tail to the particle.
+     * @type {boolean}
+     */
+    uvFromHead?: boolean;
+    /**
+     * Draw the whole trail in the particle's current color, as Unity's trails
+     * do, instead of the color each sample had when it was recorded.
+     * @type {boolean}
+     */
+    colorFromParticle?: boolean;
+    /**
+     * Drop the trail the moment its particle dies, instead of letting it
+     * shrink away one sample per step.
+     * @type {boolean}
+     */
+    dieWithParticle?: boolean;
+    /**
+     * Record trail points in world space even though the system simulates in
+     * local space, so the trail streaks behind a moving emitter instead of
+     * moving rigidly with it (Unity's Trails > World Space).
+     * @type {boolean}
+     */
+    recordWorldSpace?: boolean;
 }
 interface MeshSettings {
     /**
@@ -823,13 +1051,44 @@ interface IEmitter {
     visible: boolean;
     matrixWorld: any;
 }
-type ParticleSystemEventType = "emitEnd" | "finished" | "destroy" | "particleDied";
+type ParticleSystemEventType = 'emitEnd' | 'finished' | 'destroy' | 'particleDied';
 interface ParticleSystemEvent {
     type: ParticleSystemEventType;
     particleSystem: IParticleSystem;
     particle?: IParticle;
 }
 interface IParticleSystem {
+    /**
+     * Column storage backing the particles' vector attributes, when the
+     * implementation uses one. Rows `[0, particleNum)` hold the live particles
+     * in the same order as `particles`, so a renderer can read them as ranges.
+     * @type {ParticleStore}
+     */
+    store?: ParticleStore;
+    /**
+     * Wall-clock time that has passed since the last simulated step, in
+     * seconds, when the implementation simulates on a fixed timestep. Negative
+     * when that step ran a hair ahead of real time instead (rounded to the
+     * nearest step rather than floored, so this stays small either way). A
+     * renderer uses it to draw where the particles are now rather than where
+     * the last step left them.
+     * @type {number}
+     */
+    simulationResidual?: number;
+    /**
+     * Length of one simulation step, in seconds, when the implementation
+     * simulates on a fixed timestep. Turning is recorded per step rather than
+     * per second, so a renderer needs this to know what fraction of a step
+     * {@link simulationResidual} is.
+     * @type {number}
+     */
+    simulationStep?: number;
+    /**
+     * Whether this system only emits through another system, which is when its
+     * particles carry their own parent transform.
+     * @type {boolean}
+     */
+    onlyUsedByOther?: boolean;
     /**
      * Whether the ParticleSystem should be automatically disposed when it finishes emitting particles.
      * @type {string}
@@ -875,6 +1134,12 @@ interface IParticleSystem {
      * @type {BatchedRenderer}
      */
     rendererEmitterSettings: RendererEmitterSettings;
+    /**
+     * Fraction of billboard particles mirrored along U (x) and V (y), each
+     * picked at random when the particle is born — Unity's renderer Flip.
+     * Absent: nothing is mirrored.
+     */
+    flip?: Vector2;
     emissionState: EmissionState;
     paused: boolean;
     /** True after `endEmit()` — emission window closed (non-looping duration elapsed). */
@@ -989,6 +1254,30 @@ interface IParticle {
     get died(): boolean;
 }
 interface Particle extends IParticle {
+    /**
+     * Where the particle was when the current simulation step began, when the
+     * implementation keeps it. A renderer draws between fixed steps and uses
+     * this to continue the motion the last step produced, whatever produced it.
+     * @type {Vector3}
+     */
+    previousPosition?: Vector3;
+    /**
+     * Velocity at the start of the current step, when the implementation keeps
+     * it. A stretched billboard is drawn from its velocity, so a renderer needs
+     * this to keep the sprite's shape moving between steps as its position does.
+     * @type {Vector3}
+     */
+    previousVelocity?: Vector3;
+    /**
+     * How fast the particle is turning, as the behavior that turns it last left
+     * it: a rate in radians per second for a particle that rotates by an angle,
+     * or one simulation step's turn for one that rotates by quaternion.
+     *
+     * Written by the turning behaviors and read by the renderer, which draws
+     * between simulation steps and has no other way to continue the turn.
+     * @type {number | Quaternion}
+     */
+    angularVelocity?: number | Quaternion;
     /**
      * Speed modifier of the particle.
      * @type {number}
@@ -1085,6 +1374,10 @@ declare class NodeParticle implements IParticle {
  * Particle implementation for sprite-based particle.
  */
 declare class SpriteParticle implements Particle {
+    /** Column storage backing this particle's vector attributes. */
+    readonly store: ParticleStore;
+    /** Row this particle occupies in {@link store}. */
+    storeIndex: number;
     /**
      * Parent matrix for transformation.
      * @type {Matrix4}
@@ -1110,31 +1403,49 @@ declare class SpriteParticle implements Particle {
      * @type {Vector3}
      */
     position: Vector3;
+    /**
+     * Where this particle was when the current simulation step began; see
+     * {@link Particle.previousPosition}.
+     * @type {Vector3}
+     */
+    previousPosition: Vector3;
+    /**
+     * Velocity at the start of the current step; see
+     * {@link Particle.previousVelocity}.
+     * @type {Vector3}
+     */
+    previousVelocity: Vector3;
     /**
      * Velocity of the particle.
      * @type {Vector3}
      */
     velocity: Vector3;
+    /**
+     * Size of the particle.
+     * @type {Vector3}
+     */
+    size: Vector3;
+    /** Row of the store's interleaved scalars this particle owns. */
+    protected scalars: Float64Array;
+    protected scalarOffset: number;
     /**
      * Age of the particle.
      * @type {number}
      */
-    age: number;
+    get age(): number;
+    set age(value: number);
     /**
      * Life duration of the particle.
      * @type {number}
      */
-    life: number;
-    /**
-     * Size of the particle.
-     * @type {Vector3}
-     */
-    size: Vector3;
+    get life(): number;
+    set life(value: number);
     /**
      * Speed modifier of the particle.
      * @type {number}
      */
-    speedModifier: number;
+    get speedModifier(): number;
+    set speedModifier(value: number);
     /**
      * Angular velocity of the particle.
      * @type {number | Quaternion}
@@ -1155,6 +1466,25 @@ declare class SpriteParticle implements Particle {
      * @type {number}
      */
     uvTile: number;
+    /**
+     * Mirroring picked at birth from the system's `flip` fractions: bit 1
+     * mirrors the sprite along U, bit 2 along V. 0 draws it as is.
+     * @type {number}
+     */
+    flip: number;
+    /**
+     * @param store - Column storage to bind to. A private single-row store is
+     * created when omitted, so a standalone `new SpriteParticle()` still works.
+     * @param storeIndex - Row this particle owns.
+     */
+    constructor(store?: ParticleStore, storeIndex?: number);
+    /**
+     * Moves this particle onto a different store row. The caller is responsible
+     * for having moved the row contents too.
+     */
+    setStoreIndex(index: number): void;
+    /** Re-points the vector views after the store grew its arrays. */
+    rebind(): void;
     /**
      * Indicates if the particle has died.
      * @type {boolean}
@@ -1179,6 +1509,10 @@ declare class RecordState {
  * Particle implementation for trail-based particles.
  */
 declare class TrailParticle implements Particle {
+    /** Column storage backing this particle's vector attributes. */
+    readonly store: ParticleStore;
+    /** Row this particle occupies in {@link store}. */
+    storeIndex: number;
     /**
      * Parent matrix for transformation.
      * @type {Matrix4}
@@ -1204,6 +1538,18 @@ declare class TrailParticle implements Particle {
      * @type {Vector3}
      */
     position: Vector3;
+    /**
+     * Where this particle was when the current simulation step began; see
+     * {@link Particle.previousPosition}.
+     * @type {Vector3}
+     */
+    previousPosition: Vector3;
+    /**
+     * Velocity at the start of the current step; see
+     * {@link Particle.previousVelocity}.
+     * @type {Vector3}
+     */
+    previousVelocity: Vector3;
     /**
      * Local position of the particle.
      * @type {Vector3}
@@ -1214,31 +1560,37 @@ declare class TrailParticle implements Particle {
      * @type {Vector3}
      */
     velocity: Vector3;
+    /**
+     * Size of the particle.
+     * @type {Vector3}
+     */
+    size: Vector3;
+    /** Row of the store's interleaved scalars this particle owns. */
+    protected scalars: Float64Array;
+    protected scalarOffset: number;
     /**
      * Age of the particle.
      * @type {number}
      */
-    age: number;
+    get age(): number;
+    set age(value: number);
     /**
      * Life duration of the particle.
      * @type {number}
      */
-    life: number;
+    get life(): number;
+    set life(value: number);
     /**
-     * Size of the particle.
-     * @type {Vector3}
+     * Speed modifier of the particle.
+     * @type {number}
      */
-    size: Vector3;
+    get speedModifier(): number;
+    set speedModifier(value: number);
     /**
      * Length of the trail.
      * @type {number}
      */
     length: number;
-    /**
-     * Speed modifier of the particle.
-     * @type {number}
-     */
-    speedModifier: number;
     /**
      * Color of the particle.
      * @type {Vector4}
@@ -1246,6 +1598,10 @@ declare class TrailParticle implements Particle {
     color: Vector4;
     /**
      * Previous states of the particle.
+     *
+     * @deprecated The trail history now lives in the flat ring buffer below
+     * (`historyPositions` / `historySizes` / `historyColors`), which records a
+     * sample without allocating. This list is no longer populated or rendered.
      * @type {LinkedList<RecordState>}
      */
     previous: LinkedList<RecordState>;
@@ -1254,8 +1610,46 @@ declare class TrailParticle implements Particle {
      * @type {number}
      */
     uvTile: number;
+    /** Ring buffer of recorded positions, 3 floats per sample. */
+    historyPositions: Float32Array;
+    /** Ring buffer of recorded widths, 1 float per sample. */
+    historySizes: Float32Array;
+    /** Ring buffer of recorded colors, 4 floats per sample. */
+    historyColors: Float32Array;
+    /** Number of samples the ring buffers can hold. */
+    historyCapacity: number;
+    /** Slot the next sample is written to. */
+    historyHead: number;
+    /** Number of valid samples currently held. */
+    historyCount: number;
+    /**
+     * @param store - Column storage to bind to. A private single-row store is
+     * created when omitted, so a standalone `new TrailParticle()` still works.
+     * @param storeIndex - Row this particle owns.
+     */
+    constructor(store?: ParticleStore, storeIndex?: number);
     /**
-     * Updates the particle state.
+     * Moves this particle onto a different store row. The caller is responsible
+     * for having moved the row contents too.
+     */
+    setStoreIndex(index: number): void;
+    /** Re-points the vector views after the store grew its arrays. */
+    rebind(): void;
+    /**
+     * Allocates the trail ring buffers, reusing them when the capacity is unchanged.
+     * @param {number} capacity - Number of samples to hold.
+     */
+    ensureHistoryCapacity(capacity: number): void;
+    /** Drops every recorded sample without releasing the buffers. */
+    resetHistory(): void;
+    /**
+     * Ring buffer slot of the i-th sample counting from the oldest one.
+     * @param {number} i - Sample offset, `0` being the oldest live sample.
+     */
+    getHistoryIndex(i: number): number;
+    /**
+     * Records the current state into the trail ring buffer, or retires the
+     * oldest sample once the particle is dead. Allocation free.
      */
     update(): void;
     /**
@@ -1270,494 +1664,390 @@ declare class TrailParticle implements Particle {
     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;
+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>];
+
 /**
- * Enum representing the emitter modes for particles.
+ * Interface for particle behaviors.
+ * a behavior is a function that modifies a particle's properties over time.
  */
-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,
+interface Behavior {
+    type: string;
+    initialize(particle: Particle, particleSystem: IParticleSystem): void;
+    update(particle: Particle, delta: number): void;
     /**
-     * Emit particles in bursts.
+     * Optional bulk form of {@link update}, applied to `particles[0..count)`.
+     *
+     * The per-particle `update` is reached through one call site shared by every
+     * behavior type, which leaves it megamorphic: V8 can neither inline it nor
+     * specialise the generator calls inside. A behavior that implements this
+     * instead gets one call per frame and a loop it owns, where those calls are
+     * monomorphic. Implementations must skip dead particles exactly as the
+     * per-particle path does, and must produce identical results.
+     *
+     * Behaviors that do not implement it keep working unchanged.
      */
-    Burst = 3
+    updateAll?(particles: Array<Particle>, count: number, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    clone(): Behavior;
+    reset(): void;
 }
-declare function getValueFromEmitterMode(mode: EmitterMode, currentValue: number, spread: number, emissionState: EmissionState): number;
-interface EmitterShape {
+interface BehaviorPlugin {
     type: string;
-    initialize(particle: Particle, emissionState: EmissionState): void;
-    toJSON(): ShapeJSON;
-    update(system: IParticleSystem, delta: number): void;
-    clone(): EmitterShape;
+    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;
 
-/**
- * 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 PhysicsResolver {
+    resolve(pos: Vector3, normal: Vector3): boolean;
 }
-
+declare function setPhysicsResolver(resolver: PhysicsResolver): void;
+declare function getPhysicsResolver(): PhysicsResolver;
 /**
- * Interface representing the parameters for a circle emitter.
+ * Apply collision to particles from a physics resolver.
  */
-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;
+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;
 }
+
 /**
- * a particle emitter that emits particles from a circle.
+ * Apply a global force to particles.
  */
-declare class CircleEmitter implements EmitterShape {
+declare class ApplyForce implements Behavior {
+    direction: Vector3;
+    magnitude: ValueGenerator;
     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;
+    magnitudeValue: number;
+    memory: {
+        data: never[];
+        dataCount: number;
+    };
+    constructor(direction: Vector3, magnitude: ValueGenerator);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    updateAll(particles: Array<Particle>, count: number, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    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;
 
 /**
- * Interface representing the parameters for a donut emitter.
+ * Apply sequences to particles.
+ * {@link Sequencer}
  */
-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 {
+declare class ApplySequences implements Behavior {
+    static BEZIER: Bezier;
     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;
+    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;
 }
 
 /**
- * A point emitter emits particles from a single point.
+ * Compiles a run of behaviors into a single loop over the particles.
+ *
+ * Each behavior walking the particle array on its own means the array, and
+ * every particle in it, is re-read once per behavior. Merging the ones this
+ * module recognises into one pass reads each particle once — worth roughly
+ * 1.2x at a hundred thousand particles and up to 1.6x at twenty thousand,
+ * where the per-pass overhead weighs most.
+ *
+ * A behavior that is not recognised keeps its own pass, in its original place
+ * in the order, so nothing here depends on the built-in set being complete.
  */
-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;
+/** Runs the compiled work for `particles[0..count)`. */
+type FusedPass = (behaviors: Array<Behavior>, particles: Array<Particle>, count: number, delta: number) => void;
+/** One step of a plan: either a compiled run of behaviors, or a single behavior. */
+interface FusionStep {
+    /** Behaviors this step covers, in order. */
+    behaviors: Array<Behavior>;
+    /** Compiled pass, or undefined when the behavior runs its own update. */
+    run?: FusedPass;
 }
+/**
+ * Splits `behaviors` into steps, merging consecutive recognised ones.
+ *
+ * Only consecutive behaviors are merged: a behavior that stays on its own must
+ * still see the particles exactly where the original order left them.
+ */
+declare function planBehaviorFusion(behaviors: Array<Behavior>): Array<FusionStep>;
 
 /**
- * Interface representing the parameters for a sphere emitter.
+ * Change the emit direction of particles.
  */
-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 {
+declare class ChangeEmitDirection implements Behavior {
+    angle: ValueGenerator;
     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;
+    _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;
 }
 
 /**
- * Interface representing the parameters for a hemisphere emitter.
+ * Color particles by their speed.
  */
-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 {
+declare class ColorBySpeed implements Behavior {
+    color: FunctionColorGenerator;
+    speedRange: IntervalValue;
     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;
+    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;
 }
 
 /**
- * Interface representing the parameters for a grid emitter.
+ * Color particles by their life.
  */
-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 {
+declare class ColorOverLife implements Behavior {
+    color: FunctionColorGenerator;
     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;
+    constructor(color: FunctionColorGenerator);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    updateAll(particles: Array<Particle>, count: number, delta: number): void;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): 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;
+declare enum SubParticleEmitMode {
+    Death = 0,
+    Birth = 1,
+    Frame = 2
 }
 /**
- * a particle emitter that emits particles from a rectangle.
+ * Emit a sub particle system from particles.
  */
-declare class RectangleEmitter implements EmitterShape {
+declare class EmitSubParticleSystem implements Behavior {
+    private particleSystem;
+    useVelocityAsBasis: boolean;
+    subParticleSystem: IEmitter | undefined;
+    mode: SubParticleEmitMode;
+    emitProbability: number;
     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;
+    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;
 }
 
-interface Constructable<T> {
-    new (...args: any): T;
+/**
+ * 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;
+    /** Learned in {@link initialize}, so undefined until this behavior sees a particle. */
+    ps?: IParticleSystem;
+    initialize(particle: Particle, particleSystem: IParticleSystem): void;
+    constructor(x: FunctionValueGenerator | ValueGenerator, y: FunctionValueGenerator | ValueGenerator, z: FunctionValueGenerator | ValueGenerator);
+    update(particle: Particle, delta: number): void;
+    updateAll(particles: Array<Particle>, count: number, delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    _tempScale: Vector3;
+    _tempQ: Quaternion;
+    frameUpdate(delta: number): void;
+    clone(): Behavior;
+    reset(): void;
 }
-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 {
+/**
+ * apply tile number of particle texture by particles' life.
+ */
+declare class FrameOverLife implements Behavior {
     type: string;
-    constructor: Constructable<EmitterShape>;
-    params: ParameterPair[];
-    loadJSON: (json: any, meta: JsonMetaData) => EmitterShape;
+    private _frame;
+    constructor(frame: FunctionValueGenerator | ValueGenerator);
+    get frame(): FunctionValueGenerator | ValueGenerator;
+    set frame(frame: FunctionValueGenerator | ValueGenerator);
+    initialize(particle: Particle): void;
+    update(particle: Particle, delta: number): void;
+    updateAll(particles: Array<Particle>, count: number, delta: number): void;
+    private sampleFrame;
+    frameUpdate(delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
+    clone(): Behavior;
+    reset(): void;
 }
-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.
+ * Apply a gravity force to particles.
+ * the gravity force is calculated as:
+ * F = G * m1 * m2 / r^2
  */
-interface Behavior {
+declare class GravityForce implements Behavior {
+    center: Vector3;
+    magnitude: number;
     type: string;
-    initialize(particle: Particle, particleSystem: IParticleSystem): void;
+    temp: Vector3;
+    constructor(center: Vector3, magnitude: number);
+    initialize(particle: Particle): void;
     update(particle: Particle, delta: number): void;
+    updateAll(particles: Array<Particle>, count: number, delta: number): void;
     frameUpdate(delta: number): void;
     toJSON(): any;
+    static fromJSON(json: any): Behavior;
     clone(): Behavior;
     reset(): void;
 }
-interface BehaviorPlugin {
+
+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;
-    constructor: Constructable<Behavior>;
-    params: ParameterPair[];
-    loadJSON: (json: any, particleSystem: IParticleSystem) => Behavior;
+    /** Learned in {@link initialize}, so undefined until this behavior sees a particle. */
+    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;
 }
-declare const BehaviorTypes: {
-    [key: string]: BehaviorPlugin;
-};
-declare function BehaviorFromJSON(json: any, particleSystem: IParticleSystem): Behavior | null;
 
 /**
- * Color particles by their life.
+ * Limit the speed of particles over their life.
  */
-declare class ColorOverLife implements Behavior {
-    color: FunctionColorGenerator;
+declare class LimitSpeedOverLife implements Behavior {
+    speed: FunctionValueGenerator;
+    dampen: number;
     type: string;
-    constructor(color: FunctionColorGenerator);
     initialize(particle: Particle): void;
+    constructor(speed: FunctionValueGenerator, dampen: number);
     update(particle: Particle, delta: number): void;
+    updateAll(particles: Array<Particle>, count: number, delta: number): void;
+    toJSON(): any;
+    static fromJSON(json: any): Behavior;
     frameUpdate(delta: number): void;
+    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;
+    updateAll(particles: Array<Particle>, count: number, delta: number): void;
     toJSON(): any;
+    frameUpdate(delta: number): void;
     static fromJSON(json: any): Behavior;
     clone(): Behavior;
     reset(): void;
 }
 
 /**
- * Apply rotation to particles over their life.
+ * Orbit particles around an axis over their life.
  */
-declare class RotationOverLife implements Behavior {
-    angularVelocity: ValueGenerator | FunctionValueGenerator;
+declare class OrbitOverLife implements Behavior {
+    orbitSpeed: FunctionValueGenerator | ValueGenerator;
+    axis: Vector3;
     type: string;
-    constructor(angularVelocity: ValueGenerator | FunctionValueGenerator);
+    rotation: Quaternion;
+    temp: Vector3;
+    constructor(orbitSpeed: FunctionValueGenerator | ValueGenerator, axis?: Vector3);
     initialize(particle: Particle): void;
     update(particle: Particle, delta: number): void;
+    updateAll(particles: Array<Particle>, count: number, delta: number): void;
+    frameUpdate(delta: number): void;
     toJSON(): any;
     static fromJSON(json: any): Behavior;
-    frameUpdate(delta: number): void;
     clone(): Behavior;
     reset(): void;
 }
@@ -1768,8 +2058,8 @@ declare class RotationOverLife implements Behavior {
 declare class Rotation3DOverLife implements Behavior {
     angularVelocity: RotationGenerator;
     type: string;
-    private tempQuat;
-    private tempQuat2;
+    /** Scratch for the frame's rotation step; also read by the fused pass. */
+    tempQuat: Quaternion;
     constructor(angularVelocity: RotationGenerator);
     initialize(particle: Particle): void;
     update(particle: Particle, delta: number): void;
@@ -1781,84 +2071,53 @@ declare class Rotation3DOverLife implements Behavior {
 }
 
 /**
- * Apply a force to particles over their life.
+ * Apply rotation to particles based on their speed.
  */
-declare class ForceOverLife implements Behavior {
-    x: FunctionValueGenerator | ValueGenerator;
-    y: FunctionValueGenerator | ValueGenerator;
-    z: FunctionValueGenerator | ValueGenerator;
+declare class RotationBySpeed implements Behavior {
+    angularVelocity: ValueGenerator | FunctionValueGenerator;
+    speedRange: IntervalValue;
     type: string;
-    _temp: Vector3;
-    ps: IParticleSystem;
-    initialize(particle: Particle, particleSystem: IParticleSystem): void;
-    constructor(x: FunctionValueGenerator | ValueGenerator, y: FunctionValueGenerator | ValueGenerator, z: FunctionValueGenerator | ValueGenerator);
+    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;
-    _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.
+ * Apply rotation to particles over their life.
  */
-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;
+declare class RotationOverLife implements Behavior {
+    angularVelocity: ValueGenerator | FunctionValueGenerator;
     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;
+    constructor(angularVelocity: ValueGenerator | FunctionValueGenerator);
+    initialize(particle: Particle): void;
     update(particle: Particle, delta: number): void;
-    private orbit;
+    updateAll(particles: Array<Particle>, count: number, delta: number): void;
     toJSON(): any;
     static fromJSON(json: any): Behavior;
+    frameUpdate(delta: number): void;
     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.
+ * Apply size to particles based on their speed.
  */
-declare class InheritVelocity implements Behavior {
-    multiplier: FunctionValueGenerator | ValueGenerator;
-    mode: InheritVelocityMode;
+declare class SizeBySpeed implements Behavior {
+    size: FunctionValueGenerator | Vector3Generator;
+    speedRange: IntervalValue;
     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;
+    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;
 }
@@ -1867,11 +2126,15 @@ declare class InheritVelocity implements Behavior {
  *  Apply size to particles based on their life.
  */
 declare class SizeOverLife implements Behavior {
-    size: FunctionValueGenerator | Vector3Generator;
     type: string;
-    initialize(particle: Particle): void;
+    private _size;
+    private _sizeIsVector3;
     constructor(size: FunctionValueGenerator | Vector3Generator);
+    get size(): FunctionValueGenerator | Vector3Generator;
+    set size(size: FunctionValueGenerator | Vector3Generator);
+    initialize(particle: Particle): void;
     update(particle: Particle): void;
+    updateAll(particles: Array<Particle>, count: number, delta: number): void;
     toJSON(): any;
     static fromJSON(json: any): Behavior;
     frameUpdate(delta: number): void;
@@ -1888,6 +2151,7 @@ declare class SpeedOverLife implements Behavior {
     initialize(particle: Particle): void;
     constructor(speed: FunctionValueGenerator);
     update(particle: Particle): void;
+    updateAll(particles: Array<Particle>, count: number, delta: number): void;
     toJSON(): any;
     static fromJSON(json: any): Behavior;
     frameUpdate(delta: number): void;
@@ -1896,34 +2160,107 @@ declare class SpeedOverLife implements Behavior {
 }
 
 /**
- * apply tile number of particle texture by particles' life.
+ * A random() function, must return a numer in the interval [0,1), just like Math.random().
  */
-declare class FrameOverLife implements Behavior {
-    frame: FunctionValueGenerator;
+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;
-    constructor(frame: FunctionValueGenerator);
+    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;
-    frameUpdate(delta: number): void;
     toJSON(): any;
+    frameUpdate(delta: number): void;
     static fromJSON(json: any): Behavior;
     clone(): Behavior;
     reset(): void;
 }
 
+type VelocityOverLifeSpace = 'local' | 'world';
 /**
- * Orbit particles around an axis over their life.
+ * 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 OrbitOverLife implements Behavior {
-    orbitSpeed: FunctionValueGenerator | ValueGenerator;
-    axis: Vector3;
+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;
-    rotation: Quaternion;
-    temp: Vector3;
-    constructor(orbitSpeed: FunctionValueGenerator | ValueGenerator, axis?: Vector3);
-    initialize(particle: Particle): void;
-    update(particle: Particle, delta: number): void;
+    /** Learned in {@link initialize}, so undefined until this behavior sees a particle. */
+    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;
+    /**
+     * Axes the orbital speeds turn around, refreshed once per frame by
+     * {@link frameUpdate}. In world space they are the emitter's axes, which
+     * only change when the emitter does — so they are hoisted out of the
+     * per-particle work rather than rebuilt for every particle.
+     */
+    _axisX: Vector3;
+    _axisY: Vector3;
+    _axisZ: 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;
@@ -1946,319 +2283,644 @@ declare class WidthOverLength implements Behavior {
     reset(): 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[];
+}
+
+interface ShapeTransformJSON {
+    /** Offset of the shape, `[x, y, z]`. Omitted when zero. */
+    position?: number[];
+    /** Rotation of the shape as a quaternion, `[x, y, z, w]`. Omitted when identity. */
+    rotation?: number[];
+    /** Scale of the shape, `[x, y, z]`. Omitted when `[1, 1, 1]`. */
+    scale?: number[];
+}
 /**
- * Apply a global force to particles.
+ * Local transform of an emitter shape inside its particle system, like the
+ * Position / Rotation / Scale of Unity's Shape module.
+ *
+ * A spawn point `p` lands at `position + rotation * (scale * p)`. The start
+ * direction goes through the same scale and rotation and is then brought back
+ * to its old length, so a squashed shape bends directions without changing the
+ * start speed — which is what Unity does.
  */
-declare class ApplyForce implements Behavior {
-    direction: Vector3;
-    magnitude: ValueGenerator;
-    type: string;
-    magnitudeValue: number;
-    memory: {
-        data: never[];
-        dataCount: number;
+declare class ShapeTransform {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+    constructor(position?: Vector3, rotation?: Quaternion, scale?: Vector3);
+    /** Moves a freshly initialized particle from shape space into system space. */
+    apply(p: Particle): void;
+    isIdentity(): boolean;
+    toJSON(): ShapeTransformJSON;
+    /** Returns undefined when there is no transform in the JSON. */
+    static fromJSON(json: ShapeTransformJSON | undefined): ShapeTransform | undefined;
+    /**
+     * The `transform` entry of a shape's JSON: empty when the shape has no
+     * transform or an identity one, so shapes without one serialize as before.
+     */
+    static toShapeJSON(transform: ShapeTransform | undefined): {
+        transform?: ShapeTransformJSON;
     };
-    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;
+    clone(): ShapeTransform;
 }
 
+interface ShapeJSON {
+    type: string;
+    radius?: number;
+    arc?: number;
+    thickness?: number;
+    donutRadius?: number;
+    angle?: number;
+    width?: number;
+    height?: number;
+    depth?: number;
+    emitFrom?: number;
+    boxThickness?: number[];
+    column?: number;
+    row?: number;
+    mesh?: string;
+    mode?: number;
+    particleSystem?: string;
+    spread?: number;
+    speed?: any;
+    /** Local offset / rotation / scale of the shape; omitted when there is none. */
+    transform?: ShapeTransformJSON;
+}
 /**
- * Apply a gravity force to particles.
- * the gravity force is calculated as:
- * F = G * m1 * m2 / r^2
+ * Enum representing the emitter modes for particles.
  */
-declare class GravityForce implements Behavior {
-    center: Vector3;
-    magnitude: number;
+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;
-    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;
+    initialize(particle: Particle, emissionState: EmissionState): void;
+    toJSON(): ShapeJSON;
+    update(system: IParticleSystem, delta: number): void;
+    clone(): EmitterShape;
+    /**
+     * Optional local transform of the shape inside its particle system, applied
+     * by the shape itself at the end of {@link initialize}.
+     */
+    transform?: ShapeTransform;
 }
 
 /**
- * Change the emit direction of particles.
+ * Which part of the box particles start from.
  */
-declare class ChangeEmitDirection implements Behavior {
-    angle: ValueGenerator;
+declare enum BoxEmitFrom {
+    /** Anywhere inside the box. */
+    Volume = 0,
+    /** On the six faces. */
+    Shell = 1,
+    /** On the twelve edges. */
+    Edge = 2
+}
+/**
+ * Interface representing the parameters for a box emitter.
+ */
+interface BoxEmitterParameters {
+    /** Size of the box along X. */
+    width?: number;
+    /** Size of the box along Y. */
+    height?: number;
+    /** Size of the box along Z. */
+    depth?: number;
+    /** Which part of the box particles start from. {@link BoxEmitFrom} */
+    emitFrom?: BoxEmitFrom;
+    /**
+     * How far Shell and Edge particles may sink into the box on each axis, as a fraction of the
+     * box size: 0 keeps them on the surface, 0.5 reaches the center.
+     */
+    boxThickness?: [number, number, number];
+}
+/**
+ * A particle emitter that emits particles from a box centered on the emitter, all moving along +Z
+ * like Unity's Box shape. A box with no depth is a flat rectangle (Unity's Rectangle shape).
+ */
+declare class BoxEmitter implements EmitterShape {
     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;
+    width: number;
+    height: number;
+    depth: number;
+    emitFrom: BoxEmitFrom;
+    boxThickness: [number, number, number];
+    private readonly _point;
+    constructor(parameters?: BoxEmitterParameters);
+    update(_system: IParticleSystem, _delta: number): void;
+    initialize(p: Particle, _emissionState: EmissionState): void;
+    /**
+     * A coordinate on one of the two faces across `axis`, in -1..1. As measured in Unity, a
+     * thickness leaves half the particles on the face and sinks the rest evenly up to
+     * 2 × thickness of the half-size into the box.
+     */
+    private onSurface;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): BoxEmitter;
+    clone(): EmitterShape;
 }
 
-declare enum SubParticleEmitMode {
-    Death = 0,
-    Birth = 1,
-    Frame = 2
+/**
+ * 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;
+    /**
+     * Offset, rotation and scale of the shape within the particle system.
+     * {@link ShapeTransform}
+     */
+    transform?: ShapeTransform;
+}
+/**
+ * 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;
+    transform?: ShapeTransform;
+    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 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;
+    /**
+     * Offset, rotation and scale of the shape within the particle system.
+     * {@link ShapeTransform}
+     */
+    transform?: ShapeTransform;
 }
-/**
- * Emit a sub particle system from particles.
- */
-declare class EmitSubParticleSystem implements Behavior {
-    private particleSystem;
-    useVelocityAsBasis: boolean;
-    subParticleSystem: IEmitter | undefined;
-    mode: SubParticleEmitMode;
-    emitProbability: number;
+declare class ConeEmitter implements EmitterShape {
     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;
+    radius: number;
+    arc: number;
+    thickness: number;
+    angle: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    transform?: ShapeTransform;
+    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;
 }
 
 /**
- * A random() function, must return a numer in the interval [0,1), just like Math.random().
+ * Interface representing the parameters for a donut emitter.
  */
-type RandomFn = () => number;
-/** Deterministic simplex noise generator suitable for 2D, 3D and 4D spaces. */
-declare class SimplexNoise {
-    private p;
-    private perm;
-    private permMod12;
+interface DonutEmitterParameters {
     /**
-     * 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).
+     * The radius of the donut.
      */
-    constructor(randomOrSeed?: RandomFn | string | number);
+    radius?: number;
     /**
-     * Samples the noise field in 2 dimensions
-     * @param x
-     * @param y
-     * @returns a number in the interval [-1, 1]
+     * The arc of the donut.
      */
-    noise2D(x: number, y: number): number;
+    arc?: number;
     /**
-     * Samples the noise field in 3 dimensions
-     * @param x
-     * @param y
-     * @param z
-     * @returns a number in the interval [-1, 1]
+     * The thickness of the ring. 1 is a full donut, 0 is a ring with 0 radius.
      */
-    noise3D(x: number, y: number, z: number): number;
+    thickness?: number;
     /**
-     * Samples the noise field in 4 dimensions
-     * @param x
-     * @param y
-     * @param z
-     * @returns a number in the interval [-1, 1]
+     * The radius of the hole in the center of the donut.
      */
-    noise4D(x: number, y: number, z: number, w: number): number;
+    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;
+    /**
+     * Offset, rotation and scale of the shape within the particle system.
+     * {@link ShapeTransform}
+     */
+    transform?: ShapeTransform;
+}
+declare class DonutEmitter implements EmitterShape {
+    type: string;
+    radius: number;
+    donutRadius: number;
+    arc: number;
+    thickness: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    transform?: ShapeTransform;
+    _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;
 }
 
 /**
- * Apply turbulence to particles.
+ * Interface representing the parameters for an edge emitter.
  */
-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;
+interface EdgeEmitterParameters {
+    /** Half the length of the line: it runs from -radius to +radius along X. */
+    radius?: 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;
 }
-
 /**
- * Apply noise to particles.
+ * A particle emitter that emits particles from a line along X, all moving along +Y like Unity's
+ * single-sided Edge shape.
  */
-declare class Noise implements Behavior {
-    frequency: FunctionValueGenerator | ValueGenerator;
-    power: FunctionValueGenerator | ValueGenerator;
-    positionAmount: FunctionValueGenerator | ValueGenerator;
-    rotationAmount: FunctionValueGenerator | ValueGenerator;
+declare class EdgeEmitter implements EmitterShape {
     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;
+    radius: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    private currentValue;
+    constructor(parameters?: EdgeEmitterParameters);
+    update(system: IParticleSystem, delta: number): void;
+    initialize(p: Particle, emissionState: EmissionState): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): EdgeEmitter;
+    clone(): EmitterShape;
 }
 
-interface Sequencer {
-    transform(position: Vector3, index: number): void;
-    toJSON(): any;
-    clone(): Sequencer;
+interface EmitterShapePlugin {
+    type: string;
+    constructor: Constructable<EmitterShape>;
+    params: ParameterPair[];
+    loadJSON: (json: any, meta: JsonMetaData) => EmitterShape;
 }
-declare function SequencerFromJSON(json: any): Sequencer;
+declare const EmitterShapes: {
+    [key: string]: EmitterShapePlugin;
+};
+declare function EmitterFromJSON(json: ShapeJSON, meta: JsonMetaData): EmitterShape;
 
 /**
- * Apply sequences to particles.
- * {@link Sequencer}
+ * Interface representing the parameters for a grid emitter.
  */
-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 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;
+    /**
+     * Offset, rotation and scale of the shape within the particle system.
+     * {@link ShapeTransform}
+     */
+    transform?: ShapeTransform;
 }
-
-interface PhysicsResolver {
-    resolve(pos: Vector3, normal: Vector3): boolean;
+declare class GridEmitter implements EmitterShape {
+    type: string;
+    width: number;
+    height: number;
+    column: number;
+    row: number;
+    transform?: ShapeTransform;
+    constructor(parameters?: GridEmitterParameters);
+    initialize(p: Particle): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): GridEmitter;
+    clone(): EmitterShape;
+    update(system: IParticleSystem, delta: number): void;
 }
-declare function setPhysicsResolver(resolver: PhysicsResolver): void;
-declare function getPhysicsResolver(): PhysicsResolver;
+
 /**
- * Apply collision to particles from a physics resolver.
+ * Interface representing the parameters for a hemisphere emitter.
  */
-declare class ApplyCollision implements Behavior {
-    resolver: PhysicsResolver;
-    bounce: number;
+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;
+    /**
+     * Offset, rotation and scale of the shape within the particle system.
+     * {@link ShapeTransform}
+     */
+    transform?: ShapeTransform;
+}
+declare class HemisphereEmitter implements EmitterShape {
     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;
+    radius: number;
+    arc: number;
+    thickness: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    transform?: ShapeTransform;
+    _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;
 }
 
 /**
- * Color particles by their speed.
+ * A point emitter emits particles from a single point.
  */
-declare class ColorBySpeed implements Behavior {
-    color: FunctionColorGenerator;
-    speedRange: IntervalValue;
+declare class PointEmitter implements EmitterShape {
     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;
+    _m1: Matrix4;
+    /**
+     * Offset, rotation and scale of the point within the particle system.
+     * {@link ShapeTransform}
+     */
+    transform?: ShapeTransform;
+    constructor(transform?: ShapeTransform);
+    update(system: IParticleSystem, delta: number): void;
+    initialize(p: Particle): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): PointEmitter;
+    clone(): EmitterShape;
 }
 
 /**
- * Apply size to particles based on their speed.
+ * Interface representing the parameters for a rectangle emitter.
  */
-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;
+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;
+    /**
+     * Offset, rotation and scale of the shape within the particle system.
+     * {@link ShapeTransform}
+     */
+    transform?: ShapeTransform;
 }
-
 /**
- * Apply rotation to particles based on their speed.
+ * a particle emitter that emits particles from a rectangle.
  */
-declare class RotationBySpeed implements Behavior {
-    angularVelocity: ValueGenerator | FunctionValueGenerator;
-    speedRange: IntervalValue;
+declare class RectangleEmitter implements EmitterShape {
     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;
+    width: number;
+    height: number;
+    thickness: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    transform?: ShapeTransform;
+    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;
 }
 
 /**
- * Limit the speed of particles over their life.
+ * Interface representing the parameters for a sphere emitter.
  */
-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;
+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;
+    /**
+     * Offset, rotation and scale of the shape within the particle system.
+     * {@link ShapeTransform}
+     */
+    transform?: ShapeTransform;
 }
-
-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;
+declare class SphereEmitter implements EmitterShape {
+    type: string;
+    radius: number;
+    arc: number;
+    thickness: number;
+    mode: EmitterMode;
+    spread: number;
+    speed: ValueGenerator | FunctionValueGenerator;
+    memory: GeneratorMemory;
+    transform?: ShapeTransform;
+    _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 Plugin {
@@ -2271,23 +2933,17 @@ 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 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;
 }
 
 declare enum RenderMode {
@@ -2317,7 +2973,13 @@ interface StoredBatchSettings {
     materialDepthWrite: boolean;
     materialAlphaTest: number;
     texture: any;
+    reflectionTexture: BaseTexture | null;
+    reflectionLevel: number;
+    reflectionFaces: BaseTexture[] | null;
+    reflectionAtlas: BaseTexture | null;
     layerMask: number;
+    /** Billboard pivot in particle-size units, see {@link VFXBatchSettings.pivot}. */
+    pivot?: Vector3;
 }
 declare abstract class VFXBatch {
     mesh: Mesh;
@@ -2325,9 +2987,15 @@ declare abstract class VFXBatch {
     settings: StoredBatchSettings;
     protected maxParticles: number;
     protected scene: Scene;
+    private readonly visibleSystems;
     protected constructor(settings: VFXBatchSettings, scene: Scene);
     addSystem(system: IParticleSystem): void;
     removeSystem(system: IParticleSystem): void;
+    /**
+     * Visible systems of this batch, written into a buffer owned by the batch.
+     * Called once per frame per batch, so the result is reused rather than
+     * reallocated; treat it as valid only until the next call.
+     */
     getVisibleSystems(): IParticleSystem[];
     applyDepthTexture(depthTexture: BaseTexture | null): void;
     abstract setupBuffers(): void;
@@ -2356,7 +3024,34 @@ interface VFXBatchSettings {
     materialDepthWrite: boolean;
     materialAlphaTest: number;
     texture: Texture | null;
+    /**
+     * Cubemap (or other reflection texture) harvested from a Babylon material's
+     * `reflectionTexture`. Mesh batches sample it like StandardMaterial cubic
+     * reflection; other render modes ignore it.
+     */
+    reflectionTexture: BaseTexture | null;
+    /** Multiplier for the reflection sample — mirrors `texture.level`. */
+    reflectionLevel: number;
+    /**
+     * Optional six cube-face 2D textures (px,py,pz,nx,ny,nz). Prefer
+     * `reflectionAtlas` on iOS — many simultaneous face samplers still trip
+     * GL_INVALID_OPERATION on WebKit.
+     */
+    reflectionFaces: BaseTexture[] | null;
+    /**
+     * Single 3×2 atlas of cube faces (px py pz / nx ny nz). One sampler2D —
+     * the path that stays valid on iOS WebKit ShaderMaterial draws.
+     */
+    reflectionAtlas: BaseTexture | null;
     layerMask: number;
+    /**
+     * Offset of billboard quads from their particle, in particle-size units
+     * (Unity's renderer Pivot). On billboards x/y move the quad in its own plane
+     * before it is rotated and z moves it toward the camera (up for horizontal
+     * billboards). On stretched billboards x runs from the head to the tail and
+     * y across, and z is unused. Absent or zero: no offset. Meshes ignore it.
+     */
+    pivot?: Vector3;
 }
 interface AdaptivePerformanceOptions {
     targetFrameMs: number;
@@ -2374,22 +3069,66 @@ declare class BatchedRenderer extends TransformNode {
     batches: Array<VFXBatch>;
     systemToBatchIndex: Map<IParticleSystem, number>;
     depthTexture: BaseTexture | null;
+    /** Systems in insertion order — iterated every frame, unlike the map. */
+    private systems;
+    /**
+     * The same systems, ordered so that one emitting into another comes first.
+     *
+     * A sub emitter's particles are created by its parent's behaviors, part way
+     * through the parent's step. A sub system updated before its parent has
+     * already fixed the list of particles it will run behaviors over, so those
+     * new particles are drawn that frame with nothing but their start values —
+     * white where a colour curve would have coloured them, at their start size,
+     * sitting at the point they were born. Rebuilt only when the set of systems
+     * or their behaviors changes, not per frame.
+     */
+    private orderedSystems;
+    private orderedSystemsStale;
+    /** Consecutive frames each batch has held no system, parallel to `batches`. */
+    private batchEmptyFrames;
+    /**
+     * How long an empty batch is kept before it is disposed. Systems that toggle
+     * a setting back and forth reuse the batch within this window instead of
+     * rebuilding a mesh and material every time.
+     */
+    private static readonly EMPTY_BATCH_GRACE_FRAMES;
     private adaptivePerformanceState;
     private lastAppliedQuality;
     constructor(name: string, scene: Scene);
     private static clamp;
     private static equals;
     addSystem(system: IParticleSystem): void;
-    deleteSystem(system: IParticleSystem): void;
+    /** Places a system into a compatible batch, creating one when none matches. */
+    private assignToBatch;
+    deleteSystem(system: IParticleSystem): boolean;
+    /** Detaches a system from its batch, leaving the renderer's system list alone. */
+    private removeFromBatch;
+    /**
+     * Re-buckets a system whose render settings changed. The system keeps its
+     * place in the update order, so this is safe to call mid-frame.
+     */
     updateSystem(system: IParticleSystem): void;
     setDepthTexture(depthTexture: BaseTexture | null): void;
     configureAdaptivePerformance(options?: Partial<AdaptivePerformanceOptions>): void;
     disableAdaptivePerformance(resetQuality?: boolean): void;
     getAdaptivePerformanceState(): AdaptivePerformanceState;
     private applyAdaptiveQuality;
+    /** @internal Called when a system's behaviors change, which can add a sub emitter. */
+    _invalidateUpdateOrder(): void;
+    /**
+     * Orders the systems so a system emitting into another runs first.
+     *
+     * Depth first over "emits into" edges, recording each system once all the
+     * systems it feeds have been recorded, then reversed — a system therefore
+     * lands ahead of everything it emits into, however deep the chain. A cycle
+     * cannot be satisfied by any order; it is left as found rather than dropped.
+     */
+    private orderSystems;
     update(delta: number): void;
     /** Rebuild instance buffers from current particle state without advancing simulation. */
     refreshBatches(): void;
+    /** Disposes the batch at `index` and repairs the system→batch mapping. */
+    private removeBatch;
     /** Per-batch particle vs GPU instance counts — for diagnosing stale render state. */
     getBatchRenderStats(): Array<{
         batchIndex: number;
@@ -2403,69 +3142,63 @@ declare class BatchedRenderer extends TransformNode {
 
 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;
-    /** Pushes a zero-alpha instance so stale instancing data cannot linger on screen. */
-    private uploadClearedInstance;
-    dispose(): void;
+/** Reads the six face URLs from a Babylon CubeTexture (px py pz nx ny nz). */
+declare function cubeFaceUrls(reflection: BaseTexture | null | undefined): string[] | null;
+/** Returns a previously built atlas for this cube, if any. */
+declare function getCachedEnvAtlas(cube: BaseTexture): Texture | null;
+/** Stores an atlas for a cube source (tests / prebuilt atlases). */
+declare function cacheEnvAtlas(cube: BaseTexture, atlas: Texture): void;
+/**
+ * Packs six cube-face images into one 3×2 atlas Texture (px py pz / nx ny nz).
+ * Uses invertY:false so UV cellY=0 maps to the +faces row matching the shader.
+ */
+declare function createEnvAtlasFromFaceUrls(urls: string[], scene: Scene): Promise<Texture>;
+/**
+ * Ensures a 3×2 env atlas exists for a CubeTexture. Returns a cached atlas
+ * synchronously when available; otherwise starts (or joins) an async build and
+ * invokes onReady when the atlas is usable.
+ */
+declare function ensureEnvAtlasFromCube(cube: BaseTexture, scene: Scene, onReady: (atlas: Texture) => void): Texture | null;
+
+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);
 }
 
-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 MeshSurfaceEmitter implements EmitterShape {
+    type: string;
+    private _triangleIndexToArea;
+    private _mesh?;
+    private _positions?;
+    private _indices?;
+    private _meshReferenceId?;
+    /** Offset, rotation and scale of the mesh within the particle system. */
+    transform?: ShapeTransform;
+    get mesh(): Mesh | undefined;
+    set mesh(mesh: Mesh | undefined);
+    constructor(mesh?: Mesh, meshReferenceId?: string, transform?: ShapeTransform);
+    initialize(p: Particle): void;
+    toJSON(): ShapeJSON;
+    static fromJSON(json: any): MeshSurfaceEmitter;
+    clone(): EmitterShape;
+    update(_system: IParticleSystem, _delta: number): void;
 }
+declare const MeshSurfaceEmitterPlugin: Plugin;
 
 declare class ParticleEmitter extends TransformNode {
     system: IParticleSystem;
     private _matrixWorld;
+    private _matrixWorldFlag;
+    /**
+     * The node's world matrix in quarks.core form. Mirrored from Babylon's
+     * matrix only when that matrix actually changed (tracked by its
+     * `updateFlag`), so repeated reads inside a frame are free.
+     */
     get matrixWorld(): Matrix4;
     get visible(): boolean;
     set visible(value: boolean);
@@ -2500,6 +3233,8 @@ interface ParticleSystemParameters {
     emissionOverTime?: ValueGenerator | FunctionValueGenerator;
     emissionOverDistance?: ValueGenerator | FunctionValueGenerator;
     emissionBursts?: Array<BurstParameters>;
+    /** Most particles alive at once; emission past it is dropped. Leave unset for no limit. */
+    maxParticles?: number;
     onlyUsedByOther?: boolean;
     behaviors?: Array<Behavior>;
     instancingGeometry?: Float32Array;
@@ -2526,6 +3261,10 @@ interface ParticleSystemParameters {
     depthWrite?: boolean;
     alphaTest?: number;
     layerMask?: number;
+    /** Billboard pivot in particle-size units, see {@link VFXBatchSettings.pivot}. */
+    pivot?: Vector3;
+    /** Fraction of billboard particles mirrored along U (x) and V (y), see {@link ParticleSystem.flip}. */
+    flip?: Vector2;
     scene?: Scene;
 }
 interface BurstParametersJSON {
@@ -2551,6 +3290,7 @@ interface ParticleSystemJSONParameters {
     emissionOverTime: FunctionJSON;
     emissionOverDistance: FunctionJSON;
     emissionBursts?: Array<BurstParametersJSON>;
+    maxParticles?: number;
     onlyUsedByOther: boolean;
     rendererEmitterSettings: RendererEmitterSettings;
     instancingGeometry?: any;
@@ -2574,6 +3314,10 @@ interface ParticleSystemJSONParameters {
     alphaTest?: number;
     behaviors: Array<any>;
     worldSpace: boolean;
+    /** `[x, y, z]`; written only when non-zero. */
+    pivot?: number[];
+    /** `[u, v]`; written only when non-zero. */
+    flip?: number[];
 }
 interface BabylonMetaData {
     textures: {
@@ -2615,14 +3359,24 @@ declare class ParticleSystem implements IParticleSystem {
     startColor: ColorGenerator | FunctionColorGenerator;
     startTileIndex: ValueGenerator;
     rendererEmitterSettings: RendererEmitterSettings;
+    /**
+     * Fraction of billboard particles mirrored along U (x) and V (y), each
+     * picked at random when the particle is born — Unity's renderer Flip.
+     * Undefined: nothing is mirrored. Meshes ignore it.
+     */
+    flip?: Vector2;
     emissionOverTime: ValueGenerator | FunctionValueGenerator;
     emissionOverDistance: ValueGenerator | FunctionValueGenerator;
     emissionBursts: Array<BurstParameters>;
+    /** Most particles alive at once (Unity's Max Particles); emission past it is dropped. Undefined means no limit. */
+    maxParticles?: number;
     onlyUsedByOther: boolean;
     worldSpace: boolean;
     particleNum: number;
     paused: boolean;
     particles: Array<Particle>;
+    /** Column storage shared by this system's particles. */
+    readonly store: ParticleStore;
     emitterShape: EmitterShape;
     emitter: ParticleEmitter;
     rendererSettings: VFXBatchSettings;
@@ -2643,10 +3397,13 @@ declare class ParticleSystem implements IParticleSystem {
     private listeners;
     private readonly layerMaskProxy;
     private materialRef;
+    private sceneRef;
     private qualityFactor;
-    private useFastTrailHistory;
     private simulationAccumulator;
     private destroyed;
+    /** Behaviors the cached plan was built from, compared by identity. */
+    private fusionPlan?;
+    private fusionSteps;
     /** @internal **/
     _renderer?: BatchedRenderer;
     set time(time: number);
@@ -2671,6 +3428,15 @@ declare class ParticleSystem implements IParticleSystem {
     set blendTiles(v: boolean);
     get softParticles(): boolean;
     set softParticles(v: boolean);
+    /**
+     * Billboard pivot in particle-size units (Unity's renderer Pivot), see
+     * {@link VFXBatchSettings.pivot}. Assign a new vector to change it: editing
+     * the returned one in place does not reach the renderer.
+     */
+    get pivot(): Vector3 | undefined;
+    set pivot(v: Vector3 | undefined);
+    private static nonZeroPivot;
+    private static nonZeroFlip;
     get softNearFade(): number;
     set softNearFade(v: number);
     get softFarFade(): number;
@@ -2688,12 +3454,16 @@ declare class ParticleSystem implements IParticleSystem {
     pause(): void;
     play(): void;
     stop(): void;
-    private refreshTrailHistoryMode;
-    private ensureTrailHistoryCapacity;
-    private resetTrailHistory;
-    private getTrailHistoryCount;
-    private updateFastTrailHistory;
     setQualityFactor(qualityFactor: number): void;
+    /**
+     * Appends one particle to the pool, giving it the next row of the store.
+     *
+     * Growing the store replaces its arrays, so every particle already bound to
+     * it has to be re-pointed at the new ones.
+     */
+    /** Points every particle at the store's columns again, after any were replaced. */
+    private rebindParticles;
+    private growParticlePool;
     private spawn;
     endEmit(): void;
     dispose(): void;
@@ -2701,6 +3471,45 @@ declare class ParticleSystem implements IParticleSystem {
     private firstTimeUpdate;
     /** @internal */
     update(delta: number): void;
+    /**
+     * Time the display is ahead of (positive) or still ahead of the simulation
+     * (negative — the simulation ran a hair early), in seconds. Magnitude never
+     * exceeds one step.
+     *
+     * The simulation runs on a fixed 1/60 step so that emission and lifetimes
+     * stay in phase — without it a slow emitter flickers when the frame rate
+     * wobbles. But frames do not arrive on that grid: a display running at
+     * anything other than exactly 60Hz leaves some frames with no step at all
+     * (half of them at 120Hz, three in five at 144Hz) and others with two, so
+     * the particles are drawn stuttering even while the frame rate is perfect.
+     *
+     * The steps-per-frame count below is chosen by *rounding* the accumulated
+     * time to the nearest step, not flooring it. Flooring always leaves the
+     * accumulator positive, and when the real frame rate sits very close to
+     * 60Hz (as most displays do) that leftover creeps toward a full step for
+     * many consecutive frames before tipping over into a frame that runs two
+     * steps at once and resets it to near zero — a visible lurch, every particle
+     * in the system at once, with a perfectly steady frame rate the whole time.
+     * Rounding lets the leftover go negative instead, which keeps it centered
+     * near zero and stops it from ever building up toward that reset.
+     *
+     * Renderers close the gap by advancing what they draw along each particle's
+     * velocity by this much. That reproduces the straight-line part of the
+     * motion exactly — it is the same term the next step would integrate — so
+     * the simulation stays fixed-step while the picture moves continuously.
+     */
+    /** Length of one simulation step, in seconds. See {@link simulationResidual}. */
+    get simulationStep(): number;
+    get simulationResidual(): number;
+    /**
+     * Execution plan for this system's behaviors, rebuilt when the list changes.
+     *
+     * Consecutive behaviors that can be compiled into one loop are merged, so
+     * the particles are walked once instead of once per behavior. The plan is
+     * keyed on the behavior instances, not their types: swapping one out has to
+     * change the generated code's indices.
+     */
+    private behaviorSteps;
     /** Advances emission, behaviors, motion and culling by one fixed timestep. */
     private simulateStep;
     private notifyFinished;
@@ -2720,46 +3529,70 @@ declare class ParticleSystem implements IParticleSystem {
     addEventListener(event: ParticleSystemEventType, callback: (event: ParticleSystemEvent) => void): void;
     removeAllEventListeners(event: ParticleSystemEventType): void;
     removeEventListener(event: ParticleSystemEventType, callback: (event: ParticleSystemEvent) => void): void;
+    /** True when at least one callback is registered for the event type. */
+    private hasListeners;
     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;
-    /** True when every emitter under `root` is a finished non-looping system (or looping). */
-    static isEffectFinished(root: Node): boolean;
-    private static traverseNode;
-}
-
 interface QuarksLoaderOptions {
     baseUrl?: string;
+    /**
+     * Reuse one Texture per scene for every effect that references the same image with the same
+     * sampling, and one copy of the data for identical mesh geometry. The renderer only batches
+     * systems that share the texture (and geometry) object, so without this every loaded effect
+     * gets batches — draw calls and buffer uploads — of its own even when its images are the same
+     * as another effect's. Default true; turn off to give each effect private textures, e.g. to
+     * change one effect's texture settings without touching the others.
+     */
+    shareResources?: boolean;
 }
 declare class QuarksLoader {
     private scene;
     private options;
     constructor(scene: Scene, options?: QuarksLoaderOptions);
     load(url: string): Promise<TransformNode>;
+    /**
+     * Inlines geometries that an export wrote to their own file (`{uuid, type: 'QuarksGeometry',
+     * url}` — e.g. the Unity exporter's "geometries as files"): each `url` is passed to
+     * `loadGeometry`, and the `positions / indices / uvs / normals` it returns replace the url in
+     * place, so `parse()` (which is synchronous) sees an ordinary inline geometry. `load()` does
+     * this with `fetch`; call it yourself before `parse()` when the files come from elsewhere.
+     * A geometry that fails to load is left as is and warned about.
+     */
+    static resolveExternalGeometries(json: any, loadGeometry: (url: string) => Promise<any>): Promise<void>;
     parse(json: any, baseUrl?: string): TransformNode;
     private parseGeometries;
+    /** The scene's copy of an identical geometry when resources are shared, else `geometry` itself. */
+    private share;
+    /**
+     * Forgets the textures and geometries shared between loads into `scene` (see
+     * {@link QuarksLoaderOptions.shareResources}). Effects already loaded keep theirs; the next
+     * load creates new ones. Textures are not disposed — they may still be in use.
+     */
+    static clearSharedResources(scene: Scene): void;
     private parseSphereGeometry;
     private parseBufferGeometry;
     private extractInterleavedAttribute;
     private int32ArrayToFloat32;
     private parseImages;
+    /**
+     * Flags an image entry that is plainly not an image, which otherwise only
+     * shows up as a texture that silently fails to load.
+     *
+     * The case worth naming: an exporter that could not embed a texture falls
+     * back to writing the source asset's path, and a Unity built-in texture
+     * reports a virtual path such as `Resources/unity_builtin_extra` that no
+     * file backs.
+     */
+    private static warnIfNotAnImageUrl;
     /**
      * `img.url` is already absolute for data/blob URIs and full http(s) URLs — common for
      * "portable" exports that embed textures as base64 (see ensurePortableTextureUrl in
      * babylon.quarks-editor). Prepending baseUrl to those turns e.g.
      * "data:image/png;base64,AAAA" into an invalid path like "/some/dir/data:image/png;base64,AAAA".
      */
-    private resolveImageUrl;
+    private static resolveUrl;
     private parseTextures;
     private mapWrapMode;
     private parseMaterials;
@@ -2815,53 +3648,184 @@ declare class QuarksPrefab extends TransformNode implements IPrefab {
     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 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;
+    /** True when every emitter under `root` is a finished non-looping system (or looping). */
+    static isEffectFinished(root: Node): boolean;
+    private static traverseNode;
 }
-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$7: "\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$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$6: "\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$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$5: "\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$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$4: "\nvarying vec2 vUV;\nvarying vec4 vColor;\nvarying vec3 vNormal;\nvarying vec3 vWorldPos;\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// One 3\u00D72 atlas (px py pz / nx ny nz). Avoids samplerCube and multi-face\n// sampler bindings that raise GL_INVALID_OPERATION on iOS WebKit.\n#ifdef USE_ENVMAP_ATLAS\nuniform sampler2D envAtlas;\nuniform vec3 eyePosition;\nuniform float reflectionLevel;\n\nvec3 sampleEnvAtlas(vec3 r) {\n    vec3 a = abs(r);\n    vec2 localUV;\n    float cellX;\n    float cellY;\n    // Atlas layout: +X +Y +Z on row 0, -X -Y -Z on row 1.\n    if (a.x >= a.y && a.x >= a.z) {\n        cellX = 0.0;\n        if (r.x >= 0.0) {\n            cellY = 0.0;\n            localUV = vec2(-r.z, -r.y) / a.x * 0.5 + 0.5;\n        } else {\n            cellY = 1.0;\n            localUV = vec2(r.z, -r.y) / a.x * 0.5 + 0.5;\n        }\n    } else if (a.y >= a.z) {\n        cellX = 1.0;\n        if (r.y >= 0.0) {\n            cellY = 0.0;\n            localUV = vec2(r.x, r.z) / a.y * 0.5 + 0.5;\n        } else {\n            cellY = 1.0;\n            localUV = vec2(r.x, -r.z) / a.y * 0.5 + 0.5;\n        }\n    } else {\n        cellX = 2.0;\n        if (r.z >= 0.0) {\n            cellY = 0.0;\n            localUV = vec2(r.x, -r.y) / a.z * 0.5 + 0.5;\n        } else {\n            cellY = 1.0;\n            localUV = vec2(-r.x, -r.y) / a.z * 0.5 + 0.5;\n        }\n    }\n    vec2 uv = (vec2(cellX, cellY) + clamp(localUV, 0.0, 1.0)) / vec2(3.0, 2.0);\n    return texture2D(envAtlas, uv).rgb;\n}\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    vec3 color = baseColor.rgb * litColor;\n\n#ifdef USE_ENVMAP_ATLAS\n    vec3 viewDir = normalize(vWorldPos - eyePosition);\n    vec3 reflectionCoords = reflect(viewDir, N);\n    color += sampleEnvAtlas(reflectionCoords) * reflectionLevel;\n#endif\n\n    gl_FragColor = vec4(color, 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$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$3: "\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#ifdef PIVOT\n// Quad offset in particle-size units: xy in the quad's plane, z toward the camera.\nuniform vec3 pivot;\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    // A negative size mirrors the quad, which is how flipped particles arrive.\n    vec2 alignedPosition = position.xy * size.xy;\n#ifdef PIVOT\n    // The pivot turns with the particle but is not mirrored with it.\n    alignedPosition += pivot.xy * abs(size.xy);\n#endif\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#ifdef PIVOT\n    mvPosition.y += pivot.z * abs(size.x);\n#endif\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#ifdef PIVOT\n#ifndef HORIZONTAL\n    // Toward the camera along its view axis, whichever way the view space\n    // faces: anything in front of the camera has the sign of the far side.\n    mvPosition.z -= sign(mvPosition.z) * pivot.z * abs(size.x);\n#endif\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$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    // Stretch direction is the velocity direction; only a genuinely motionless particle has none.\n    // Deriving it via normalize keeps the stretch aligned even when the speed contribution is ~0\n    // (e.g. speedFactor 0), instead of collapsing the whole burst onto a fixed screen axis.\n    vec3 vdir = vlength > 0.000001 ? viewVelocity / vlength : vec3(0.0, 0.0, 1.0);\n    mvPosition.xyz += position.y * normalize(cross(mvPosition.xyz, vdir)) * avgSize;\n    // Equivalent to viewVelocity * (1.0 + lengthFactor / vlength) for moving particles, but the\n    // size-based term (vdir * lengthFactor) survives when the velocity contribution vanishes.\n    mvPosition.xyz -= (position.x + 0.5) * (viewVelocity + vdir * lengthFactor) * 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$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#ifdef PIVOT\n// Streak offset in particle-size units: x from head to tail, y across.\nuniform vec3 pivot;\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    // A flipped particle arrives with a negative size: the streak keeps its\n    // extent and mirrors its texture instead (see quadUV below).\n    float avgSize = (abs(size.x) + abs(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    // Stretch direction is the velocity direction; only a genuinely motionless particle has none.\n    // Deriving it via normalize keeps the stretch aligned even when the speed contribution is ~0\n    // (e.g. speedFactor 0), instead of collapsing the whole burst onto a fixed screen axis.\n    vec3 vdir = vlength > 0.000001 ? viewVelocity / vlength : vec3(0.0, 0.0, 1.0);\n    vec3 side = normalize(cross(mvPosition.xyz, vdir));\n    mvPosition.xyz += position.y * side * avgSize;\n    // Equivalent to viewVelocity * (1.0 + lengthFactor / vlength) for moving particles, but the\n    // size-based term (vdir * lengthFactor) survives when the velocity contribution vanishes.\n    mvPosition.xyz -= (position.x + 0.5) * (viewVelocity + vdir * lengthFactor) * avgSize;\n#ifdef PIVOT\n    // In particle-size units along the quad's own axes: x from head to tail, y across.\n    mvPosition.xyz += (pivot.y * side - pivot.x * vdir) * avgSize;\n#endif\n    gl_Position = projection * mvPosition;\n    vec2 quadUV = vec2(size.x < 0.0 ? 1.0 - uv.x : uv.x, size.y < 0.0 ? 1.0 - uv.y : uv.y);\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 = quadUV / 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 = quadUV / tc + vec2(nextU, nextV);\n            vTileBlend = fract(uvTile);\n        #endif\n    #else\n        vUV = quadUV;\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$1: "\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";
 
-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";
+declare const _default: "\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";
 
-type BabylonParticleMaterialParameters = Record<string, any>;
-declare class ParticleMeshStandardMaterial extends StandardMaterial {
-    readonly isParticleMeshStandardMaterial = true;
-    constructor(name: string, scene?: Scene, parameters?: BabylonParticleMaterialParameters);
+declare class SpriteBatch extends VFXBatch {
+    private static whiteTextureByScene;
+    /** 1×1 white map so mesh batches always have a sampler2D (iOS WebKit). */
+    private static whiteTexture;
+    private offsetBuffer;
+    private rotationBuffer;
+    private sizeBuffer;
+    private colorBuffer;
+    private uvTileBuffer;
+    private velocityBuffer?;
+    /** Concretely typed handle on the batch material, see syncStretchedSpeedFactor. */
+    private shaderMaterial;
+    private offsetVB;
+    private rotationVB;
+    private sizeVB;
+    private colorVB;
+    private uvTileVB;
+    private velocityVB?;
+    constructor(settings: VFXBatchSettings, scene: Scene);
+    setupBuffers(): void;
+    /** Releases the instance vertex buffers so a resize does not leak GPU memory. */
+    private disposeExpandableBuffers;
+    private buildExpandableBuffers;
+    expandBuffers(target: number): void;
+    rebuildMaterial(): void;
+    private vector_;
+    private vector2_;
+    private vector3_;
+    private quaternion_;
+    private quaternion2_;
+    private quaternion3_;
+    private quaternion4_;
+    private quaternion5_;
+    private rotationMat_;
+    private rotationMat2_;
+    private lastStretchedSpeedFactor;
+    /** Slot 0 holds the zero-alpha instance since the batch last went empty. */
+    private clearedInstanceUploaded;
+    update(): void;
+    /**
+     * Pushes the stretched-billboard speed factor to the shader when it changed.
+     *
+     * Deliberately kept out of `update`: touching the loosely typed
+     * `mesh.material` from inside that function gives V8 a generic property
+     * access it has no feedback for, which knocks the whole particle loop out of
+     * optimised code on every frame.
+     */
+    private syncStretchedSpeedFactor;
+    /** The quads that take a pivot and flip: every billboard kind, stretched included, but not meshes. */
+    private static takesPivotAndFlip;
+    /**
+     * Negates the size of each flipped particle along the axes it flips on,
+     * starting at `base` in `sizes`. The billboard shader scales the quad by
+     * the size, so a negative one mirrors it — and with it the texture, the
+     * quad being centred — the way Unity's renderer Flip mirrors U and V. The
+     * stretched shader reads the sign and mirrors the texture coordinates.
+     */
+    private static applyFlip;
+    /**
+     * The fraction `f` of a turn, as a normalised lerp from no rotation toward
+     * `step`, written into `out`.
+     *
+     * A true slerp would be exact, but `step` is one simulation step of turning
+     * and `f` is below 1, so the arc being split is small enough that the lerp
+     * is within a rounding error of it and costs a fraction as much.
+     */
+    private static partialTurn;
+    /**
+     * Continues a three-component column by `fraction` of the step it just took,
+     * never below zero.
+     *
+     * Size fades to nothing at the end of a life, so the last step before death
+     * can point past zero; a negative size turns a sprite inside out.
+     */
+    private static continueVector3;
+    /** The same for colour, whose alpha runs out at the end of a life too. */
+    private static continueColor;
+    /**
+     * Writes rows `[0, count)` of the store's positions into `target` at `base`,
+     * each carried on by `fraction` of the step it just took.
+     *
+     * Continuing the measured last step covers every way a particle can move —
+     * velocity integration, an orbit, noise, a plugin's own behavior — because
+     * it reads what happened rather than predicting from one term of it. Over
+     * less than a step it is a straight line through a path that may curve,
+     * which for a sixtieth of a second is well under a pixel.
+     *
+     * A particle born during the step has the same position on both sides and
+     * so does not move at all, which is what puts it at the emitter rather than
+     * a step's travel away from it.
+     */
+    private static extrapolate;
+    /** Pushes a zero-alpha instance so stale instancing data cannot linger on screen. */
+    private uploadClearedInstance;
+    dispose(): void;
 }
-declare class ParticleMeshPhysicsMaterial extends PBRMaterial {
-    readonly isParticleMeshPhysicsMaterial = true;
-    constructor(name: string, scene?: Scene, parameters?: BabylonParticleMaterialParameters);
+
+declare class TrailBatch extends VFXBatch {
+    private positionBuffer;
+    private previousBuffer;
+    private nextBuffer;
+    private uvBuffer;
+    private sideBuffer;
+    private widthBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    /** True while the batch is parked on the degenerate draw, see uploadGeometry. */
+    private drawsNothing;
+    private previousVB;
+    private nextVB;
+    private sideVB;
+    private widthVB;
+    constructor(settings: VFXBatchSettings, scene: Scene);
+    setupBuffers(): void;
+    private buildGeometryBuffers;
+    expandBuffers(target: number): void;
+    rebuildMaterial(): void;
+    private vector_;
+    private vector2_;
+    private vector3_;
+    private quaternion_;
+    /** Forces the emitter's world matrix to be current before sampling it. */
+    private static ensureWorldMatrix;
+    update(): void;
+    /**
+     * Uploads the vertex data written by `update` and resizes the sub mesh.
+     *
+     * Split out of `update` on purpose: the Babylon mesh/sub-mesh plumbing here
+     * runs a handful of times per frame, and folding it into the per-vertex loop
+     * costs that loop its optimised code.
+     */
+    private uploadGeometry;
+    /**
+     * Points every sub mesh at the mesh's own bounds.
+     *
+     * Updating indices rebuilds the sub meshes, and a fresh one computes its
+     * bounds from the vertex data — which this batch keeps deliberately stale
+     * beyond the range it draws. Transparent sorting reads those bounds every
+     * frame, so they have to be replaced again after every index update, not
+     * only when the geometry is built.
+     */
+    private adoptMeshBounds;
+    dispose(): void;
 }
 
-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 };
+export { ApplyCollision, ApplyForce, ApplySequences, AxisAngleGenerator, BatchedParticleRenderer, BatchedRenderer, BehaviorFromJSON, BehaviorTypes, Bezier, BoxEmitFrom, BoxEmitter, ChangeEmitDirection, CircleEmitter, ColorBySpeed, ColorGeneratorFromJSON, ColorOverLife, ColorRange, ConeEmitter, ConstantColor, ConstantValue, DEG2RAD, DonutEmitter, EdgeEmitter, 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, ParticleStore, ParticleSystem, PiecewiseBezier, PiecewiseFunction, Plugins, PointEmitter, QuarksLoader, QuarksPrefab, QuarksUtil, Quaternion, RAD2DEG, RandomColor, RandomColorBetweenGradient, RandomQuatGenerator, RecordState, RectangleEmitter, RenderMode, Rotation3DOverLife, RotationBySpeed, RotationGeneratorFromJSON, RotationOverLife, SequencerFromJSON, ShapeTransform, SizeBySpeed, SizeOverLife, SpeedOverLife, SphereEmitter, SpriteBatch, SpriteParticle, SubParticleEmitMode, TextureSequencer, TrailBatch, TrailParticle, TurbulenceField, VFXBatch, ValueGeneratorFromJSON, Vector2, Vector3, Vector3Function, Vector3GeneratorFromJSON, Vector3View, Vector4, Vector4View, VelocityOverLife, WebGLCoordinateSystem, WebGPUCoordinateSystem, WidthOverLength, cacheEnvAtlas, ceilPowerOfTwo, clamp, createEnvAtlasFromFaceUrls, cubeFaceUrls, damp, degToRad, denormalize, ensureEnvAtlasFromCube, euclideanModulo, floorPowerOfTwo, generateUUID, getCachedEnvAtlas, getPhysicsResolver, getRegisteredShaderChunks, getShaderChunk, getValueFromEmitterMode, inverseLerp, isPowerOfTwo, lerp, loadPlugin, _default$7 as localParticlePhysicsVertShader, _default$6 as localParticleVertShader, mapLinear, normalize, _default$5 as particleFragShader, _default$4 as particlePhysicsFragShader, _default$3 as particleVertShader, pingpong, planBehaviorFusion, radToDeg, randFloat, randFloatSpread, randInt, registerShaderChunks, seededRandom, setPhysicsResolver, setQuaternionFromProperEuler, smootherstep, smoothstep, _default$2 as stretchedBillboardVertShader, _default$1 as trailFragShader, _default as trailVertShader, unloadPlugin };
+export type { AdaptivePerformanceOptions, AdaptivePerformanceState, AnimationData, BabylonMetaData, BabylonParticleMaterialParameters, Behavior, BehaviorPlugin, BillBoardSettings, BoxEmitterParameters, BurstParameters, BurstParametersJSON, CircleEmitterParameters, ColorGenerator, ConeEmitterParameters, Constructable, DonutEmitterParameters, EdgeEmitterParameters, EmissionState, EmitterShape, EmitterShapePlugin, EulerOrder, FieldType, FunctionColorGenerator, FunctionJSON, FunctionValueGenerator, FusedPass, FusionStep, 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, ShapeTransformJSON, SphereEmitterParameters, StoredBatchSettings, StretchedBillBoardSettings, TrailSettings, VFXBatchSettings, ValueGenerator, Vector3Generator, VelocityOverLifeSpace };