@galacean/engine-core 0.9.19 → 0.9.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-core",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -15,10 +15,10 @@
     "types/**/*"
   ],
   "dependencies": {
-    "@galacean/engine-math": "0.9.19"
+    "@galacean/engine-math": "0.9.21"
   },
   "devDependencies": {
-    "@galacean/engine-design": "0.9.19"
+    "@galacean/engine-design": "0.9.21"
   },
   "scripts": {
     "b:types": "tsc"

package/types/RenderPipeline/CullingResults.d.ts

@@ -0,0 +1 @@
+export {};

package/types/RenderPipeline/DepthOnlyPass.d.ts

@@ -0,0 +1 @@
+export {};

package/types/RenderPipeline/PipelinePass.d.ts

@@ -0,0 +1,16 @@
+import { Engine } from "../Engine";
+import { CullingResults } from "../RenderPipeline/CullingResults";
+import { RenderContext } from "../RenderPipeline/RenderContext";
+/**
+ * PipelinePass is a base class for all pipeline passes.
+ */
+export declare abstract class PipelinePass {
+    protected _engine: Engine;
+    constructor(engine: Engine);
+    /**
+     * Called before rendering a camera, override this method to configure the camera If you need to configure the camera clear flag or render target.
+     * @param context - Rendering context
+     * @param cullingResults - Culling results
+     */
+    abstract onRender(context: RenderContext, cullingResults: CullingResults): void;
+}

package/types/RenderPipeline/PipelineUtils.d.ts

@@ -0,0 +1 @@
+export {};

package/types/RenderPipeline/RenderData.d.ts

@@ -1,7 +1,14 @@
+import { SubMesh } from "../graphic";
+import { Primitive } from "../graphic/Primitive";
 import { Material } from "../material";
 import { Renderer } from "../Renderer";
-export declare class RenderData {
+import { IPoolElement } from "./IPoolElement";
+export declare class RenderData implements IPoolElement {
     component: Renderer;
     material: Material;
+    primitive: Primitive;
+    subPrimitive: SubMesh;
     multiRenderData: boolean;
+    setX(component: Renderer, material: Material, primitive: Primitive, subPrimitive: SubMesh): void;
+    dispose(): void;
 }

package/types/RenderPipeline/RenderElementX.d.ts

@@ -0,0 +1,12 @@
+import { Renderer } from "../Renderer";
+import { Primitive } from "../graphic/Primitive";
+import { Material } from "../material/Material";
+import { ShaderPass } from "../shader/ShaderPass";
+import { IPoolElement } from "./IPoolElement";
+export declare class RenderElementX implements IPoolElement {
+    shaderPasses: ReadonlyArray<ShaderPass>;
+    component: Renderer;
+    material: Material;
+    primitive: Primitive;
+    dispose(): void;
+}

package/types/RenderPipeline/enums/PipelineStage.d.ts

@@ -2,6 +2,8 @@
  * Pipeline stage.
  */
 export declare enum PipelineStage {
+    /** DepthOnly stage. */
+    DepthOnly = "DepthOnly",
     /** Shadow caster stage. */
     ShadowCaster = "ShadowCaster",
     /** Forward shading stage. */

package/types/Ticker.d.ts

@@ -0,0 +1,30 @@
+export declare class Ticker {
+    private _vSyncCount;
+    private _vSyncCounter;
+    private _requestId;
+    private _animationLoop;
+    private _requestAnimationFrame;
+    private _cancelAnimationFrame;
+    /**
+     * The number of vertical synchronization means the number of vertical blanking for one frame.
+     * @remarks 0 means that the vertical synchronization is turned off.
+     */
+    get vSyncCount(): number;
+    set vSyncCount(value: number);
+    get requestAnimationFrame(): (...params: any[]) => any;
+    set requestAnimationFrame(func: (...params: any[]) => any);
+    get cancelAnimationFrame(): (...params: any[]) => any;
+    set cancelAnimationFrame(func: (...params: any[]) => any);
+    get animationLoop(): (...params: any[]) => any;
+    set animationLoop(func: (...params: any[]) => any);
+    /**
+     * Pause the engine.
+     */
+    pause(): void;
+    /**
+     * Resume the engine.
+     */
+    resume(): void;
+    private _onAnimationFrame;
+    constructor();
+}

package/types/animation/animationCurve/AnimationRectCurve.d.ts

@@ -0,0 +1,8 @@
+import { Rect } from "@galacean/engine-math";
+import { AnimationCurve } from "./AnimationCurve";
+/**
+ * Store a collection of Keyframes that can be evaluated over time.
+ */
+export declare class AnimationRectCurve extends AnimationCurve<Rect> {
+    constructor();
+}

package/types/animation/animationCurve/AnimationRefCurve.d.ts

@@ -0,0 +1,8 @@
+import { ReferResource } from "../../asset/ReferResource";
+import { AnimationCurve } from "./AnimationCurve";
+/**
+ * Store a collection of Keyframes that can be evaluated over time.
+ */
+export declare class AnimationRefCurve extends AnimationCurve<ReferResource> {
+    constructor();
+}

package/types/animation/internal/AnimationCurveOwnerLayerData.d.ts

@@ -0,0 +1 @@
+export {};

package/types/asset/GraphicsResource.d.ts

@@ -1,5 +1,9 @@
 import { Engine } from "../Engine";
 import { ReferResource } from "./ReferResource";
 export declare abstract class GraphicsResource extends ReferResource {
+    /**
+     * Whether the content of the resource is lost.
+     */
+    get isContentLost(): boolean;
     protected constructor(engine: Engine);
 }

package/types/asset/request.d.ts

@@ -17,9 +17,13 @@ export declare class MultiExecutor {
     private interval;
     private _timeoutId;
     private _currentCount;
+    private _onComplete;
+    private _onError;
+    private _error;
     constructor(execFunc: (count?: number) => Promise<any>, totalCount: number, interval: number);
-    private done;
-    start(done?: Function): void;
-    stop(): void;
+    start(): this;
+    onComplete(func: Function): this;
+    onError(func: Function): this;
+    cancel(): void;
     private exec;
 }

package/types/enums/DepthTextureMode.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Depth texture mode.
+ */
+export declare enum DepthTextureMode {
+    None = 0,
+    PrePass = 1
+}

package/types/graphic/Primitive.d.ts

@@ -0,0 +1 @@
+export {};

package/types/graphic/PrimitiveVertexBinding.d.ts

@@ -0,0 +1 @@
+export {};

package/types/graphic/SubPrimitive.d.ts

@@ -0,0 +1,9 @@
+import { MeshTopology } from "./enums/MeshTopology";
+export declare class SubPrimitive {
+    /** Start drawing offset. */
+    start: number;
+    /** Drawing count. */
+    count: number;
+    /** Drawing topology. */
+    topology: MeshTopology;
+}

package/types/particle/ParticleBufferUtils.d.ts

@@ -0,0 +1 @@
+export {};

package/types/particle/ParticleData.d.ts

@@ -0,0 +1 @@
+export {};

package/types/particle/ParticleGenerator.d.ts

@@ -0,0 +1,72 @@
+import { ParticleRenderer } from "./ParticleRenderer";
+import { ParticleStopMode } from "./enums/ParticleStopMode";
+import { ColorOverLifetimeModule } from "./modules/ColorOverLifetimeModule";
+import { EmissionModule } from "./modules/EmissionModule";
+import { MainModule } from "./modules/MainModule";
+import { RotationOverLifetimeModule } from "./modules/RotationOverLifetimeModule";
+import { SizeOverLifetimeModule } from "./modules/SizeOverLifetimeModule";
+import { TextureSheetAnimationModule } from "./modules/TextureSheetAnimationModule";
+import { VelocityOverLifetimeModule } from "./modules/VelocityOverLifetimeModule";
+/**
+ * Particle Generator.
+ */
+export declare class ParticleGenerator {
+    private static readonly _particleIncreaseCount;
+    /** Use auto random seed. */
+    useAutoRandomSeed: boolean;
+    /** Main module. */
+    readonly main: MainModule;
+    /** Emission module. */
+    readonly emission: EmissionModule;
+    /** Velocity over lifetime module. */
+    readonly velocityOverLifetime: VelocityOverLifetimeModule;
+    /** Size over lifetime module. */
+    readonly sizeOverLifetime: SizeOverLifetimeModule;
+    /** Rotation over lifetime module. */
+    readonly rotationOverLifetime: RotationOverLifetimeModule;
+    /** Color over lifetime module. */
+    readonly colorOverLifetime: ColorOverLifetimeModule;
+    /** Texture sheet animation module. */
+    readonly textureSheetAnimation: TextureSheetAnimationModule;
+    private _isPlaying;
+    private _instanceBufferResized;
+    private _waitProcessRetiredElementCount;
+    private _instanceVertexBufferBinding;
+    private _instanceVertices;
+    private _randomSeed;
+    /**
+     * Whether the particle generator is contain alive or is still creating particles.
+     */
+    get isAlive(): boolean;
+    /**
+     * Random seed.
+     *
+     * @remarks
+     * If `useAutoRandomSeed` is true, this value will be random changed when play.
+     * If you set this value custom, `useAutoRandomSeed` will be false.
+     */
+    get randomSeed(): number;
+    set randomSeed(value: number);
+    constructor(renderer: ParticleRenderer);
+    /**
+     * Start emitting particles.
+     * @param withChildren - Whether to start the particle generator of the child entity
+     */
+    play(withChildren?: boolean): void;
+    /**
+     * Stop emitting particles.
+     * @param withChildren - Whether to stop the particle generator of the child entity
+     * @param stopMode - Stop mode
+     */
+    stop(withChildren?: boolean, stopMode?: ParticleStopMode): void;
+    /**
+     * Manually emit certain number of particles immediately.
+     * @param count - Number of particles to emit
+     */
+    emit(count: number): void;
+    private _addNewParticle;
+    private _retireActiveParticles;
+    private _freeRetiredParticles;
+    private _addActiveParticlesToVertexBuffer;
+    private _addVertexBufferBindingsFilterDuplicate;
+}

package/types/particle/ParticleMaterial.d.ts

@@ -0,0 +1,28 @@
+import { Color } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { BaseMaterial } from "../material/BaseMaterial";
+import { Texture2D } from "../texture/Texture2D";
+/**
+ * Particle Material.
+ */
+export declare class ParticleMaterial extends BaseMaterial {
+    /**
+     * Base color.
+     */
+    get baseColor(): Color;
+    set baseColor(value: Color);
+    /**
+     * Base texture.
+     */
+    get baseTexture(): Texture2D;
+    set baseTexture(value: Texture2D);
+    /**
+     * Create a unlit material instance.
+     * @param engine - Engine to which the material belongs
+     */
+    constructor(engine: Engine);
+    /**
+     * @inheritdoc
+     */
+    clone(): ParticleMaterial;
+}

package/types/particle/ParticleMesh.d.ts

@@ -0,0 +1,289 @@
+import { BoundingBox, Color, Vector2, Vector3 } from "@galacean/engine-math";
+import { ParticleRenderer } from "./ParticleRenderer";
+import { BufferMesh } from "../mesh";
+import { Buffer, VertexElement } from "../graphic";
+import { ColorOverLifetimeModule, EmissionModule, ParticleCurve, RotationOverLifetimeModule, SizeOverLifetimeModule, TextureSheetAnimationModule, VelocityOverLifetimeModule } from "./module";
+import { BaseShape } from "./module/shape/BaseShape";
+import { ParticleCurveMode, ParticleScaleMode, ParticleSimulationSpace } from "./enum";
+/**
+ * Particle Mesh
+ */
+export declare class ParticleMesh extends BufferMesh {
+    protected static VERTEX_STRIDE: number;
+    protected static VERTEX_ELEMENTS: VertexElement[];
+    protected static halfKSqrtOf2: number;
+    protected static g: number;
+    protected static _maxElapsedTime: number;
+    protected static _tempVector30: Vector3;
+    protected static _tempVector31: Vector3;
+    protected static _tempVector32: Vector3;
+    protected static _tempVector33: Vector3;
+    protected static _tempVector34: Vector3;
+    protected static _tempVector35: Vector3;
+    protected static _tempVector36: Vector3;
+    protected static _tempVector37: Vector3;
+    protected static _tempPosition: Vector3;
+    protected static _tempDirection: Vector3;
+    protected _simulateUpdate: boolean;
+    protected _drawCounter: number;
+    protected _isEmitting: boolean;
+    protected _isPlaying: boolean;
+    protected _isPaused: boolean;
+    protected _playStartDelay: number;
+    protected _frameRateTime: number;
+    protected _emissionTime: number;
+    protected _totalDelayTime: number;
+    protected _emissionDistance: number;
+    protected _emissionLastPosition: Vector3;
+    protected _uvLength: Vector2;
+    protected _renderer: ParticleRenderer;
+    protected _indexBuffer: Buffer;
+    protected _vertexBuffer: Buffer;
+    protected _vertices: Float32Array;
+    protected _simulationUV_Index: number;
+    protected _startLifeTimeIndex: number;
+    protected _timeIndex: number;
+    protected _burstsIndex: number;
+    protected _firstActiveElement: number;
+    protected _firstNewElement: number;
+    protected _firstFreeElement: number;
+    protected _firstRetiredElement: number;
+    protected _vertexStride: number;
+    protected _indexStride: number;
+    protected _floatCountPerVertex: number;
+    protected _bufferMaxParticles: number;
+    protected _emission: EmissionModule;
+    protected _shape: BaseShape;
+    protected _velocityOverLifetime: VelocityOverLifetimeModule;
+    protected _colorOverLifetime: ColorOverLifetimeModule;
+    protected _sizeOverLifetime: SizeOverLifetimeModule;
+    protected _rotationOverLifetime: RotationOverLifetimeModule;
+    protected _textureSheetAnimation: TextureSheetAnimationModule;
+    protected _startLifetimeType: ParticleCurveMode;
+    protected _startLifetimeConstant: number;
+    protected _startLifeTimeGradient: ParticleCurve;
+    protected _startLifetimeConstantMin: number;
+    protected _startLifetimeConstantMax: number;
+    protected _startLifeTimeGradientMin: ParticleCurve;
+    protected _startLifeTimeGradientMax: ParticleCurve;
+    protected _maxStartLifetime: number;
+    /** The mode of drag */
+    dragType: ParticleCurveMode;
+    /** Apply drag to particles within the volume of the Force Field. */
+    dragConstant: number;
+    /** Min apply drag to particles within the volume of the Force Field. */
+    dragSpeedConstantMin: number;
+    /** Max apply drag to particles within the volume of the Force Field. */
+    dragSpeedConstantMax: number;
+    /** Random seed.(should set before play()) */
+    randomSeed: Uint32Array;
+    /** Whether to use random seed */
+    autoRandomSeed: boolean;
+    /** Whether to use performance mode, which will delay particle release.*/
+    isPerformanceMode: boolean;
+    /** The duration of the Particle System in seconds. */
+    duration: number;
+    /** Specifies whether the Particle System is looping. */
+    looping: boolean;
+    /** A scale that this Particle System applies to gravity, defined by Physics.gravity. */
+    gravityModifier: number;
+    /** Control how the Particle System applies its Transform component to the particles it emits. */
+    scalingMode: ParticleScaleMode;
+    /** This selects the space in which to simulate particles. It can be either world or local space. */
+    simulationSpace: ParticleSimulationSpace;
+    /** Override the default playback speed of the Particle System. */
+    simulationSpeed: number;
+    /** If set to true, the Particle System automatically begins to play on startup. */
+    playOnAwake: boolean;
+    /** Makes some particles spin in the opposite direction. */
+    flipRotation: number;
+    /** Start delay mode. */
+    startDelayType: ParticleCurveMode;
+    /** Start delay in seconds. */
+    startDelay: number;
+    /** Start delay in min seconds. */
+    startDelayMin: number;
+    /** Start delay in max seconds. */
+    startDelayMax: number;
+    /** The mode of start particles speed */
+    startSpeedType: ParticleCurveMode;
+    /** The initial speed of particles when the Particle System first spawns them. */
+    startSpeedConstant: number;
+    /** The min initial speed of particles when the Particle System first spawns them. */
+    startSpeedConstantMin: number;
+    /** The max initial speed of particles when the Particle System first spawns them. */
+    startSpeedConstantMax: number;
+    /** A flag to enable 3D particle rotation. */
+    startRotation3D: boolean;
+    /** The mode of start rotation */
+    startRotationType: ParticleCurveMode;
+    /** The initial rotation of particles when the Particle System first spawns them. */
+    startRotationConstant: number;
+    /** The initial rotation of particles when the Particle System first spawns them. */
+    startRotationConstantSeparate: Vector3;
+    /** The min initial rotation of particles when the Particle System first spawns them. */
+    startRotationConstantMin: number;
+    /** The max initial rotation of particles when the Particle System first spawns them. */
+    startRotationConstantMax: number;
+    /** The min initial rotation of particles when the Particle System first spawns them. */
+    startRotationConstantMinSeparate: Vector3;
+    /** The max initial rotation of particles when the Particle System first spawns them. */
+    startRotationConstantMaxSeparate: Vector3;
+    /** A flag to enable specifying particle size individually for each axis. */
+    startSize3D: boolean;
+    /** The mode of start size */
+    startSizeType: ParticleCurveMode;
+    /** The initial size of particles when the Particle System first spawns them. */
+    startSizeConstant: number;
+    /** The initial size of particles when the Particle System first spawns them. */
+    startSizeConstantSeparate: Vector3;
+    /** The min initial size of particles when the Particle System first spawns them. */
+    startSizeConstantMin: number;
+    /** The max initial size of particles when the Particle System first spawns them. */
+    startSizeConstantMax: number;
+    /** The min initial size of particles when the Particle System first spawns them. */
+    startSizeConstantMinSeparate: Vector3;
+    /** The max initial size of particles when the Particle System first spawns them. */
+    startSizeConstantMaxSeparate: Vector3;
+    /** The mode of start color */
+    startColorType: ParticleCurveMode;
+    /** The initial color of particles when the Particle System first spawns them. */
+    startColorConstant: Color;
+    /** The min initial color of particles when the Particle System first spawns them. */
+    startColorConstantMin: Color;
+    /** The max initial color of particles when the Particle System first spawns them. */
+    startColorConstantMax: Color;
+    /**
+     * The mode of total lifetime.
+     */
+    get startLifetimeType(): ParticleCurveMode;
+    set startLifetimeType(value: ParticleCurveMode);
+    /**
+     * The total lifetime in seconds that each new particle has.
+     */
+    get startLifetimeConstant(): number;
+    set startLifetimeConstant(value: number);
+    /**
+     * The total lifetime in seconds that each new particle has.
+     */
+    get startLifeTimeGradient(): ParticleCurve;
+    set startLifeTimeGradient(value: ParticleCurve);
+    /**
+     * The lower total lifetime in seconds that each new particle has.
+     */
+    get startLifetimeConstantMin(): number;
+    set startLifetimeConstantMin(value: number);
+    /**
+     * The upper total lifetime in seconds that each new particle has.
+     */
+    get startLifetimeConstantMax(): number;
+    set startLifetimeConstantMax(value: number);
+    /**
+     * The lower total lifetime in seconds that each new particle has.
+     */
+    get startLifeTimeGradientMin(): ParticleCurve;
+    set startLifeTimeGradientMin(value: ParticleCurve);
+    /**
+     * The upper total lifetime in seconds that each new particle has.
+     */
+    get startLifeTimeGradientMax(): ParticleCurve;
+    set startLifeTimeGradientMax(value: ParticleCurve);
+    /**
+     * The ShapeModule of a Particle System.
+     */
+    get shape(): BaseShape;
+    set shape(value: BaseShape);
+    /**
+     * The maximum number of particles to emit.
+     */
+    get maxParticles(): number;
+    set maxParticles(value: number);
+    /**
+     * the sum of all alive particles within the particle system.
+     */
+    get aliveParticleCount(): number;
+    /**
+     * The emission time of the Particle System in seconds.
+     */
+    get emissionTime(): number;
+    /**
+     * The EmissionModule of a Particle System.
+     */
+    get emission(): EmissionModule;
+    /**
+     * Determines whether the Particle System is alive
+     */
+    get isAlive(): boolean;
+    /**
+     * Determines whether the Particle System is emitting particles.
+     */
+    get isEmitting(): boolean;
+    /**
+     * Determines whether the Particle System is playing.
+     */
+    get isPlaying(): boolean;
+    /**
+     * Determines whether the Particle System is paused.
+     */
+    get isPaused(): boolean;
+    /**
+     * The VelocityOverLifetimeModule of a Particle System.
+     */
+    get velocityOverLifetime(): VelocityOverLifetimeModule;
+    set velocityOverLifetime(value: VelocityOverLifetimeModule);
+    /**
+     * The ColorOverLifetimeModule of a Particle System.
+     */
+    get colorOverLifetime(): ColorOverLifetimeModule;
+    set colorOverLifetime(value: ColorOverLifetimeModule);
+    /**
+     * The SizeOverLifetimeModule of a Particle System.
+     */
+    get sizeOverLifetime(): SizeOverLifetimeModule;
+    set sizeOverLifetime(value: SizeOverLifetimeModule);
+    /**
+     * The RotationOverLifetimeModule of a Particle System.
+     */
+    get rotationOverLifetime(): RotationOverLifetimeModule;
+    set rotationOverLifetime(value: RotationOverLifetimeModule);
+    /**
+     * The TextureSheetAnimationModule of a Particle System.
+     */
+    get textureSheetAnimation(): TextureSheetAnimationModule;
+    set textureSheetAnimation(value: TextureSheetAnimationModule);
+    /**
+     * Self-defined bounding box
+     */
+    get customBounds(): BoundingBox;
+    set customBounds(value: BoundingBox);
+    constructor(renderer: ParticleRenderer);
+    /**
+     * Starts the Particle System.
+     */
+    play(): void;
+    /**
+     * Pauses the system so no new particles are emitted and the existing particles are not updated.
+     */
+    pause(): void;
+    /**
+     * Fast-forwards the Particle System by simulating particles over the given period of time, then pauses it.
+     * @param time - Time period in seconds to advance the ParticleSystem simulation by.
+     * @param restart - Restart and start from the beginning.
+     */
+    simulate(time: number, restart?: boolean): void;
+    /**
+     * Stops playing the Particle System using the supplied stop behaviour.
+     */
+    stop(): void;
+    protected _updateEmission(elapsedTime: number): void;
+    protected _updateParticles(elapsedTime: number): void;
+    protected _advanceTime(elapsedTime: number, emitTime: number): void;
+    protected _advanceDistance(emitTime: number): void;
+    protected _burst(fromTime: number, toTime: number): number;
+    protected _retireActiveParticles(): void;
+    protected _freeRetiredParticles(): void;
+    protected _emit(time: number): boolean;
+    protected _addParticle(position: Vector3, direction: Vector3, time: number): boolean;
+    protected _addNewParticlesToVertexBuffer(): void;
+    protected _updateParticlesSimulationRestart(time: number): void;
+}

package/types/particle/ParticleShaderDeclaration.d.ts

@@ -0,0 +1 @@
+export {};

package/types/particle/ParticleShaderMacro.d.ts

@@ -0,0 +1 @@
+export {};

package/types/particle/ParticleShaderProperty.d.ts

@@ -0,0 +1 @@
+export {};

package/types/particle/ParticleSystem.d.ts

@@ -0,0 +1,41 @@
+import { ParticleRenderer } from "./ParticleRenderer";
+import { EmissionModule } from "./modules/EmissionModule";
+import { MainModule } from "./modules/MainModule";
+import { ShapeModule } from "./modules/ShapeModule";
+/**
+ * Particle System.
+ */
+export declare class ParticleGenerator {
+    /** Use auto random seed. */
+    useAutoRandomSeed: boolean;
+    /** Main module. */
+    readonly main: MainModule;
+    /** Emission module. */
+    readonly emission: EmissionModule;
+    /** Shape module. */
+    readonly shape: ShapeModule;
+    private _waitProcessRetiredElementCount;
+    private _instanceVertexBufferBinding;
+    private _instanceVertices;
+    private readonly _engine;
+    private readonly _renderer;
+    private readonly _particleIncreaseCount;
+    /**
+     * Random seed.
+     * @remarks If `useAutoRandomSeed` is true, this value will be random changed when play.
+     */
+    get randomSeed(): number;
+    set randomSeed(value: number);
+    constructor(renderer: ParticleRenderer);
+    /**
+     * Emit a certain number of particles.
+     * @param count - Number of particles to emit
+     */
+    emit(count: number): void;
+    private _addNewParticle;
+    private _retireActiveParticles;
+    private _freeRetiredParticles;
+    private _addNewParticlesToVertexBuffer;
+    private _createParticleData;
+    private _addVertexBufferBindingsFilterDuplicate;
+}

package/types/particle/ParticleVertexElements.d.ts

@@ -0,0 +1 @@
+export {};

package/types/particle/ParticleVertexUtils.d.ts

@@ -0,0 +1 @@
+export {};

package/types/particle/enum/ParticleAnimationRowMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The mode used for selecting rows of an animation in the Texture Sheet Animation Module.
+ */
+export declare enum ParticleAnimationRowMode {
+    /** Use a random row for each particle. */
+    Random = 0,
+    /** Use the mesh index as the row, so that meshes can be mapped to specific animation frames. */
+    MeshIndex = 1
+}