@galacean/engine-core 1.1.0-alpha.1 → 1.1.0-alpha.2

package/package.json

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

package/types/RenderPipeline/MeshRenderElement.d.ts

@@ -4,16 +4,14 @@ import { Material } from "../material/Material";
 import { Renderer } from "../Renderer";
 import { ShaderPass } from "../shader/ShaderPass";
 import { RenderState } from "../shader/state/RenderState";
-import { IPoolElement } from "./IPoolElement";
 import { RenderElement } from "./RenderElement";
 /**
  * Render element.
  */
-export declare class MeshRenderElement extends RenderElement implements IPoolElement {
+export declare class MeshRenderElement extends RenderElement {
     /** Mesh. */
     mesh: Mesh;
     /** Sub mesh. */
     subMesh: SubMesh;
     setValue(component: Renderer, mesh: Mesh, subMesh: SubMesh, material: Material, renderState: RenderState, shaderPass: ShaderPass): 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/SpriteElement.d.ts

@@ -4,12 +4,10 @@ import { Renderer } from "../Renderer";
 import { ShaderPass } from "../shader";
 import { RenderState } from "../shader/state/RenderState";
 import { Texture2D } from "../texture";
-import { IPoolElement } from "./IPoolElement";
 import { RenderElement } from "./RenderElement";
-export declare class SpriteElement extends RenderElement implements IPoolElement {
+export declare class SpriteElement extends RenderElement {
     renderData: RenderData2D;
     texture: Texture2D;
     constructor();
     setValue(component: Renderer, renderDate: RenderData2D, material: Material, texture: Texture2D, renderState: RenderState, shaderPass: ShaderPass): void;
-    dispose(): void;
 }

package/types/RenderPipeline/SpriteMaskElement.d.ts

@@ -1,12 +1,10 @@
 import { RenderData2D } from "../2d/data/RenderData2D";
 import { Material } from "../material/Material";
 import { Renderer } from "../Renderer";
-import { IPoolElement } from "./IPoolElement";
 import { RenderElement } from "./RenderElement";
-export declare class SpriteMaskElement extends RenderElement implements IPoolElement {
+export declare class SpriteMaskElement extends RenderElement {
     renderData: RenderData2D;
     isAdd: boolean;
     constructor();
     setValue(component: Renderer, renderData: RenderData2D, material: Material): void;
-    dispose(): void;
 }

package/types/RenderPipeline/TextRenderElement.d.ts

@@ -1,8 +1,6 @@
-import { IPoolElement } from "./IPoolElement";
 import { RenderElement } from "./RenderElement";
 import { SpriteElement } from "./SpriteElement";
-export declare class TextRenderElement extends RenderElement implements IPoolElement {
+export declare class TextRenderElement extends RenderElement {
     charElements: SpriteElement[];
     constructor();
-    dispose(): void;
 }

package/types/SafeLoopArray.d.ts

@@ -0,0 +1,37 @@
+export declare class SafeLoopArray<T> {
+    private _array;
+    private _loopArray;
+    private _loopArrayDirty;
+    /**
+     * Get the length of the array.
+     */
+    get length(): number;
+    /**
+     * Push item to the array.
+     * @param item - The item which want to be pushed
+     */
+    push(item: T): void;
+    /**
+     * Splice the array.
+     * @param index - The index of the array
+     * @param deleteCount - The count of the array which want to be deleted
+     * @param item - The item which want to be added
+     */
+    splice(index: number, deleteCount: number, item?: T): void;
+    /**
+     * The index of the item.
+     * @param item - The item which want to get the index
+     * @returns Index of the item
+     */
+    indexOf(item: T): number;
+    /**
+     * Get the array.
+     * @returns The array
+     */
+    getArray(): ReadonlyArray<T>;
+    /**
+     * Get the array use for loop.
+     * @returns The array use for loop
+     */
+    getLoopArray(): ReadonlyArray<T>;
+}

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/Transform.d.ts

@@ -195,6 +195,7 @@ export declare class Transform extends Component {
      * @returns Change flag
      */
     registerWorldChangeFlag(): BoolUpdateFlag;
+    protected _onDestroy(): void;
     /**
      * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
      * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.

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

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

package/types/asset/Loader.d.ts

@@ -27,6 +27,6 @@ export declare abstract class Loader<T> {
     private static _engineObjects;
     constructor(useCache: boolean);
     initialize?(engine: Engine, configuration: EngineConfiguration): Promise<void>;
-    abstract load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<T> | Record<string, AssetPromise<any>>;
+    abstract load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<T>;
     request: <U>(url: string, config: RequestConfig) => AssetPromise<U>;
 }

package/types/asset/ResourceManager.d.ts

@@ -26,6 +26,7 @@ export declare class ResourceManager {
     private _graphicResourcePool;
     /** Restorable resource information pool, key is the `instanceID` of resource. */
     private _contentRestorerPool;
+    private _subAssetPromiseCallbacks;
     /**
      * Create a ResourceManager.
      * @param engine - Engine to which the current ResourceManager belongs
@@ -61,6 +62,12 @@ export declare class ResourceManager {
      * @returns Resource object
      */
     getFromCache<T>(url: string): T;
+    /**
+     * Find the resource by type.
+     * @param type - Resource type
+     * @returns - Resource collection
+     */
+    findResourcesByType<T extends EngineObject>(type: new (...args: any[]) => T): T[];
     /**
      * Get asset url from instanceId.
      * @param instanceId - Engine instance id
@@ -93,6 +100,7 @@ export declare class ResourceManager {
     addContentRestorer<T extends EngineObject>(restorer: ContentRestorer<T>): void;
     private _assignDefaultOptions;
     private _loadSingleItem;
+    private _pushSubAssetPromiseCallback;
     private _gc;
     private _getResolveResource;
     private _parseURL;

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/index.d.ts

@@ -22,7 +22,7 @@ export { AssetPromise } from "./asset/AssetPromise";
 export type { LoadItem } from "./asset/LoadItem";
 export { AssetType } from "./asset/AssetType";
 export { ReferResource } from "./asset/ReferResource";
-export * from "./RenderPipeline/Index";
+export * from "./RenderPipeline/index";
 export * from "./base";
 export { Background } from "./Background";
 export { BackgroundMode } from "./enums/BackgroundMode";

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 System.
+ */
+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 system 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 system of the child entity
+     */
+    play(withChildren?: boolean): void;
+    /**
+     * Stop emitting particles.
+     * @param withChildren - Whether to stop the particle system 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 _addNewParticlesToVertexBuffer;
+    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 {};