babylon.quarks 0.19.0 → 0.20.0

package/dist/types/index.d.ts

@@ -640,7 +640,7 @@ declare class Gradient implements FunctionColorGenerator {
     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. */
+    /** 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
@@ -787,7 +787,11 @@ declare class PiecewiseBezier extends PiecewiseFunction<Bezier> implements Funct
      * See {@link refreshTable}.
      */
     private table;
-    /** Control points the table was built from, used to detect edits. */
+    /**
+     * 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.
@@ -993,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 {
     /**
@@ -1105,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). */
@@ -1431,6 +1466,12 @@ 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.
@@ -1890,13 +1931,13 @@ declare class ForceOverLife implements Behavior {
 declare class FrameOverLife implements Behavior {
     type: string;
     private _frame;
-    private _frameIsBezier;
-    constructor(frame: FunctionValueGenerator);
-    get frame(): FunctionValueGenerator;
-    set frame(frame: FunctionValueGenerator);
+    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;
@@ -2261,6 +2302,44 @@ interface IPrefab {
     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[];
+}
+/**
+ * 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 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;
+    };
+    clone(): ShapeTransform;
+}
+
 interface ShapeJSON {
     type: string;
     radius?: number;
@@ -2270,6 +2349,9 @@ interface ShapeJSON {
     angle?: number;
     width?: number;
     height?: number;
+    depth?: number;
+    emitFrom?: number;
+    boxThickness?: number[];
     column?: number;
     row?: number;
     mesh?: string;
@@ -2277,6 +2359,8 @@ interface ShapeJSON {
     particleSystem?: string;
     spread?: number;
     speed?: any;
+    /** Local offset / rotation / scale of the shape; omitted when there is none. */
+    transform?: ShapeTransformJSON;
 }
 /**
  * Enum representing the emitter modes for particles.
@@ -2306,6 +2390,66 @@ interface EmitterShape {
     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;
+}
+
+/**
+ * Which part of the box particles start from.
+ */
+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;
+    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;
 }
 
 /**
@@ -2340,6 +2484,11 @@ interface CircleEmitterParameters {
      * {@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.
@@ -2353,6 +2502,7 @@ declare class CircleEmitter implements EmitterShape {
     spread: number;
     speed: ValueGenerator | FunctionValueGenerator;
     memory: GeneratorMemory;
+    transform?: ShapeTransform;
     private currentValue;
     constructor(parameters?: CircleEmitterParameters);
     update(system: IParticleSystem, delta: number): void;
@@ -2397,6 +2547,11 @@ interface ConeEmitterParameters {
      * {@link EmitterMode}
      */
     speed?: ValueGenerator | FunctionValueGenerator;
+    /**
+     * Offset, rotation and scale of the shape within the particle system.
+     * {@link ShapeTransform}
+     */
+    transform?: ShapeTransform;
 }
 declare class ConeEmitter implements EmitterShape {
     type: string;
@@ -2408,6 +2563,7 @@ declare class ConeEmitter implements EmitterShape {
     spread: number;
     speed: ValueGenerator | FunctionValueGenerator;
     memory: GeneratorMemory;
+    transform?: ShapeTransform;
     private currentValue;
     constructor(parameters?: ConeEmitterParameters);
     update(system: IParticleSystem, delta: number): void;
@@ -2452,6 +2608,11 @@ interface DonutEmitterParameters {
      * {@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;
@@ -2463,6 +2624,7 @@ declare class DonutEmitter implements EmitterShape {
     spread: number;
     speed: ValueGenerator | FunctionValueGenerator;
     memory: GeneratorMemory;
+    transform?: ShapeTransform;
     _m1: Matrix4;
     constructor(parameters?: DonutEmitterParameters);
     private currentValue;
@@ -2473,6 +2635,48 @@ declare class DonutEmitter implements EmitterShape {
     clone(): EmitterShape;
 }
 
+/**
+ * Interface representing the parameters for an edge emitter.
+ */
+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;
+}
+/**
+ * A particle emitter that emits particles from a line along X, all moving along +Y like Unity's
+ * single-sided Edge shape.
+ */
+declare class EdgeEmitter implements EmitterShape {
+    type: string;
+    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 EmitterShapePlugin {
     type: string;
     constructor: Constructable<EmitterShape>;
@@ -2504,6 +2708,11 @@ interface GridEmitterParameters {
      * The number of rows in the grid.
      */
     row?: number;
+    /**
+     * Offset, rotation and scale of the shape within the particle system.
+     * {@link ShapeTransform}
+     */
+    transform?: ShapeTransform;
 }
 declare class GridEmitter implements EmitterShape {
     type: string;
@@ -2511,6 +2720,7 @@ declare class GridEmitter implements EmitterShape {
     height: number;
     column: number;
     row: number;
+    transform?: ShapeTransform;
     constructor(parameters?: GridEmitterParameters);
     initialize(p: Particle): void;
     toJSON(): ShapeJSON;
@@ -2550,6 +2760,11 @@ interface HemisphereEmitterParameters {
      * {@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;
@@ -2560,6 +2775,7 @@ declare class HemisphereEmitter implements EmitterShape {
     spread: number;
     speed: ValueGenerator | FunctionValueGenerator;
     memory: GeneratorMemory;
+    transform?: ShapeTransform;
     _m1: Matrix4;
     constructor(parameters?: HemisphereEmitterParameters);
     private currentValue;
@@ -2576,7 +2792,12 @@ declare class HemisphereEmitter implements EmitterShape {
 declare class PointEmitter implements EmitterShape {
     type: string;
     _m1: Matrix4;
-    constructor();
+    /**
+     * 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;
@@ -2616,6 +2837,11 @@ interface RectangleEmitterParameters {
      * {@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 rectangle.
@@ -2629,6 +2855,7 @@ declare class RectangleEmitter implements EmitterShape {
     spread: number;
     speed: ValueGenerator | FunctionValueGenerator;
     memory: GeneratorMemory;
+    transform?: ShapeTransform;
     private currentValue;
     private _m1;
     constructor(parameters?: RectangleEmitterParameters);
@@ -2670,6 +2897,11 @@ interface SphereEmitterParameters {
      * {@link EmitterMode}
      */
     speed?: ValueGenerator | FunctionValueGenerator;
+    /**
+     * Offset, rotation and scale of the shape within the particle system.
+     * {@link ShapeTransform}
+     */
+    transform?: ShapeTransform;
 }
 declare class SphereEmitter implements EmitterShape {
     type: string;
@@ -2680,6 +2912,7 @@ declare class SphereEmitter implements EmitterShape {
     spread: number;
     speed: ValueGenerator | FunctionValueGenerator;
     memory: GeneratorMemory;
+    transform?: ShapeTransform;
     _m1: Matrix4;
     constructor(parameters?: SphereEmitterParameters);
     private currentValue;
@@ -2745,6 +2978,8 @@ interface StoredBatchSettings {
     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;
@@ -2809,6 +3044,14 @@ interface VFXBatchSettings {
      */
     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;
@@ -2934,9 +3177,11 @@ declare class MeshSurfaceEmitter implements EmitterShape {
     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);
+    constructor(mesh?: Mesh, meshReferenceId?: string, transform?: ShapeTransform);
     initialize(p: Particle): void;
     toJSON(): ShapeJSON;
     static fromJSON(json: any): MeshSurfaceEmitter;
@@ -2988,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;
@@ -3014,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 {
@@ -3039,6 +3290,7 @@ interface ParticleSystemJSONParameters {
     emissionOverTime: FunctionJSON;
     emissionOverDistance: FunctionJSON;
     emissionBursts?: Array<BurstParametersJSON>;
+    maxParticles?: number;
     onlyUsedByOther: boolean;
     rendererEmitterSettings: RendererEmitterSettings;
     instancingGeometry?: any;
@@ -3062,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: {
@@ -3103,9 +3359,17 @@ 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;
@@ -3164,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;
@@ -3264,14 +3537,40 @@ declare class ParticleSystem implements IParticleSystem {
 
 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;
@@ -3293,7 +3592,7 @@ declare class QuarksLoader {
      * 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;
@@ -3375,9 +3674,9 @@ declare const _default$5: "\nvarying vec2 vUV;\nvarying vec4 vColor;\n\n#ifdef T
 
 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: "\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$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: "\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";
 
@@ -3419,6 +3718,8 @@ declare class SpriteBatch extends VFXBatch {
     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.
@@ -3429,6 +3730,16 @@ declare class SpriteBatch extends VFXBatch {
      * 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`.
@@ -3516,5 +3827,5 @@ declare class TrailBatch extends VFXBatch {
     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, ParticleStore, 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, 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, BurstParameters, BurstParametersJSON, CircleEmitterParameters, ColorGenerator, ConeEmitterParameters, Constructable, DonutEmitterParameters, 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, 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "babylon.quarks",
-    "version": "0.19.0",
+    "version": "0.20.0",
     "description": "A High-Performance Particle System for Babylon.js",
     "type": "module",
     "types": "./dist/types/index.d.ts",