babylon.quarks 0.28.0 → 0.29.0

package/dist/types/index.d.cts

@@ -10,6 +10,7 @@ import { ShaderMaterial } from '@babylonjs/core/Materials/shaderMaterial.js';
 import { Mesh } from '@babylonjs/core/Meshes/mesh.js';
 import { Node } from '@babylonjs/core/node.js';
 import { Color3 } from '@babylonjs/core/Maths/math.color.js';
+import { IImageProcessingConfigurationDefines } from '@babylonjs/core/Materials/imageProcessingConfiguration.defines.js';
 
 /**
  * A two-component vector (a three.js `Vector2` port), used for 2D quantities such as texture
@@ -1783,8 +1784,17 @@ interface PiecewiseBezierJSON {
     /** The curve's segments, each with the time it starts at. */
     functions: PiecewiseBezierSegmentJSON[];
 }
+/** A {@link RandomBetweenCurves}. */
+interface RandomBetweenCurvesJSON {
+    /** The generator's type. */
+    type: 'RandomBetweenCurves';
+    /** One bound. */
+    curve1: PiecewiseBezierJSON;
+    /** The other bound. */
+    curve2: PiecewiseBezierJSON;
+}
 /** The JSON of a value generator. */
-type ValueGeneratorJSON = ConstantValueJSON | IntervalValueJSON | PiecewiseBezierJSON;
+type ValueGeneratorJSON = ConstantValueJSON | IntervalValueJSON | PiecewiseBezierJSON | RandomBetweenCurvesJSON;
 /** A {@link ConstantColor}. */
 interface ConstantColorJSON {
     /** The generator's type. */
@@ -1958,7 +1968,7 @@ type FunctionJSON = ValueGeneratorJSON | ColorGeneratorJSON | RotationGeneratorJ
  * - **Stateless / deterministic** (`ConstantValue`, `PiecewiseBezier`,
  *   `Gradient`, `RandomColor`) — `startGen` is a no-op; `genValue` derives
  *   output from inputs (`t`, params) alone.
- * - **Sample-once stochastic** (`IntervalValue`, `ColorRange`,
+ * - **Sample-once stochastic** (`IntervalValue`, `RandomBetweenCurves`, `ColorRange`,
  *   `RandomColorBetweenGradient`, `RandomQuatGenerator`) — `startGen` pushes
  *   one random sample into memory; `genValue` reads it. This is what keeps a
  *   given particle's "random" startSize/color/rotation fixed for its life.
@@ -1973,6 +1983,8 @@ type FunctionJSON = ValueGeneratorJSON | ColorGeneratorJSON | RotationGeneratorJ
  * - `indexCount` lives on the generator (shared across particles), not on
  *   memory. It is overwritten on every spawn; that is safe because each
  *   `genValue` call during a spawn happens before the next spawn's `startGen`.
+ *   So a stochastic instance must not be shared between two settings or two
+ *   systems: give each its own, by `clone()`.
  * - The values stored in memory are not aliased — each particle's memory is
  *   its own array, so two particles can hold different samples at the same
  *   slot without interference.
@@ -2528,6 +2540,55 @@ declare class PiecewiseBezier extends PiecewiseFunction<Bezier> implements Funct
     startGen(memory: GeneratorMemory): void;
 }
 
+/**
+ * A number over time between two curves, at a mix rolled once per particle and kept for its life
+ * (Unity's Random Between Two Curves): each particle follows its own curve, the same fraction of the
+ * way from {@link RandomBetweenCurves.curve1} to {@link RandomBetweenCurves.curve2} at every `t`.
+ * Where it drives a start value, `t` is the system's cycle, as for any curve there.
+ *
+ * Where a system-level setting takes it (emission over time or distance, a burst's count, a shape's
+ * speed, Noise's scroll speed), the mix is rolled once per play rather than at every emission step,
+ * as a random range is there.
+ *
+ * Like every random generator, an instance holds the memory slot of its mix: give each setting its
+ * own instance, and {@link RandomBetweenCurves.clone} one to reuse it.
+ */
+declare class RandomBetweenCurves implements FunctionValueGenerator {
+    curve1: PiecewiseBezier;
+    curve2: PiecewiseBezier;
+    /** Always `'function'`: the number depends on `t`. */
+    readonly type: "function";
+    /**
+     * The slot of {@link GeneratorMemory} the mix lives in; -1 before the first roll.
+     * @internal
+     */
+    indexCount: number;
+    /**
+     * @param curve1 - One bound (Unity's lower curve).
+     * @param curve2 - The other bound (Unity's upper curve).
+     */
+    constructor(curve1: PiecewiseBezier, curve2: PiecewiseBezier);
+    /** Rolls the particle's mix between the curves into a new slot of `memory`. */
+    startGen(memory: GeneratorMemory): void;
+    /** Has both curves sample their tables, as a single curve does; see {@link PiecewiseBezier.refreshTable}. */
+    refreshTable(): void;
+    /**
+     * The particle's number at `t`; rolls its mix first if {@link RandomBetweenCurves.startGen}
+     * never has. A particle that was not rolled for this instance (one alive when the setting was
+     * replaced) takes the midway curve rather than a missing mix.
+     */
+    genValue(memory: GeneratorMemory, t?: number): number;
+    /** The JSON form, `{type: 'RandomBetweenCurves', curve1, curve2}`. */
+    toJSON(): RandomBetweenCurvesJSON;
+    /**
+     * Reads {@link RandomBetweenCurves.toJSON} output. A bound that is missing or not a curve warns
+     * (throws when strict) and reads as a flat 0 curve, so one bad value does not cost the effect.
+     */
+    static fromJSON(json: RandomBetweenCurvesJSON): RandomBetweenCurves;
+    /** A copy with copies of both curves. */
+    clone(): RandomBetweenCurves;
+}
+
 /**
  * A uniformly random rotation, rolled once per particle and kept for its life. Call
  * {@link RandomQuatGenerator.startGen} with each particle's memory when it spawns.
@@ -2976,7 +3037,10 @@ interface IEmitter {
     uuid: string;
     /** Whether the node, and so the system, is visible. */
     visible: boolean;
-    /** The node's world matrix. */
+    /**
+     * The matrix the system simulates and draws in: the node's world matrix, with the scale its
+     * scaling mode applies on each axis (babylon.quarks' `ScalingMode`).
+     */
     matrixWorld: Matrix4;
 }
 /**
@@ -3024,9 +3088,9 @@ interface IParticleSystem {
      */
     simulationStep?: number;
     /**
-     * What world-space forces and speed limits are multiplied by: the
-     * emitter's world scale when the system scales its motion with it (a
-     * world-space system in `'hierarchy'` scaling mode), 1 or undefined
+     * What world-space forces and speed limits are multiplied by: the mean
+     * scale of {@link IEmitter.matrixWorld}'s axes for a world-space system,
+     * which carries what its scaling mode scales motion by; 1 or undefined
      * otherwise.
      * @type {number}
      */
@@ -3044,10 +3108,22 @@ interface IParticleSystem {
      */
     readonly isDisposed?: boolean;
     /**
-     * Whether the ParticleSystem should be automatically disposed when it finishes emitting particles.
-     * @type {string}
+     * Whether the system is disposed once it has finished.
+     * @deprecated Read {@link IParticleSystem.stopAction}: true is `'destroy'`.
+     * @type {boolean}
      */
     autoDestroy: boolean;
+    /**
+     * What the system does once it has finished, as Unity's Stop Action: nothing (`'none'`),
+     * disable its emitter (`'disable'`) or dispose itself (`'destroy'`). Undefined is `'none'`.
+     */
+    stopAction?: 'none' | 'disable' | 'destroy';
+    /**
+     * Whether particles outlive their lifetime: held or looped at the end of it until new ones
+     * replace them, as with Unity's Ring Buffer Mode on a full system. A Death sub emitter does
+     * not fire for them, since they do not die.
+     */
+    readonly ringBufferActive?: boolean;
     /**
      * Whether the system is in world space.
      * @type {boolean}
@@ -3097,8 +3173,11 @@ interface IParticleSystem {
     paused: boolean;
     /** True after `endEmit()` — emission window closed (non-looping duration elapsed). */
     readonly isEmitEnded: boolean;
-    /** Whether more particles can still spawn (bursts, rate, distance). */
-    hasPendingEmission(): boolean;
+    /**
+     * Whether more particles can still spawn (bursts, rate, distance): from the system's own
+     * emission, or with `state` from one a sub emitter runs into it for a parent particle.
+     */
+    hasPendingEmission(state?: EmissionState): boolean;
     /** Non-looping system with no live particles and no pending emission. */
     isFinished(): boolean;
     /** Freezes the system where it is until {@link IParticleSystem.play}. */
@@ -3749,10 +3828,11 @@ interface Constructable<T> {
 /**
  * The kind of a field an editor shows for a shape or behavior: a number, an angle (`'radian'`), a
  * vector, a generator of some kind, a reference to a mesh or system, an enum (`'emitterMode'`,
- * `'boxEmitFrom'`), a shape's local transform (`'shapeTransform'`), the properties a sub emitter
- * inherits (`'subEmitterInherit'`, a list of `SubEmitterInheritance`), and so on.
+ * `'boxEmitFrom'`, `'coneEmitFrom'`, `'gridSampling'`), a shape's local transform
+ * (`'shapeTransform'`), the properties a sub emitter inherits (`'subEmitterInherit'`, a list of
+ * `SubEmitterInheritance`), and so on.
  */
-type FieldType = 'vec3' | 'value' | 'number' | 'range' | 'colorFunc' | 'valueFunc' | 'rotationFunc' | 'radian' | 'mesh' | 'particleSystem' | 'boolean' | 'string' | 'geometry' | 'emitterMode' | 'boxEmitFrom' | 'subEmitterInherit' | 'shapeTransform' | 'vec3Func';
+type FieldType = 'vec3' | 'value' | 'number' | 'range' | 'colorFunc' | 'valueFunc' | 'rotationFunc' | 'radian' | 'mesh' | 'particleSystem' | 'boolean' | 'string' | 'geometry' | 'emitterMode' | 'boxEmitFrom' | 'coneEmitFrom' | 'gridSampling' | 'subEmitterInherit' | 'shapeTransform' | 'vec3Func';
 /** A {@link FieldType}, or `'self'` for a field that refers to the system itself. */
 type ParameterType = FieldType | 'self';
 /**
@@ -3972,7 +4052,7 @@ declare class EmitterFrame {
     readonly position: Vector3;
     /** The emitter's world rotation. */
     readonly quaternion: Quaternion;
-    /** The emitter's world scale per axis. */
+    /** The scale per axis of the emitter's `matrixWorld`, which its scaling mode sets. */
     readonly scale: Vector3;
     /** Inverse of {@link quaternion}. */
     readonly quaternionInverse: Quaternion;
@@ -3986,6 +4066,11 @@ declare class EmitterFrame {
      * true. A vector already in the simulation space is left as it is.
      */
     toSimulation(vector: Vector3, space: BehaviorSpace, worldSpace: boolean): Vector3;
+    /**
+     * The inverse of {@link toSimulation}: converts the direction `vector`, in the simulation
+     * space, into `space`. A vector already in `space` is left as it is.
+     */
+    fromSimulation(vector: Vector3, space: BehaviorSpace, worldSpace: boolean): Vector3;
     /**
      * Converts the point `point`, authored in `space`, into the simulation
      * space, as {@link toSimulation} does for a direction but with the
@@ -4418,6 +4503,13 @@ declare class EmitSubParticleSystem implements Behavior {
     inherit?: SubEmitterInheritance[]);
     initialize(particle: Particle): void;
     update(particle: Particle, delta: number): void;
+    /**
+     * Whether emissions that parent particles started into the target are still running, so the
+     * target has more particles to come. The parent is not finished while it has any.
+     */
+    hasPendingEmission(): boolean;
+    /** The system this behavior emits into, when it is set, linked and not disposed. */
+    get targetSystem(): IParticleSystem | undefined;
     /**
      * The system to emit into, or undefined when `subParticleSystem` does not
      * hold a resolved emitter — unset, or a uuid string a loader could not
@@ -4737,18 +4829,27 @@ declare class InheritVelocity implements Behavior {
 
 /** The JSON of a speed limit over life: a {@link LimitSpeedOverLife}. */
 interface LimitSpeedOverLifeJSON extends BehaviorJSON {
-    /** The limit. */
-    speed: ValueGeneratorJSON;
+    /** The limit: one curve for the speed, or a `Vector3Function` for each axis. */
+    speed: ValueGeneratorJSON | Vector3FunctionJSON;
     /** How much excess speed goes per step; 1 when absent. */
     dampen?: number;
+    /** The space of per-axis limits; `'local'` when absent. Written only when not the default. */
+    space?: BehaviorSpace;
 }
 /**
  * Limits the speed of particles over their life, like Unity's Limit Velocity over Lifetime: a
  * particle faster than `speed` loses part of the excess each step.
+ *
+ * With a {@link Vector3Function} as `speed` it is Unity's Separate Axes: each component of the
+ * velocity, measured along the axes of {@link space}, is limited by its own curve and keeps its
+ * sign. Applies in every render mode.
  */
 declare class LimitSpeedOverLife implements Behavior {
-    /** The speed limit over the particle's life. */
-    speed: FunctionValueGenerator;
+    /**
+     * The speed limit over the particle's life: one curve for the speed, or a
+     * {@link Vector3Function} with a limit for each axis (Unity's Separate Axes).
+     */
+    speed: FunctionValueGenerator | ValueGenerator | Vector3Function;
     /**
      * How much of the excess speed goes, from 0 (none) to 1, clamped. At 60 steps a second each
      * step removes `dampen / 3` of it; other step lengths remove the share that compounds to the
@@ -4756,22 +4857,58 @@ declare class LimitSpeedOverLife implements Behavior {
      * limit is approached over a few steps rather than held exactly.
      */
     dampen: number;
+    /**
+     * The axes per-axis limits are measured along, as Unity's Space setting: the emitter's own
+     * (`'local'`, the default), which turn and scale with it, or the world's. A single speed
+     * limit has no axes and ignores it.
+     */
+    space: BehaviorSpace;
     type: string;
     /** Learned in {@link initialize}; its motion scale multiplies the limit of a world-space system. */
     ps?: IParticleSystem;
+    /** The emitter's transform this frame, refreshed by {@link frameUpdate} for per-axis limits. */
+    readonly _frame: EmitterFrame;
+    /**
+     * Scratch values.
+     * @internal
+     */
+    _limit: Vector3;
+    /** @internal */
+    _velocity: Vector3;
     initialize(particle: Particle, particleSystem?: IParticleSystem): void;
     /** What the limit is multiplied by: the system's motion scale in world space, else 1. */
     motionScale(): number;
     constructor(
-    /** The speed limit over the particle's life. */
-    speed: FunctionValueGenerator, 
+    /**
+     * The speed limit over the particle's life: one curve for the speed, or a
+     * {@link Vector3Function} with a limit for each axis (Unity's Separate Axes).
+     */
+    speed: FunctionValueGenerator | ValueGenerator | Vector3Function, 
     /**
      * How much of the excess speed goes, from 0 (none) to 1, clamped. At 60 steps a second each
      * step removes `dampen / 3` of it; other step lengths remove the share that compounds to the
      * same loss per second, so the result does not depend on the frame rate. Even at 1 the
      * limit is approached over a few steps rather than held exactly.
      */
-    dampen: number);
+    dampen: number, 
+    /**
+     * The axes per-axis limits are measured along, as Unity's Space setting: the emitter's own
+     * (`'local'`, the default), which turn and scale with it, or the world's. A single speed
+     * limit has no axes and ignores it.
+     */
+    space?: BehaviorSpace);
+    /**
+     * Whether the frame is read: per-axis limits authored in another space than the simulation's.
+     * @internal
+     */
+    _convertsSpace(): boolean;
+    /**
+     * Limits each axis of `velocity` (in the simulation space) by the per-axis limits at `t`.
+     * The excess is worked out in {@link space} and taken off in the simulation space, so an axis
+     * the emitter's scale flattens keeps its velocity rather than losing it.
+     * @internal
+     */
+    _limitAxes(particle: Particle, t: number, step: number, motionScale: number, convert: boolean): void;
     /** The share of the excess speed one step of `delta` seconds removes; see {@link dampen}. */
     dampenStep(delta: number): number;
     update(particle: Particle, delta: number): void;
@@ -4779,7 +4916,8 @@ declare class LimitSpeedOverLife implements Behavior {
     toJSON(): LimitSpeedOverLifeJSON;
     /**
      * Reads {@link LimitSpeedOverLife.toJSON} output; a field the JSON leaves out takes its
-     * default.
+     * default, and a speed that is neither a number generator nor a `Vector3Function` warns and
+     * reads as 0.
      */
     static fromJSON(json: LimitSpeedOverLifeJSON): Behavior;
     frameUpdate(delta: number): void;
@@ -5557,14 +5695,21 @@ interface ShapeJSON {
     height?: number;
     /** Depth of a box. */
     depth?: number;
-    /** Where a box emits from (its volume, shell or edges), a `BoxEmitFrom` value. */
+    /**
+     * Where a box emits from (its volume, shell or edges), a `BoxEmitFrom` value; where a cone
+     * does (its base or volume), a `ConeEmitFrom` value.
+     */
     emitFrom?: number;
+    /** Height of the volume a cone emits from with `ConeEmitFrom.Volume`. */
+    length?: number;
     /** Thickness of a box's shell along x, y and z. */
     boxThickness?: number[];
     /** Columns of a grid. */
     column?: number;
     /** Rows of a grid. */
     row?: number;
+    /** How a grid picks its cells, a `GridSampling` value. */
+    sampling?: number;
     /** Uuid of the mesh a mesh-surface shape emits from. */
     mesh?: string;
     /** The {@link EmitterMode} of the shape's arc. */
@@ -5796,6 +5941,15 @@ declare class CircleEmitter implements EmitterShape {
     clone(): EmitterShape;
 }
 
+/**
+ * Which part of a cone particles start from (Unity's Cone Emit from).
+ */
+declare enum ConeEmitFrom {
+    /** The base disc, as Unity's Base. */
+    Base = 0,
+    /** Anywhere along the cone, from the base out to {@link ConeEmitter.length}, as Unity's Volume. */
+    Volume = 1
+}
 /**
  * Interface representing the parameters for a cone emitter.
  */
@@ -5821,6 +5975,16 @@ interface ConeEmitterParameters {
      * Defaults to π/6.
      */
     angle?: number;
+    /**
+     * Which part of the cone particles start from; {@link ConeEmitFrom.Base}, the default, for the
+     * base disc only.
+     */
+    emitFrom?: ConeEmitFrom;
+    /**
+     * Height of the cone along +z that {@link ConeEmitFrom.Volume} fills (Unity's Length); a
+     * negative or non-finite value is read as 0. Defaults to 5, as in Unity. The base ignores it.
+     */
+    length?: number;
     /**
      * The mode of the emitter.
      * {@link EmitterMode}
@@ -5844,7 +6008,10 @@ interface ConeEmitterParameters {
 }
 /**
  * Emits from a disc in the xy plane into a cone along +z (Unity's Cone shape): a particle at the
- * disc's rim heads out at the cone's angle, one at the centre straight along z.
+ * disc's rim heads out at the cone's angle, one at the centre straight along z, and one between
+ * them along the cone's side lines, tilted by atan(r · tan(angle)) at the fraction r of the radius.
+ * With {@link ConeEmitFrom.Volume}, particles start anywhere on those lines up to
+ * {@link ConeEmitter.length} along z.
  */
 declare class ConeEmitter implements EmitterShape {
     /** Always `'cone'`. */
@@ -5863,6 +6030,14 @@ declare class ConeEmitter implements EmitterShape {
      * π/2.
      */
     angle: number;
+    /** Which part of the cone particles start from, see {@link ConeEmitFrom}. */
+    emitFrom: ConeEmitFrom;
+    /**
+     * Height along +z of the volume {@link ConeEmitFrom.Volume} fills; read as 0 when negative or
+     * not finite. Side lines steeper than 89° from the axis are followed as if at 89°, so a cone
+     * opened to 90° fills out to about 57 times the length past the rim, not infinitely far.
+     */
+    length: number;
     /** How the start point moves along the arc, see {@link EmitterMode}. */
     mode: EmitterMode;
     /**
@@ -6103,6 +6278,20 @@ declare function EmitterFromJSON(json: ShapeJSON, meta: JsonMetaData): EmitterSh
  */
 declare function EmitterToJSON(shape: EmitterShape, meta?: JsonMetaData): ShapeJSON;
 
+/**
+ * How a grid emitter picks the cell each particle starts in.
+ */
+declare enum GridSampling {
+    /** A random cell for every particle. */
+    Random = 0,
+    /**
+     * The cells in turn, row by row from the one at -x, -y, starting over after the last, as
+     * Niagara's Grid Location fills its cells by particle index: a burst of `row × column`
+     * particles puts one in every cell. The turn carries on across bursts, loop cycles and prewarm;
+     * only a restart (the shape's `reset()`) starts it over. Meant for grids of up to 2^53 cells.
+     */
+    Sequential = 1
+}
 /**
  * Interface representing the parameters for a grid emitter.
  */
@@ -6123,6 +6312,8 @@ interface GridEmitterParameters {
      * The number of rows in the grid.
      */
     row?: number;
+    /** How each particle's cell is picked; {@link GridSampling.Random}, the default, at random. */
+    sampling?: GridSampling;
     /**
      * Offset, rotation and scale of the shape within the particle system.
      * {@link ShapeTransform}
@@ -6130,8 +6321,9 @@ interface GridEmitterParameters {
     transform?: ShapeTransform;
 }
 /**
- * Emits from the cells of a grid in the xy plane, centred on the origin and heading along +z: each particle starts at the centre of a random cell, so a 2 × 2 grid of
- * width 2 emits from x = ±0.5.
+ * Emits from the cells of a grid in the xy plane, centred on the origin and heading along +z: each
+ * particle starts at the centre of a cell, picked at random or in turn (see {@link GridSampling}),
+ * so a 2 × 2 grid of width 2 emits from x = ±0.5.
  */
 declare class GridEmitter implements EmitterShape {
     /** Always `'grid'`. */
@@ -6144,10 +6336,15 @@ declare class GridEmitter implements EmitterShape {
     column: number;
     /** Cells along y; read as a whole number of at least 1, and as 1 when not finite. */
     row: number;
+    /** How each particle's cell is picked, see {@link GridSampling}. */
+    sampling: GridSampling;
     transform?: ShapeTransform;
+    /** The cell the next {@link GridSampling.Sequential} particle starts in. */
+    private nextCell;
     constructor(parameters?: GridEmitterParameters);
     /**
-     * Starts `p` at the centre of a random cell of the grid, heading along +z at its start speed.
+     * Starts `p` at the centre of a cell of the grid, picked by {@link GridEmitter.sampling},
+     * heading along +z at its start speed.
      */
     initialize(p: Particle): void;
     /** The shape's JSON. */
@@ -6156,8 +6353,10 @@ declare class GridEmitter implements EmitterShape {
     static fromJSON(json: ShapeJSON): GridEmitter;
     /** A copy with the same settings. */
     clone(): EmitterShape;
-    /** Does nothing: the grid has no state. */
+    /** Does nothing: the grid only moves on as it emits. */
     update(system: IParticleSystem, delta: number): void;
+    /** Starts {@link GridSampling.Sequential} over at the first cell, so a restart replays the same cells. */
+    reset(): void;
 }
 
 /**
@@ -6967,6 +7166,8 @@ interface StoredBatchSettings {
     renderingGroupId: number;
     /** Whether the scene's fog is applied, see {@link VFXBatchSettings.applyFog}. */
     applyFog: boolean;
+    /** Whether the scene's image processing is applied, see {@link VFXBatchSettings.applyImageProcessing}. */
+    applyImageProcessing: boolean;
     /** Billboard pivot in particle-size units, see {@link VFXBatchSettings.pivot}. */
     pivot?: Vector3;
     /** Draw order within the batch, see {@link SortMode}. */
@@ -6991,6 +7192,135 @@ interface StoredBatchSettings {
     erosion?: ParticleErosion;
 }
 
+/**
+ * Picking the shader language a batch compiles in, and putting the source where
+ * the engine will look for it.
+ *
+ * WebGPU speaks WGSL. Handing it GLSL is not an error — Babylon transpiles —
+ * but the transpilers are two WASM modules it downloads from cdn.babylonjs.com
+ * the first time a GLSL shader is compiled. That is a third-party request on
+ * first draw, a hard failure under a Content-Security-Policy that does not list
+ * the CDN or with no network at all, and a GLSL to SPIR-V to WGSL round trip
+ * before the first particle appears. Shipping the WGSL means none of that
+ * happens.
+ *
+ * The two languages live in separate stores keyed by the same name, so a scene
+ * that somehow ran both would not collide.
+ */
+interface ShaderSources {
+    /** GLSL source, used on every WebGL engine. */
+    glsl: string;
+    /** WGSL source, used on WebGPU. */
+    wgsl: string;
+}
+
+/**
+ * The part of a batch's settings that decides its shader: the render mode, which textures and
+ * effects are compiled in, and the blend state the fog and the fade read. Everything else a
+ * batch holds (geometry, draw order, the effects' parameters) is a buffer or a uniform value.
+ */
+type ShaderSettings = Pick<StoredBatchSettings, 'renderMode' | 'texture' | 'reflectionAtlas' | 'uTileCount' | 'vTileCount' | 'blendTiles' | 'softParticles' | 'materialAlphaTest' | 'materialTransparent' | 'materialBlendMode' | 'applyFog' | 'applyImageProcessing' | 'pivot' | 'minParticleSize' | 'maxParticleSize' | 'lighting' | 'rim' | 'mapUV' | 'uvDistortion' | 'gradientMap' | 'erosion'>;
+/** What the material needs to know about the depth texture soft particles read. */
+interface ShaderDepth {
+    /** Whether the depth is packed into four 8-bit channels, as a `DepthRenderer` of type `UNSIGNED_BYTE` writes it. */
+    packed: boolean;
+}
+/**
+ * What a batch knows at compile time that its settings do not say: whether the textures it
+ * depends on are there to be sampled.
+ */
+interface ShaderContext {
+    /**
+     * The depth texture soft particles read, when one is attached to the renderer. Soft particles
+     * compile only with a depth texture.
+     */
+    depth: ShaderDepth | null;
+    /** Whether the mesh batch's reflection atlas has finished loading; it is sampled only then. */
+    envAtlasReady: boolean;
+    /** Whether the mesh batch has a second UV set to read for {@link UVChannel} 1. */
+    meshUV2: boolean;
+    /**
+     * The scene's image processing as `ImageProcessingConfiguration.prepareDefines` writes it;
+     * null or left out for none. Compiled in only when the settings apply it, see
+     * {@link ParticleSystem.applyImageProcessing}.
+     */
+    imageProcessing?: ShaderImageProcessing | null;
+}
+/**
+ * The defines an `ImageProcessingConfiguration` prepares for a material
+ * (`ImageProcessingConfigurationDefines`): which of its effects are on, and whether a post
+ * process applies it instead.
+ */
+type ShaderImageProcessing = Readonly<IImageProcessingConfigurationDefines>;
+/**
+ * One compiled shader of the library: the sources in both languages and the defines, attributes,
+ * uniforms and samplers the material is built with. Built by {@link shaderProgram} from a
+ * batch's settings, so a batch and a shader validator describe the same material.
+ */
+interface ShaderProgram {
+    /** The name the sources are registered under in Babylon's shader store, one per render mode. */
+    name: string;
+    /** The vertex shader in both languages. */
+    vertex: ShaderSources;
+    /** The fragment shader in both languages. */
+    fragment: ShaderSources;
+    /** The preprocessor defines, without the `#define`. */
+    defines: string[];
+    /** The vertex attributes the material binds. */
+    attributes: string[];
+    /** The uniforms the material declares. */
+    uniforms: string[];
+    /** The texture samplers the material declares. */
+    samplers: string[];
+}
+/**
+ * How a particle's colour has to leave the fragment shader for its blend mode, so that its alpha
+ * means coverage: alpha 0 leaves the frame as it was, alpha 1 draws the colour in full, and the
+ * fades (soft particles, erosion, a rim fade, alpha over life) only lower alpha. Unity's particle
+ * shaders do the same for their Alpha, Premultiply, Additive and Multiply modes. Alpha has no
+ * such meaning for an opaque material, nor under `ALPHA_INTERPOLATE` (constant blend colour),
+ * `ALPHA_REPLACE_COLOR` (replaces the frame) and `ALPHA_DUAL_SRC0_ADD_SRC1xDST` (reads a second
+ * shader output the particle shaders do not write); these leave the colour as it is.
+ *
+ * - `'straight'`: the blend weighs the colour by its alpha itself (Babylon's `ALPHA_COMBINE`,
+ *   `ALPHA_ADD`, `ALPHA_LAYER_ACCUMULATE`, …) or does not blend; the colour leaves as it is.
+ * - `'premultiply'`: the blend takes the colour at full weight, or the frame by one minus the
+ *   colour (`ALPHA_PREMULTIPLIED`, `ALPHA_ONEONE`, `ALPHA_SCREENMODE`, `ALPHA_SUBTRACT`,
+ *   `ALPHA_MAXIMIZED`, `ALPHA_MAX`, …), so the shader multiplies it by its alpha: black, which
+ *   these modes leave the frame alone with, at alpha 0. Textures stay straight alpha, as in
+ *   Unity's Premultiply mode. The fade is linear in alpha except under `ALPHA_MAXIMIZED`, whose
+ *   blend weighs the colour by alpha once more, and `ALPHA_MAX`.
+ * - `'multiply'`: the blend multiplies the frame by the colour (`ALPHA_MULTIPLY`, `ALPHA_MIN`), so
+ *   the shader moves it toward white, which leaves the frame alone, as alpha falls. `ALPHA_MIN`
+ *   clamps a frame brighter than 1 (an HDR target) to 1 where a particle draws, even at alpha 0.
+ */
+type BlendOutput = 'straight' | 'premultiply' | 'multiply';
+/**
+ * What the scene's fog turns a particle's colour into with distance: the fog colour where the
+ * particle covers the frame (`'color'`), black where it adds to it (`'black'`, or the fog would
+ * add itself to the whole screen), white where it multiplies it (`'white'`). Unity fogs its
+ * additive and multiply particles toward black and white for the same reason.
+ */
+type FogTarget = 'color' | 'black' | 'white';
+/** The {@link BlendOutput} and {@link FogTarget} of a blend mode. */
+interface BlendCategory {
+    /** How the colour leaves the shader. */
+    output: BlendOutput;
+    /** Where the fog takes the colour. */
+    fogTarget: FogTarget;
+}
+/**
+ * The {@link BlendCategory} of a material: an opaque one (`materialTransparent` false, or
+ * `ALPHA_DISABLE`) is straight and fogs toward the fog colour; a transparent one by its Babylon
+ * alpha mode. A mode this table does not know is straight and fogs toward the fog colour.
+ */
+declare function blendCategory(settings: {
+    materialTransparent: boolean;
+    materialBlendMode: number;
+}): BlendCategory;
+/** The shader program a batch with `settings` compiles, given what it knows about its textures. */
+declare function shaderProgram(settings: ShaderSettings, context: ShaderContext): ShaderProgram;
+
 /**
  * One draw call of a {@link BatchedRenderer}: the systems that share a material, texture and
  * geometry, drawn together from one instanced mesh. The renderer makes and frees batches as
@@ -7061,6 +7391,28 @@ declare abstract class VFXBatch {
      * @internal
      */
     protected bindFog(material: ShaderMaterial): void;
+    /** The observer of the scene's image processing that rebuilds the material when its defines change. */
+    private imageProcessingObserver;
+    /**
+     * The scene's image processing as the material compiles it, see {@link ShaderContext.imageProcessing}:
+     * null when the batch does not apply it.
+     * @internal
+     */
+    protected imageProcessing(): ShaderImageProcessing | null;
+    /**
+     * Binds the scene's image processing to a material compiled with `compiled`: its values on every
+     * bind, unless a post process applies them, and the material's defines, uniforms and samplers
+     * swapped in place whenever the configuration changes what it has to compile (tone mapping
+     * switched on, a vignette, a colour grading texture, a post process taking over). The material
+     * stays the same one: a configuration that flips back and forth within a frame, as a reflection
+     * probe rendering in linear space does, only switches between the effects the engine has
+     * cached for each set of defines. A colour grading texture is set on the material too, so
+     * that the batch, like Babylon's own materials, is not drawn before it has loaded.
+     * @internal
+     */
+    protected bindImageProcessing(material: ShaderMaterial, compiled: ShaderImageProcessing | null): void;
+    /** Stops following the scene's image processing. @internal */
+    protected releaseImageProcessing(): void;
     /**
      * Seconds of renderer time, set by the renderer before each fill; what UV
      * and erosion mask scrolling advance by.
@@ -7240,6 +7592,18 @@ interface VFXBatchSettings {
      * that differ are batched apart.
      */
     applyFog: boolean;
+    /**
+     * Whether the material applies the scene's image processing (`scene.imageProcessingConfiguration`:
+     * exposure, contrast, tone mapping, vignette, colour curves, colour grading, dithering), as
+     * Babylon's own `ParticleSystem` and its standard and PBR materials do; unset reads as true.
+     * When the configuration is applied by a post process (a `DefaultRenderingPipeline` with image
+     * processing on), the material leaves its colour in linear space for it, as those materials do.
+     * Off, the material does neither: its colour is written as authored. That does not keep the
+     * particles out of a post process, which processes the whole frame; particles that must reach
+     * the screen untouched are drawn by a camera the pipeline is not attached to. Systems that
+     * differ are batched apart. See {@link ParticleSystem.applyImageProcessing}.
+     */
+    applyImageProcessing?: boolean;
     /**
      * 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
@@ -7646,18 +8010,66 @@ interface BurstParameters {
  */
 type CullingMode = 'always' | 'pause' | 'pauseAndCatchUp';
 /**
- * What the emitter's world scale does to a world-space system (Unity's
- * Scaling Mode, as far as it differs here). A local-space system lives in its
- * emitter's space, so its scale reaches everything either way.
+ * What a system does once it has finished, its emission over and its last particle dead (Unity's
+ * Stop Action):
+ *
+ * - `'none'` (the default): nothing; {@link ParticleSystem.restart} plays it again.
+ * - `'disable'`: disables its emitter node (`setEnabled(false)`), and with it the nodes under it.
+ *   A disabled system is not advanced or drawn; enable the emitter again before playing it.
+ * - `'destroy'`: disposes the system and its emitter, as `ParticleSystem.dispose()` does.
+ *
+ * Unity's Callback is the system's `finished` event, which fires whatever the stop action. The
+ * action waits for the system's sub emitters, see {@link ParticleSystem.stopAction}. A disabled
+ * emitter is state like any other: saved as not visible, and copied disabled by `clone`.
+ */
+type StopAction = 'none' | 'disable' | 'destroy';
+/**
+ * What a full system does with the particles it emits next (Unity's Ring Buffer Mode). It needs
+ * {@link ParticleSystemParameters.maxParticles}; without a limit it is ignored.
  *
- * - `'shape'` (default): the scale sizes the emission shape and the
- *   particles; speeds, forces and speed limits stay in world units, so a
- *   scaled-down effect moves as far as the full-size one.
- * - `'hierarchy'`: the scale also multiplies start speeds (per axis),
- *   `ForceOverLife` and `LimitSpeedOverLife` (by the mean of the axes), so the
- *   whole effect, motion included, scales like a model would.
+ * - `'disabled'` (the default): particles die at the end of their life, and a full system drops
+ *   what it would emit.
+ * - `'pauseUntilReplaced'`: a particle at the end of its life stays where and as it is, frozen,
+ *   until a new particle replaces it, the oldest first. For footprints, decals and bullet holes.
+ * - `'loopUntilReplaced'`: a particle at the end of its life goes back to an earlier point of it
+ *   and plays that part again, over and over, until a new particle replaces it; see
+ *   {@link ParticleSystem.ringBufferLoopRange}.
+ *
+ * Particles are never killed by age, so a system in either mode keeps its particles and does not
+ * finish while it has any: a non-looping ring effect never fires `finished`, and an
+ * `EffectPool` copy of it returns to the pool only when it is released. A replaced particle
+ * does not fire `particleDied`, nor Death sub emitters, which never fire in either mode since
+ * no particle dies. Lowering `maxParticles` drops the oldest particles over the new limit, also
+ * without `particleDied`. Particles are replaced oldest first in the order they were emitted;
+ * switching a mode on in a system whose particles have already died in a different order
+ * replaces them in row order the first time round. `'oldestInFront'` and `'youngestInFront'`
+ * sorting reads age, so a looping particle sorts by its age in the loop. Applies in every
+ * render mode but Trail, whose particles always die at the end of their life.
+ */
+type RingBufferMode = 'disabled' | 'pauseUntilReplaced' | 'loopUntilReplaced';
+/**
+ * What the emitter's scale does to the system, as Unity's Scaling Mode, in world and local space
+ * alike. The scale reaches the emission shape, the particles' size, their start speed and, in world
+ * space, `ForceOverLife`, `ApplyForce` and `LimitSpeedOverLife` (by the mean of the axes), so a
+ * scaled effect looks and moves like a scaled model, except where a mode leaves it out:
+ *
+ * - `'local'` (default, as in Unity): only the emitter's own `scaling`; its parents' scale is left
+ *   out, so an effect keeps its size under a scaled character or prop.
+ * - `'hierarchy'`: the emitter's whole world scale, its parents' included.
+ * - `'shape'`: the world scale sizes the emission shape alone; the particles keep their size and
+ *   speed, so a bigger emitter spreads the same particles over a larger area.
+ *
+ * Under every mode the emitter's position, rotation and any mirroring come from the whole
+ * hierarchy; only the length of each axis changes. A sub emission starts in its parent particle's
+ * frame and takes its size and speed from that, not from the sub emitter's scale; `'shape'` still
+ * scales its shape by the sub emitter's world scale. With a non-uniform scale `'shape'` stretches
+ * where particles start, not the directions the shape sends them.
+ *
+ * Known differences from Unity: a world force (`ForceOverLife`, `ApplyForce`, and so the gravity
+ * the Unity exporter writes) is scaled with the motion in `'local'` and `'hierarchy'`, where
+ * Unity's gravity is not.
  */
-type ScalingMode = 'shape' | 'hierarchy';
+type ScalingMode = 'local' | 'hierarchy' | 'shape';
 /**
  * Where a {@link RenderMode.Beam} system's quads end: a point in world space,
  * or anything with a world position, such as a Babylon `TransformNode`, read
@@ -7686,7 +8098,12 @@ type BeamEnd = {
  * default named on it, the same default `fromJSON` gives a file that leaves it out.
  */
 interface ParticleSystemParameters {
-    /** See {@link ParticleSystem.autoDestroy}. Default false. */
+    /** What the system does once it has finished, see {@link StopAction}. Default `'none'`. */
+    stopAction?: StopAction;
+    /**
+     * `true` is `stopAction: 'destroy'`; read only when `stopAction` is left out.
+     * @deprecated Use `stopAction: 'destroy'`.
+     */
     autoDestroy?: boolean;
     /** See {@link ParticleSystem.looping}. Default true. */
     looping?: boolean;
@@ -7718,6 +8135,10 @@ interface ParticleSystemParameters {
     emissionBursts?: Array<BurstParameters>;
     /** Most particles alive at once; emission past it is dropped. Leave unset for no limit. */
     maxParticles?: number;
+    /** What a full system does with new particles, see {@link RingBufferMode}. Default `'disabled'`. */
+    ringBufferMode?: RingBufferMode;
+    /** See {@link ParticleSystem.ringBufferLoopRange}. Default the whole life, (0, 1). */
+    ringBufferLoopRange?: Vector2;
     /** See {@link ParticleSystem.onlyUsedByOther}. Default false. */
     onlyUsedByOther?: boolean;
     /** See {@link ParticleSystem.behaviors}. Default none. */
@@ -7804,7 +8225,7 @@ interface ParticleSystemParameters {
     playbackSpeed?: number;
     /** What the system does while off screen, see {@link CullingMode}. Default `'always'`. */
     cullingMode?: CullingMode;
-    /** What the emitter's scale does to a world-space system, see {@link ScalingMode}. Default `'shape'`. */
+    /** What the emitter's scale does to the system, see {@link ScalingMode}. Default `'local'`. */
     scalingMode?: ScalingMode;
     /** Seed for this system's own random generator, see {@link ParticleSystem.seed}. Default none. */
     seed?: number;
@@ -7822,6 +8243,8 @@ interface ParticleSystemParameters {
     renderingGroupId?: number;
     /** Whether the scene's fog applies, see {@link ParticleSystem.applyFog}. Default true. */
     applyFog?: boolean;
+    /** Whether the scene's image processing applies, see {@link ParticleSystem.applyImageProcessing}. Default true. */
+    applyImageProcessing?: boolean;
     /** Scene the emitter node is created in. Default Babylon's last created scene. */
     scene?: Scene;
 }
@@ -7853,7 +8276,9 @@ interface BurstParametersJSON {
 interface ParticleSystemJSONParameters {
     /** The quarks.core version line the system was written with. */
     version: string;
-    /** See {@link ParticleSystem.autoDestroy}. */
+    /** Written only when not `'none'`. */
+    stopAction?: StopAction;
+    /** Read from older files: `true` is `stopAction: 'destroy'`. No longer written. */
     autoDestroy?: boolean;
     /** See {@link ParticleSystem.looping}. */
     looping?: boolean;
@@ -7885,6 +8310,10 @@ interface ParticleSystemJSONParameters {
     emissionBursts?: Array<BurstParametersJSON>;
     /** See {@link ParticleSystem.maxParticles}. */
     maxParticles?: number;
+    /** Written only when not `'disabled'`. */
+    ringBufferMode?: RingBufferMode;
+    /** `[start, end]`; written only when not `[0, 1]`. */
+    ringBufferLoopRange?: [number, number];
     /** See {@link ParticleSystem.onlyUsedByOther}. */
     onlyUsedByOther?: boolean;
     /**
@@ -7902,11 +8331,13 @@ interface ParticleSystemJSONParameters {
     renderingGroupId?: number;
     /** Written only when false. */
     applyFog?: boolean;
+    /** Written only when false. */
+    applyImageProcessing?: boolean;
     /** Written only when not 1. */
     playbackSpeed?: number;
     /** Written only when not `'always'`. */
     cullingMode?: CullingMode;
-    /** Written only when not `'shape'`. */
+    /** Written only when not `'local'`. */
     scalingMode?: ScalingMode;
     /** Written only when set. */
     seed?: number;
@@ -8033,12 +8464,27 @@ 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.
+    private _matrixWorldMode;
+    private readonly _shapeScale;
+    /**
+     * The matrix the system simulates and draws in, in quarks.core form: the node's world matrix,
+     * with the length of each axis set by the system's {@link ScalingMode}. `'hierarchy'` keeps the
+     * whole world scale; `'local'` sets each axis to the node's own `scaling` (times
+     * `scalingDeterminant`), leaving the parents' scale out; `'shape'` sets each to 1, and
+     * {@link shapeScale} applies the world scale to the emission shape alone. Only the axes'
+     * lengths change, so position, rotation and any mirroring from the hierarchy are kept. An axis
+     * that a parent scales to 0 has no direction left: it is rebuilt square to the other two. A
+     * node whose system has no scaling mode reads as `'hierarchy'`. Recomputed only when Babylon's
+     * matrix changed (tracked by its `updateFlag`) or the mode did, so repeated reads inside a frame
+     * are free.
      */
     get matrixWorld(): Matrix4;
+    /**
+     * What the system's emission shape is scaled by before {@link matrixWorld} places it: the
+     * node's world scale in `'shape'` mode, which leaves the particles and their motion unscaled,
+     * and 1 otherwise. Read it after `matrixWorld`, which refreshes it.
+     */
+    get shapeScale(): Vector3;
     /** Whether the node and its parents are enabled; setting it is `setEnabled`. */
     get visible(): boolean;
     set visible(value: boolean);
@@ -8048,7 +8494,7 @@ declare class ParticleEmitter extends TransformNode {
     /**
      * Disposes the node and the particle system it carries, so `root.dispose()` on an effect tree
      * also removes its systems from their renderer. Safe to call more than once. When a system
-     * disposes its own emitter (`ParticleSystem.dispose()`, `autoDestroy`), the systems of child
+     * disposes its own emitter (`ParticleSystem.dispose()`, a `destroy` stop action), the systems of child
      * emitters keep playing until they finish or are disposed themselves.
      */
     dispose(doNotRecurse?: boolean, disposeMaterialAndTextures?: boolean): void;
@@ -8076,8 +8522,31 @@ declare class ParticleEmitter extends TransformNode {
  * start values and emission, and the particle's age over its life inside behaviors.
  */
 declare class ParticleSystem implements IParticleSystem {
-    /** Dispose the system, its emitter and its batch slot when it finishes. Default false. */
-    autoDestroy: boolean;
+    /**
+     * What the system does once it has finished (Unity's Stop Action): nothing, disable its
+     * emitter, or dispose it; see {@link StopAction}. `'none'` by default.
+     *
+     * As in Unity, the action waits for the system's sub emitters: it runs once the system has
+     * finished and none of the systems it emits into, nor theirs, has a particle left (see
+     * {@link isAlive}), so disabling or disposing a parent does not cut its sub emitters'
+     * particles short. A sub emitter target ({@link onlyUsedByOther}) takes no stop action of its
+     * own: it is empty between its parent's bursts, and its parent decides when the effect is done.
+     */
+    stopAction: StopAction;
+    /**
+     * Skips the {@link stopAction} while true, so a tool can play an effect over and over (an
+     * editor's preview, a gallery, a pool of reused copies) and still save the stop action it
+     * was authored with, as Unity applies stop actions only in Play mode. The `finished` event
+     * fires either way. False by default; never saved, cloned or loaded.
+     */
+    ignoreStopAction: boolean;
+    /**
+     * Whether the system disposes itself when it finishes: `stopAction === 'destroy'`. Setting it
+     * true sets that stop action, and false turns a `'destroy'` one into `'none'`.
+     * @deprecated Use {@link stopAction}.
+     */
+    get autoDestroy(): boolean;
+    set autoDestroy(value: boolean);
     /**
      * Start a looping system as if it had already run one full cycle (Unity's Prewarm), so a fire
      * or a mist is full from its first frame. Default false.
@@ -8144,9 +8613,24 @@ declare class ParticleSystem implements IParticleSystem {
     /**
      * Most particles alive at once (Unity's Max Particles); emission past it is dropped. Undefined
      * means no limit, as does a negative or NaN count given to the constructor; a fraction is
-     * rounded down.
+     * rounded down. With a {@link ringBufferMode}, new particles replace the oldest instead.
      */
     maxParticles?: number;
+    /**
+     * What a full system does with new particles (Unity's Ring Buffer Mode): drop them, or
+     * replace the oldest, which wait frozen or looping until then; see {@link RingBufferMode}.
+     * `'disabled'` by default. Takes effect only with {@link maxParticles}.
+     */
+    ringBufferMode: RingBufferMode;
+    /**
+     * The part of its life a particle plays again in `'loopUntilReplaced'` (Unity's Loop Range):
+     * at the end of its life it goes back to `x` and plays to `y`, as fractions of its life, 0 to
+     * 1. (0, 1), the default, replays its whole life. Both ends are read clamped into 0..1 and in
+     * order, however the vector was set. A range of no length, such as (0.5, 0.5), holds the
+     * particle still at that point of its life; behaviors that act by age stop with it, those
+     * that act per second (rotation speed, forces) still run.
+     */
+    ringBufferLoopRange: Vector2;
     /**
      * The system emits nothing of its own and only spawns what an `EmitSubParticleSystem` on
      * another system sends it (a Unity sub emitter). Default false.
@@ -8225,8 +8709,11 @@ declare class ParticleSystem implements IParticleSystem {
     get time(): number;
     /** Whether {@link endEmit} ran, or a non-looping system reached the end of its duration. */
     get isEmitEnded(): boolean;
-    /** Whether continuous or queued emission can still spawn particles before the system is done. */
-    hasPendingEmission(): boolean;
+    /**
+     * Whether continuous or queued emission can still spawn particles before the system is done:
+     * its own, or with `state` one a sub emitter runs into this system for a parent particle.
+     */
+    hasPendingEmission(state?: EmissionState): boolean;
     /**
      * No particles left and nothing left to emit: a non-looping system that
      * ran its course, or a looping one whose emission was ended with
@@ -8385,15 +8872,7 @@ declare class ParticleSystem implements IParticleSystem {
      */
     get uvDistortion(): ParticleUVDistortion | undefined;
     set uvDistortion(distortion: ParticleUVDistortionOptions | undefined);
-    /**
-     * The emitter's world scale per axis, measured with {@link motionScale}
-     * before every step; what `'hierarchy'` multiplies start speeds by. Taken
-     * from the system's own emitter rather than the emission matrix, whose
-     * columns carry a parent particle's velocity for a sub emitter.
-     * @internal
-     */
-    readonly hierarchyScale: Vector3;
-    /** The mean world scale of the emitter for a world-space `'hierarchy'` system, else 1. */
+    /** The mean scale of the emitter's matrix for a world-space system, else 1. */
     private measureMotionScale;
     /**
      * Distance in world units in front of the scene at which a soft particle is fully faded out,
@@ -8508,6 +8987,27 @@ declare class ParticleSystem implements IParticleSystem {
      */
     get applyFog(): boolean;
     set applyFog(apply: boolean);
+    /**
+     * Whether the particles' material applies the scene's image processing (exposure, contrast,
+     * tone mapping, vignette, colour curves, colour grading, dithering of
+     * `scene.imageProcessingConfiguration`), as Babylon's own particle systems and materials do;
+     * true by default. A scene whose configuration does nothing leaves the colour as it is, and
+     * one applied by a post process gets the colour in linear space. Particles that multiply the
+     * frame (`ALPHA_MULTIPLY`) are a factor rather than light and are not tone mapped.
+     *
+     * As in Babylon, the processing runs on each particle before it is blended: tone mapping
+     * clamps an HDR colour to the displayable range, and an additive particle picks up what the
+     * configuration does to black (a contrast below 1, colour curves or an
+     * opaque vignette lift it). The configuration is the scene's;
+     * there is no per-system one.
+     *
+     * Switched off, the material writes its colour as authored, and leaves it in gamma space under
+     * a post process, which still processes the frame the particles are in. To keep particles out
+     * of a post process, draw them with a camera the pipeline is not attached to. Saved in the
+     * effect JSON only when switched off.
+     */
+    get applyImageProcessing(): boolean;
+    set applyImageProcessing(apply: boolean);
     /**
      * Multiplier on the time this system is advanced by (Unity's Simulation
      * Speed): 2 runs the effect twice as fast, 0 freezes it without pausing the
@@ -8541,12 +9041,13 @@ declare class ParticleSystem implements IParticleSystem {
     private emissionMultiplierValue;
     /** What this system does while off screen, see {@link CullingMode}. `'always'` by default. */
     cullingMode: CullingMode;
-    /** What the emitter's world scale does to a world-space system, see {@link ScalingMode}. `'shape'` by default. */
+    /** What the emitter's scale does to the system, see {@link ScalingMode}. `'local'` by default. */
     scalingMode: ScalingMode;
     /**
-     * What world-space forces and speed limits are multiplied by this step:
-     * the mean of the emitter's world scale axes in `'hierarchy'` mode, 1
-     * otherwise. Updated before every simulation step.
+     * What world-space forces and speed limits are multiplied by this step: the mean of the axes
+     * of the scale the {@link scalingMode} applies (the emitter's own in `'local'`, its world scale
+     * in `'hierarchy'`, 1 in `'shape'`) in a world-space system, 1 in a local-space one, whose
+     * emitter matrix scales them already. Updated before every simulation step.
      */
     motionScale: number;
     /**
@@ -8652,7 +9153,7 @@ declare class ParticleSystem implements IParticleSystem {
     /**
      * Stops emission and lets the particles alive die out (Unity's `Stop` with
      * `StopEmitting`). The system fires `emitEnd`, then `finished` when the last particle has
-     * died, and is disposed then if {@link autoDestroy} is set. {@link restart} starts it again.
+     * died, and then does what its {@link stopAction} says. {@link restart} starts it again.
      */
     endEmit(): void;
     /** Whether {@link dispose} has run. A disposed system emits nothing and cannot be restarted. */
@@ -8767,13 +9268,35 @@ declare class ParticleSystem implements IParticleSystem {
      */
     private simulateStep;
     private stepOnce;
+    /** Whether a sub emitter of this system still has an emission running into its target. */
+    private hasPendingSubEmission;
+    /**
+     * Whether the system still has particles or emission to come (Unity's `IsAlive`): not
+     * {@link isFinished}, or, with `withSubEmitters` (the default), any system it emits into
+     * through an `EmitSubParticleSystem`, and theirs, still has particles.
+     */
+    isAlive(withSubEmitters?: boolean): boolean;
+    /** Whether a system this one emits into has particles, or one of theirs; `seen` stops a cycle. */
+    private subEmittersAlive;
+    /**
+     * Whether particles outlive their lifetime, held or looped until replaced: a {@link ringBufferMode}
+     * on a system with {@link maxParticles}, outside the Trail render mode.
+     */
+    get ringBufferActive(): boolean;
     /** Re-points every particle at the store, for {@link snapshotPreviousState}. */
     private readonly rebindParticles;
     /** The one `particleDied` event, filled in for each death so a death allocates nothing. */
     private readonly particleDiedEvent;
     /** Fires `particleDied` for a particle the step retired. */
     private readonly fireParticleDied;
+    /** The ring buffer step for {@link integrateSprites}, or undefined when particles die by age. */
+    private ringBufferStep;
+    private readonly ringStep;
+    /** Set on each finish until the {@link stopAction} has run, which waits for the sub emitters. */
+    private stopActionPending;
     private notifyFinished;
+    /** Runs a pending {@link stopAction} once no system this one emits into has particles left. */
+    private applyStopAction;
     /**
      * Spawns what this step's emission calls for. Called by the simulation step, and by
      * `EmitSubParticleSystem` on a sub emitter target with the parent particle's state and matrix.
@@ -9036,7 +9559,7 @@ declare class QuarksPrefab extends TransformNode implements IPrefab {
  * reads every earlier version, and files written before the field existed, and warns about a
  * file from a newer version.
  */
-declare const QUARKS_FORMAT_VERSION = 1;
+declare const QUARKS_FORMAT_VERSION = 2;
 /** An image a texture reads: a url, a root-relative path, or a `data:` URI. */
 interface QuarksImageJSON {
     /** Unique within the file; other entries refer to it by this. */
@@ -9451,7 +9974,8 @@ interface EffectPlacement {
  * it; a copy whose every system has finished goes back to the pool by itself,
  * so a one-shot effect needs nothing more. A looping effect is ended with
  * {@link stop}, which lets its particles die out before the copy returns, or
- * dropped at once with {@link release}.
+ * dropped at once with {@link release}. A ring buffer effect (`ringBufferMode`)
+ * never finishes, since its particles never die: release it.
  *
  * Idle copies are parked disabled, which costs the renderer nothing, and keep
  * their place in its batches, so acquiring one allocates nothing.
@@ -9907,7 +10431,12 @@ declare class QuarksUtil {
     static pause(root: Node): void;
     /** Restarts every system under `root` from the beginning, see {@link ParticleSystem.restart}. */
     static restart(root: Node): void;
-    /** Sets {@link ParticleSystem.autoDestroy} on every system under `root`. */
+    /** Sets {@link ParticleSystem.stopAction} on every system under `root`. */
+    static setStopAction(root: Node, stopAction: StopAction): void;
+    /**
+     * Sets {@link ParticleSystem.autoDestroy} on every system under `root`.
+     * @deprecated Use {@link QuarksUtil.setStopAction} with `'destroy'`.
+     */
     static setAutoDestroy(root: Node, autoDestroy: boolean): void;
     /** Ends emission on every system under `root` and lets the particles die out, see {@link ParticleSystem.endEmit}. */
     static endEmit(root: Node): void;
@@ -9951,123 +10480,6 @@ declare class QuarksUtil {
     private static traverseNode;
 }
 
-/**
- * Picking the shader language a batch compiles in, and putting the source where
- * the engine will look for it.
- *
- * WebGPU speaks WGSL. Handing it GLSL is not an error — Babylon transpiles —
- * but the transpilers are two WASM modules it downloads from cdn.babylonjs.com
- * the first time a GLSL shader is compiled. That is a third-party request on
- * first draw, a hard failure under a Content-Security-Policy that does not list
- * the CDN or with no network at all, and a GLSL to SPIR-V to WGSL round trip
- * before the first particle appears. Shipping the WGSL means none of that
- * happens.
- *
- * The two languages live in separate stores keyed by the same name, so a scene
- * that somehow ran both would not collide.
- */
-interface ShaderSources {
-    /** GLSL source, used on every WebGL engine. */
-    glsl: string;
-    /** WGSL source, used on WebGPU. */
-    wgsl: string;
-}
-
-/**
- * The part of a batch's settings that decides its shader: the render mode, which textures and
- * effects are compiled in, and the blend state the fog and the fade read. Everything else a
- * batch holds (geometry, draw order, the effects' parameters) is a buffer or a uniform value.
- */
-type ShaderSettings = Pick<StoredBatchSettings, 'renderMode' | 'texture' | 'reflectionAtlas' | 'uTileCount' | 'vTileCount' | 'blendTiles' | 'softParticles' | 'materialAlphaTest' | 'materialTransparent' | 'materialBlendMode' | 'applyFog' | 'pivot' | 'minParticleSize' | 'maxParticleSize' | 'lighting' | 'rim' | 'mapUV' | 'uvDistortion' | 'gradientMap' | 'erosion'>;
-/** What the material needs to know about the depth texture soft particles read. */
-interface ShaderDepth {
-    /** Whether the depth is packed into four 8-bit channels, as a `DepthRenderer` of type `UNSIGNED_BYTE` writes it. */
-    packed: boolean;
-}
-/**
- * What a batch knows at compile time that its settings do not say: whether the textures it
- * depends on are there to be sampled.
- */
-interface ShaderContext {
-    /**
-     * The depth texture soft particles read, when one is attached to the renderer. Soft particles
-     * compile only with a depth texture.
-     */
-    depth: ShaderDepth | null;
-    /** Whether the mesh batch's reflection atlas has finished loading; it is sampled only then. */
-    envAtlasReady: boolean;
-    /** Whether the mesh batch has a second UV set to read for {@link UVChannel} 1. */
-    meshUV2: boolean;
-}
-/**
- * One compiled shader of the library: the sources in both languages and the defines, attributes,
- * uniforms and samplers the material is built with. Built by {@link shaderProgram} from a
- * batch's settings, so a batch and a shader validator describe the same material.
- */
-interface ShaderProgram {
-    /** The name the sources are registered under in Babylon's shader store, one per render mode. */
-    name: string;
-    /** The vertex shader in both languages. */
-    vertex: ShaderSources;
-    /** The fragment shader in both languages. */
-    fragment: ShaderSources;
-    /** The preprocessor defines, without the `#define`. */
-    defines: string[];
-    /** The vertex attributes the material binds. */
-    attributes: string[];
-    /** The uniforms the material declares. */
-    uniforms: string[];
-    /** The texture samplers the material declares. */
-    samplers: string[];
-}
-/**
- * How a particle's colour has to leave the fragment shader for its blend mode, so that its alpha
- * means coverage: alpha 0 leaves the frame as it was, alpha 1 draws the colour in full, and the
- * fades (soft particles, erosion, a rim fade, alpha over life) only lower alpha. Unity's particle
- * shaders do the same for their Alpha, Premultiply, Additive and Multiply modes. Alpha has no
- * such meaning for an opaque material, nor under `ALPHA_INTERPOLATE` (constant blend colour),
- * `ALPHA_REPLACE_COLOR` (replaces the frame) and `ALPHA_DUAL_SRC0_ADD_SRC1xDST` (reads a second
- * shader output the particle shaders do not write); these leave the colour as it is.
- *
- * - `'straight'`: the blend weighs the colour by its alpha itself (Babylon's `ALPHA_COMBINE`,
- *   `ALPHA_ADD`, `ALPHA_LAYER_ACCUMULATE`, …) or does not blend; the colour leaves as it is.
- * - `'premultiply'`: the blend takes the colour at full weight, or the frame by one minus the
- *   colour (`ALPHA_PREMULTIPLIED`, `ALPHA_ONEONE`, `ALPHA_SCREENMODE`, `ALPHA_SUBTRACT`,
- *   `ALPHA_MAXIMIZED`, `ALPHA_MAX`, …), so the shader multiplies it by its alpha: black, which
- *   these modes leave the frame alone with, at alpha 0. Textures stay straight alpha, as in
- *   Unity's Premultiply mode. The fade is linear in alpha except under `ALPHA_MAXIMIZED`, whose
- *   blend weighs the colour by alpha once more, and `ALPHA_MAX`.
- * - `'multiply'`: the blend multiplies the frame by the colour (`ALPHA_MULTIPLY`, `ALPHA_MIN`), so
- *   the shader moves it toward white, which leaves the frame alone, as alpha falls. `ALPHA_MIN`
- *   clamps a frame brighter than 1 (an HDR target) to 1 where a particle draws, even at alpha 0.
- */
-type BlendOutput = 'straight' | 'premultiply' | 'multiply';
-/**
- * What the scene's fog turns a particle's colour into with distance: the fog colour where the
- * particle covers the frame (`'color'`), black where it adds to it (`'black'`, or the fog would
- * add itself to the whole screen), white where it multiplies it (`'white'`). Unity fogs its
- * additive and multiply particles toward black and white for the same reason.
- */
-type FogTarget = 'color' | 'black' | 'white';
-/** The {@link BlendOutput} and {@link FogTarget} of a blend mode. */
-interface BlendCategory {
-    /** How the colour leaves the shader. */
-    output: BlendOutput;
-    /** Where the fog takes the colour. */
-    fogTarget: FogTarget;
-}
-/**
- * The {@link BlendCategory} of a material: an opaque one (`materialTransparent` false, or
- * `ALPHA_DISABLE`) is straight and fogs toward the fog colour; a transparent one by its Babylon
- * alpha mode. A mode this table does not know is straight and fogs toward the fog colour.
- */
-declare function blendCategory(settings: {
-    materialTransparent: boolean;
-    materialBlendMode: number;
-}): BlendCategory;
-/** The shader program a batch with `settings` compiles, given what it knows about its textures. */
-declare function shaderProgram(settings: ShaderSettings, context: ShaderContext): ShaderProgram;
-
 /**
  * One shader the library can compile: a {@link ShaderProgram} with the settings that produce it,
  * named for the renderer's benefit. See {@link shaderVariants}.
@@ -10081,8 +10493,8 @@ interface ShaderVariant {
 /**
  * Every shader program the library can compile, one per distinct set of defines: every render
  * mode with every combination of sheet, map, soft particles, alpha test and fog, every blend
- * resolve with and without fog and soft particles, and the texture effects alone and together on
- * each shader family. What a shader validator compiles, and what
+ * resolve with and without fog and soft particles, the texture effects alone and together on
+ * each shader family, and the scene's image processing on every render mode. What a shader validator compiles, and what
  * an application can warm the shader cache with before its first frame (Unity's
  * ShaderVariantCollection). Built by {@link shaderProgram}, so a variant here is a material a
  * batch would build.
@@ -10104,5 +10516,5 @@ declare function shaderVariants(): ShaderVariant[];
  */
 declare function textureSourceUrl(texture: Texture): string | undefined;
 
-export { ApplyCollision, ApplyForce, ApplySequences, AxisAngleGenerator, BatchedRenderer, BehaviorFromJSON, BehaviorToJSON, BehaviorTypes, Bezier, BoxEmitFrom, BoxEmitter, ChangeEmitDirection, CircleEmitter, ColorBySpeed, ColorGeneratorFromJSON, ColorOverLife, ColorRange, ConeEmitter, ConstantColor, ConstantValue, ContinuousLinearFunction, DEG2RAD, DonutEmitter, EROSION_DEFAULT_SOFTNESS, EdgeEmitter, EffectPool, EmitSubParticleSystem, EmitterFrame, EmitterFromJSON, EmitterMode, EmitterShapes, EmitterToJSON, Euler, EulerGenerator, ForceOverLife, FrameOverLife, GRADIENT_MAP_WEIGHTS, GeneratorFromJSON, Gradient, GravityForce, GridEmitter, HemisphereEmitter, InheritVelocity, IntervalValue, LimitSpeedOverLife, MAX_TRAIL_TESSELLATION, MathUtils, Matrix3, Matrix4, MeshSurfaceEmitter, MeshSurfaceEmitterPlugin, NodeParticle, Noise, OrbitOverLife, ParticleEmitter, ParticleStore, ParticleSystem, PiecewiseBezier, PiecewiseFunction, Plugins, PointEmitter, QUARKS_FORMAT_VERSION, QuarksFormatError, QuarksLoader, QuarksPrefab, QuarksUtil, Quaternion, QuaternionView, RAD2DEG, RandomColor, RandomColorBetweenGradient, RandomQuatGenerator, RecordState, RectangleEmitter, RenderMode, Rotation3DOverLife, RotationBySpeed, RotationGeneratorFromJSON, RotationOverLife, SequencerFromJSON, ShapeTransform, SizeBySpeed, SizeOverLife, SpeedOverLife, SphereEmitter, SpriteParticle, SubEmitterInheritMask, SubParticleEmitMode, TextureSequencer, TrailParticle, TurbulenceField, UV_DISTORTION_DEFAULT_STRENGTH, UV_DISTORTION_DEFAULT_UV, VFXBatch, ValueGeneratorFromJSON, Vector2, Vector3, Vector3Function, Vector3GeneratorFromJSON, Vector3View, Vector4, Vector4View, VelocityOverLife, WebGLCoordinateSystem, WebGPUCoordinateSystem, WidthOverLength, blendCategory, cacheEnvAtlas, ceilPowerOfTwo, clamp, createEnvAtlasFromFaceUrls, createSeededRandom, cubeFaceUrls, currentFormatPath, damp, decodeSoftDepth, defaultMeshLighting, degToRad, denormalize, disposeEnvAtlas, ensureEnvAtlasFromCube, erosionEqual, euclideanModulo, floorPowerOfTwo, generateUUID, getCachedEnvAtlas, getPhysicsResolver, getRandomSource, getValueFromEmitterMode, gradientMapEqual, inverseLerp, isPowerOfTwo, lerp, loadPlugin, mapLinear, mapUVEqual, meshRimEqual, normalize, normalizeErosion, normalizeGradientMap, normalizeMapUV, normalizeMeshRim, normalizeTextureUV, normalizeUVDistortion, pingpong, planBehaviorFusion, quarksNodeId, radToDeg, randFloat, randFloatSpread, randInt, random, readBehaviorSpace, readFormat, readFormatPart, readsUV1, seededRandom, serializeEffect, setPhysicsResolver, setQuaternionFromProperEuler, setRandomSource, shaderProgram, shaderVariants, smootherstep, smoothstep, softDepthParams, speedFraction, subEmitterInheritMask, textureSourceUrl, textureUVEqual, textureUVToJSON, trailCurveTension, trailLifetime, trailMinVertexDistance, trailTessellation, trailTextureMode, trailTextureScale, unloadPlugin, uvDistortionEqual, warnFormat, withRandomSource };
-export type { AdaptivePerformanceOptions, AdaptivePerformanceState, AnimationData, AnimationJSON, ApplyCollisionJSON, ApplyForceJSON, ApplySequencesJSON, AxisAngleJSON, BabylonMetaData, BeamEnd, Behavior, BehaviorJSON, BehaviorPlugin, BehaviorSpace, BezierJSON, BezierSplit, BillBoardSettings, BlendCategory, BlendOutput, BoxEmitterParameters, BufferAttributeJSON, BufferGeometryAttributesJSON, BufferGeometryDataJSON, BufferGeometryJSON, BufferIndexJSON, BurstParameters, BurstParametersJSON, ChangeEmitDirectionJSON, CircleEmitterParameters, ColorBySpeedJSON, ColorGenerator, ColorGeneratorJSON, ColorJSON, ColorOverLifeJSON, ColorRangeJSON, ConeEmitterParameters, ConstantColorJSON, ConstantValueJSON, Constructable, ContinuousLinearFunctionJSON, ContinuousLinearKeyJSON, ContinuousLinearSubType, ContinuousLinearSubTypeOf, ContinuousLinearValueJSON, CullingMode, DepthTextureOptions, DonutEmitterParameters, EdgeEmitterParameters, EffectDocumentJSON, EffectGeometryJSON, EffectImageJSON, EffectPlacement, EffectPoolOptions, EmissionState, EmitSubParticleSystemJSON, EmitterShape, EmitterShapePlugin, ErosionJSON, EulerJSON, EulerOrder, FieldType, FogTarget, ForceOverLifeJSON, FormatReadOptions, FrameOverLifeJSON, FrameOverLifeOptions, FunctionColorGenerator, FunctionJSON, FunctionValueGenerator, FusedPass, FusionStep, GeneratorMemory, GeometryArrays, GeometryEntry, GradientJSON, GradientMapChannel, GradientMapJSON, GradientRangeJSON, GravityForceJSON, GridEmitterParameters, HemisphereEmitterParameters, IAnimationData, IEmitter, IParticle, IParticleSystem, IPrefab, InheritVelocityJSON, InheritVelocityMode, InterleavedBufferJSON, IntervalValueJSON, JsonMetaData, LimitSpeedOverLifeJSON, MaterialTextureRef, MeshLighting, MeshLightingSettings, MeshRim, MeshSettings, NoiseJSON, ObjectValueType, OrbitOverLifeJSON, ParameterPair, ParameterType, Particle, ParticleEmitterJSON, ParticleErosion, ParticleErosionOptions, ParticleGradientMap, ParticleMaterialSource, ParticleSystemEvent, ParticleSystemEventType, ParticleSystemJSONParameters, ParticleSystemParameters, ParticleUVDistortion, ParticleUVDistortionOptions, PhysicsResolver, PiecewiseBezierJSON, PiecewiseBezierSegmentJSON, PlaneGeometryJSON, Plugin, QuarksBatchLoadOptions, QuarksEffectJSON, QuarksGeometryEntryJSON, QuarksGeometryJSON, QuarksImageJSON, QuarksJSONLoadEntry, QuarksLoadOptions, QuarksLoaderOptions, QuarksMaterialJSON, QuarksNodeJSON, QuarksPrefabJSON, QuarksResolveOptions, QuarksResourceKind, QuarksResourceResolver, QuarksTextureJSON, QuarksTimelineClip, RGBJSON, RandomColorBetweenGradientJSON, RandomColorJSON, RandomQuatJSON, RandomSource, RectangleEmitterParameters, RenderFace, RendererEmitterSettings, RendererEmitterSettingsJSON, Resource, Rotation3DOverLifeJSON, RotationBySpeedJSON, RotationGenerator, RotationGeneratorJSON, RotationOverLifeJSON, ScalingMode, SequenceJSON, Sequencer, SequencerJSON, SerializationOptions, SerializeEffectOptions, ShaderContext, ShaderDepth, ShaderProgram, ShaderSettings, ShaderSources, ShaderVariant, ShapeJSON, ShapeTransformJSON, SizeBySpeedJSON, SizeOverLifeJSON, SoftDepthEncoding, SortMode, SpeedOverLifeJSON, SphereEmitterParameters, SphereGeometryJSON, StoredBatchSettings, StretchedBillBoardSettings, SubEmitterInheritance, TextureSequencerJSON, TextureUV, TrailOptions, TrailSettings, TrailSettingsJSON, TrailTextureMode, TurbulenceFieldJSON, UVChannel, UVDistortionJSON, VFXBatchSettings, ValueGenerator, ValueGeneratorJSON, Vector2JSON, Vector3ArrayJSON, Vector3FunctionJSON, Vector3Generator, Vector3GeneratorJSON, Vector3JSON, Vector4JSON, VelocityOverLifeJSON, VelocityOverLifeSpace, WidthOverLengthJSON };
+export { ApplyCollision, ApplyForce, ApplySequences, AxisAngleGenerator, BatchedRenderer, BehaviorFromJSON, BehaviorToJSON, BehaviorTypes, Bezier, BoxEmitFrom, BoxEmitter, ChangeEmitDirection, CircleEmitter, ColorBySpeed, ColorGeneratorFromJSON, ColorOverLife, ColorRange, ConeEmitFrom, ConeEmitter, ConstantColor, ConstantValue, ContinuousLinearFunction, DEG2RAD, DonutEmitter, EROSION_DEFAULT_SOFTNESS, EdgeEmitter, EffectPool, EmitSubParticleSystem, EmitterFrame, EmitterFromJSON, EmitterMode, EmitterShapes, EmitterToJSON, Euler, EulerGenerator, ForceOverLife, FrameOverLife, GRADIENT_MAP_WEIGHTS, GeneratorFromJSON, Gradient, GravityForce, GridEmitter, GridSampling, HemisphereEmitter, InheritVelocity, IntervalValue, LimitSpeedOverLife, MAX_TRAIL_TESSELLATION, MathUtils, Matrix3, Matrix4, MeshSurfaceEmitter, MeshSurfaceEmitterPlugin, NodeParticle, Noise, OrbitOverLife, ParticleEmitter, ParticleStore, ParticleSystem, PiecewiseBezier, PiecewiseFunction, Plugins, PointEmitter, QUARKS_FORMAT_VERSION, QuarksFormatError, QuarksLoader, QuarksPrefab, QuarksUtil, Quaternion, QuaternionView, RAD2DEG, RandomBetweenCurves, RandomColor, RandomColorBetweenGradient, RandomQuatGenerator, RecordState, RectangleEmitter, RenderMode, Rotation3DOverLife, RotationBySpeed, RotationGeneratorFromJSON, RotationOverLife, SequencerFromJSON, ShapeTransform, SizeBySpeed, SizeOverLife, SpeedOverLife, SphereEmitter, SpriteParticle, SubEmitterInheritMask, SubParticleEmitMode, TextureSequencer, TrailParticle, TurbulenceField, UV_DISTORTION_DEFAULT_STRENGTH, UV_DISTORTION_DEFAULT_UV, VFXBatch, ValueGeneratorFromJSON, Vector2, Vector3, Vector3Function, Vector3GeneratorFromJSON, Vector3View, Vector4, Vector4View, VelocityOverLife, WebGLCoordinateSystem, WebGPUCoordinateSystem, WidthOverLength, blendCategory, cacheEnvAtlas, ceilPowerOfTwo, clamp, createEnvAtlasFromFaceUrls, createSeededRandom, cubeFaceUrls, currentFormatPath, damp, decodeSoftDepth, defaultMeshLighting, degToRad, denormalize, disposeEnvAtlas, ensureEnvAtlasFromCube, erosionEqual, euclideanModulo, floorPowerOfTwo, generateUUID, getCachedEnvAtlas, getPhysicsResolver, getRandomSource, getValueFromEmitterMode, gradientMapEqual, inverseLerp, isPowerOfTwo, lerp, loadPlugin, mapLinear, mapUVEqual, meshRimEqual, normalize, normalizeErosion, normalizeGradientMap, normalizeMapUV, normalizeMeshRim, normalizeTextureUV, normalizeUVDistortion, pingpong, planBehaviorFusion, quarksNodeId, radToDeg, randFloat, randFloatSpread, randInt, random, readBehaviorSpace, readFormat, readFormatPart, readsUV1, seededRandom, serializeEffect, setPhysicsResolver, setQuaternionFromProperEuler, setRandomSource, shaderProgram, shaderVariants, smootherstep, smoothstep, softDepthParams, speedFraction, subEmitterInheritMask, textureSourceUrl, textureUVEqual, textureUVToJSON, trailCurveTension, trailLifetime, trailMinVertexDistance, trailTessellation, trailTextureMode, trailTextureScale, unloadPlugin, uvDistortionEqual, warnFormat, withRandomSource };
+export type { AdaptivePerformanceOptions, AdaptivePerformanceState, AnimationData, AnimationJSON, ApplyCollisionJSON, ApplyForceJSON, ApplySequencesJSON, AxisAngleJSON, BabylonMetaData, BeamEnd, Behavior, BehaviorJSON, BehaviorPlugin, BehaviorSpace, BezierJSON, BezierSplit, BillBoardSettings, BlendCategory, BlendOutput, BoxEmitterParameters, BufferAttributeJSON, BufferGeometryAttributesJSON, BufferGeometryDataJSON, BufferGeometryJSON, BufferIndexJSON, BurstParameters, BurstParametersJSON, ChangeEmitDirectionJSON, CircleEmitterParameters, ColorBySpeedJSON, ColorGenerator, ColorGeneratorJSON, ColorJSON, ColorOverLifeJSON, ColorRangeJSON, ConeEmitterParameters, ConstantColorJSON, ConstantValueJSON, Constructable, ContinuousLinearFunctionJSON, ContinuousLinearKeyJSON, ContinuousLinearSubType, ContinuousLinearSubTypeOf, ContinuousLinearValueJSON, CullingMode, DepthTextureOptions, DonutEmitterParameters, EdgeEmitterParameters, EffectDocumentJSON, EffectGeometryJSON, EffectImageJSON, EffectPlacement, EffectPoolOptions, EmissionState, EmitSubParticleSystemJSON, EmitterShape, EmitterShapePlugin, ErosionJSON, EulerJSON, EulerOrder, FieldType, FogTarget, ForceOverLifeJSON, FormatReadOptions, FrameOverLifeJSON, FrameOverLifeOptions, FunctionColorGenerator, FunctionJSON, FunctionValueGenerator, FusedPass, FusionStep, GeneratorMemory, GeometryArrays, GeometryEntry, GradientJSON, GradientMapChannel, GradientMapJSON, GradientRangeJSON, GravityForceJSON, GridEmitterParameters, HemisphereEmitterParameters, IAnimationData, IEmitter, IParticle, IParticleSystem, IPrefab, InheritVelocityJSON, InheritVelocityMode, InterleavedBufferJSON, IntervalValueJSON, JsonMetaData, LimitSpeedOverLifeJSON, MaterialTextureRef, MeshLighting, MeshLightingSettings, MeshRim, MeshSettings, NoiseJSON, ObjectValueType, OrbitOverLifeJSON, ParameterPair, ParameterType, Particle, ParticleEmitterJSON, ParticleErosion, ParticleErosionOptions, ParticleGradientMap, ParticleMaterialSource, ParticleSystemEvent, ParticleSystemEventType, ParticleSystemJSONParameters, ParticleSystemParameters, ParticleUVDistortion, ParticleUVDistortionOptions, PhysicsResolver, PiecewiseBezierJSON, PiecewiseBezierSegmentJSON, PlaneGeometryJSON, Plugin, QuarksBatchLoadOptions, QuarksEffectJSON, QuarksGeometryEntryJSON, QuarksGeometryJSON, QuarksImageJSON, QuarksJSONLoadEntry, QuarksLoadOptions, QuarksLoaderOptions, QuarksMaterialJSON, QuarksNodeJSON, QuarksPrefabJSON, QuarksResolveOptions, QuarksResourceKind, QuarksResourceResolver, QuarksTextureJSON, QuarksTimelineClip, RGBJSON, RandomBetweenCurvesJSON, RandomColorBetweenGradientJSON, RandomColorJSON, RandomQuatJSON, RandomSource, RectangleEmitterParameters, RenderFace, RendererEmitterSettings, RendererEmitterSettingsJSON, Resource, RingBufferMode, Rotation3DOverLifeJSON, RotationBySpeedJSON, RotationGenerator, RotationGeneratorJSON, RotationOverLifeJSON, ScalingMode, SequenceJSON, Sequencer, SequencerJSON, SerializationOptions, SerializeEffectOptions, ShaderContext, ShaderDepth, ShaderProgram, ShaderSettings, ShaderSources, ShaderVariant, ShapeJSON, ShapeTransformJSON, SizeBySpeedJSON, SizeOverLifeJSON, SoftDepthEncoding, SortMode, SpeedOverLifeJSON, SphereEmitterParameters, SphereGeometryJSON, StopAction, StoredBatchSettings, StretchedBillBoardSettings, SubEmitterInheritance, TextureSequencerJSON, TextureUV, TrailOptions, TrailSettings, TrailSettingsJSON, TrailTextureMode, TurbulenceFieldJSON, UVChannel, UVDistortionJSON, VFXBatchSettings, ValueGenerator, ValueGeneratorJSON, Vector2JSON, Vector3ArrayJSON, Vector3FunctionJSON, Vector3Generator, Vector3GeneratorJSON, Vector3JSON, Vector4JSON, VelocityOverLifeJSON, VelocityOverLifeSpace, WidthOverLengthJSON };