@galacean/engine-core 0.0.0-experimental-0.9-plus.8 → 0.0.0-experimental-double11.1

package/types/mesh/PrimitiveMesh.d.ts

@@ -63,8 +63,8 @@ export declare class PrimitiveMesh {
      * @param engine - Engine
      * @param radius - The radius of cap
      * @param height - The height of torso
-     * @param radialSegments - Cylinder radial segments
-     * @param heightSegments - Cylinder height segments
+     * @param radialSegments - Cone radial segments
+     * @param heightSegments - Cone height segments
      * @param noLongerAccessible - No longer access the vertices of the mesh after creation
      * @returns Cone model mesh
      */
@@ -80,6 +80,8 @@ export declare class PrimitiveMesh {
      * @returns Capsule model mesh
      */
     static createCapsule(engine: Engine, radius?: number, height?: number, radialSegments?: number, heightSegments?: number, noLongerAccessible?: boolean): ModelMesh;
+    static _setCylinderData(cylinderMesh: ModelMesh, radiusTop: number, radiusBottom: number, height: number, radialSegments: number, heightSegments: number, noLongerAccessible: boolean, isRestoreMode: boolean): void;
+    static _setCapsuleData(capsuleMesh: ModelMesh, radius: number, height: number, radialSegments: number, heightSegments: number, noLongerAccessible: boolean, isRestoreMode: boolean): void;
     private static _initialize;
     private static _generateIndices;
     private static _createCapsuleCap;

package/types/mesh/SkinnedMeshRenderer.d.ts

@@ -1,17 +1,14 @@
 import { BoundingBox } from "@galacean/engine-math";
 import { Entity } from "../Entity";
-import { RenderContext } from "../RenderPipeline/RenderContext";
 import { MeshRenderer } from "./MeshRenderer";
 import { Skin } from "./Skin";
 /**
  * SkinnedMeshRenderer.
  */
 export declare class SkinnedMeshRenderer extends MeshRenderer {
-    private static _tempMatrix;
     private static _jointCountProperty;
     private static _jointSamplerProperty;
     private static _jointMatrixProperty;
-    private _supportSkinning;
     private _hasInitSkin;
     private _jointDataCreateCache;
     private _skin;
@@ -43,18 +40,6 @@ export declare class SkinnedMeshRenderer extends MeshRenderer {
      */
     get rootBone(): Entity;
     set rootBone(value: Entity);
-    /**
-     * @override
-     */
-    protected _updateShaderData(context: RenderContext): void;
-    /**
-     * @override
-     */
-    protected _registerEntityTransformListener(): void;
-    /**
-     * @override
-     */
-    protected _updateBounds(worldBounds: BoundingBox): void;
     private _initSkin;
     private _computeApproximateBindMatrix;
     private _findByEntityName;

package/types/particle/ParticleBufferUtils.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/ParticleRenderer.d.ts

@@ -1,6 +1,6 @@
-import { Vector3, Color } from "@galacean/engine-math";
-import { Texture } from "../texture";
+import { Color, Vector3 } from "@galacean/engine-math";
 import { MeshRenderer } from "../mesh/MeshRenderer";
+import { Texture } from "../texture";
 /**
  * Blend mode enums of the particle renderer's material.
  */

package/types/particle/enums/ParticleCurveMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Particle curve mode.
+ */
+export declare enum ParticleCurveMode {
+    Constant = 0,
+    TwoConstants = 1,
+    Curve = 2,
+    TwoCurves = 3
+}

package/types/particle/enums/ParticleGradientMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Particle gradient mode.
+ */
+export declare enum ParticleGradientMode {
+    Constant = 0,
+    TwoConstants = 1,
+    Gradient = 2,
+    TwoGradients = 3
+}

package/types/particle/enums/ParticleRandomSubSeeds.d.ts

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

package/types/particle/enums/ParticleRenderMode.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The rendering mode for particle renderer.
+ */
+export declare enum ParticleRenderMode {
+    /** Render particles as billboards facing the active camera. */
+    Billboard = 0,
+    /** Stretch particles in the direction of motion. */
+    StretchBillboard = 1,
+    /** Render particles as billboards always facing up along the y-Axis. */
+    HorizontalBillboard = 2,
+    /** Render particles as billboards always facing the player, but not pitching along the x-Axis. */
+    VerticalBillboard = 3,
+    /** Render particles as meshes. */
+    Mesh = 4,
+    /** Do not render particles. */
+    None = 5
+}

package/types/particle/enums/ParticleScaleMode.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Control how Particle Generator apply transform scale.
+ */
+export declare enum ParticleScaleMode {
+    /** Scale the Particle Generator using the entire transform hierarchy. */
+    Hierarchy = 0,
+    /** Scale the Particle Generator using only its own transform scale. (Ignores parent scale). */
+    Local = 1,
+    /** Only apply transform scale to the shape component, which controls where particles are spawned, but does not affect their size or movement. */
+    World = 2
+}

package/types/particle/enums/ParticleSimulationSpace.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The space to simulate particles in.
+ */
+export declare enum ParticleSimulationSpace {
+    /** Simulate particles in local space. */
+    Local = 0,
+    /** Simulate particles in world space. */
+    World = 1
+}

package/types/particle/enums/ParticleStopMode.d.ts

@@ -0,0 +1,6 @@
+export declare enum ParticleStopMode {
+    /** Stop emitting new particles and clear existing particles immediately. */
+    StopEmittingAndClear = 0,
+    /** Stop emitting new particles, but keep existing particles until they expire. */
+    StopEmitting = 1
+}

package/types/particle/enums/attributes/BillboardParticleVertexAttribute.d.ts

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

package/types/particle/enums/attributes/MeshParticleVertexAttribute.d.ts

@@ -0,0 +1,5 @@
+export declare enum MeshParticleVertexAttribute {
+    MeshPosition = "a_MeshPosition",
+    MeshColor = "a_MeshColor",
+    MeshTextureCoordinate = "a_MeshTextureCoordinate"
+}

package/types/particle/enums/attributes/ParticleInstanceVertexAttribute.d.ts

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

package/types/particle/modules/Burst.d.ts

@@ -0,0 +1,14 @@
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+/**
+ * A burst is a particle emission event, where a number of particles are all emitted at the same time
+ */
+export declare class Burst {
+    time: number;
+    count: ParticleCompositeCurve;
+    /**
+     * Create burst object.
+     * @param time - Time to emit the burst
+     * @param count - Count of particles to emit
+     */
+    constructor(time: number, count: ParticleCompositeCurve);
+}

package/types/particle/modules/ColorOverLifetimeModule.d.ts

@@ -0,0 +1,20 @@
+import { ShaderMacro } from "../../shader/ShaderMacro";
+import { ShaderProperty } from "../../shader/ShaderProperty";
+import { ParticleCompositeGradient } from "./ParticleCompositeGradient";
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+/**
+ * Color over lifetime module.
+ */
+export declare class ColorOverLifetimeModule extends ParticleGeneratorModule {
+    static readonly _gradientMacro: ShaderMacro;
+    static readonly _randomGradientsMacro: ShaderMacro;
+    static readonly _minGradientColor: ShaderProperty;
+    static readonly _minGradientAlpha: ShaderProperty;
+    static readonly _maxGradientColor: ShaderProperty;
+    static readonly _maxGradientAlpha: ShaderProperty;
+    static readonly _gradientKeysCount: ShaderProperty;
+    /** Color gradient over lifetime. */
+    color: ParticleCompositeGradient;
+    private _gradientKeysCount;
+    private _colorMacro;
+}

package/types/particle/modules/EmissionModule.d.ts

@@ -0,0 +1,45 @@
+import { Burst } from "./Burst";
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+import { BaseShape } from "./shape/BaseShape";
+/**
+ * The EmissionModule of a Particle Generator.
+ */
+export declare class EmissionModule extends ParticleGeneratorModule {
+    /**  The rate of particle emission. */
+    rateOverTime: ParticleCompositeCurve;
+    /**  The rate at which the emitter spawns new particles over distance. */
+    rateOverDistance: ParticleCompositeCurve;
+    /** The shape of the emitter. */
+    shape: BaseShape;
+    private _bursts;
+    private _frameRateTime;
+    private _currentBurstIndex;
+    private _burstRand;
+    /**
+     * Gets the burst array.
+     */
+    get bursts(): ReadonlyArray<Burst>;
+    /**
+     * Add a single burst.
+     * @param burst - The burst
+     */
+    addBurst(burst: Burst): void;
+    /**
+     * Remove a single burst from the array of bursts.
+     * @param burst - The burst data
+     */
+    removeBurst(burst: Burst): void;
+    /**
+     * Remove a single burst from the array of bursts.
+     * @param index - The burst data index
+     */
+    removeBurstByIndex(index: number): void;
+    /**
+     * Clear burst data.
+     */
+    clearBurst(): void;
+    private _emitByRateOverTime;
+    private _emitByBurst;
+    private _emitBySubBurst;
+}

package/types/particle/modules/MainModule.d.ts

@@ -0,0 +1,68 @@
+import { ICustomClone } from "../../clone/ComponentCloner";
+import { ParticleScaleMode } from "../enums/ParticleScaleMode";
+import { ParticleSimulationSpace } from "../enums/ParticleSimulationSpace";
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+import { ParticleCompositeGradient } from "./ParticleCompositeGradient";
+export declare class MainModule implements ICustomClone {
+    private static _tempVector40;
+    private static _vector3One;
+    private static readonly _positionScale;
+    private static readonly _sizeScale;
+    private static readonly _worldPosition;
+    private static readonly _worldRotation;
+    private static readonly _gravity;
+    private static readonly _simulationSpace;
+    private static readonly _startRotation3D;
+    private static readonly _scaleMode;
+    /** The duration of the Particle Generator in seconds. */
+    duration: number;
+    /** Specifies whether the Particle Generator loops. */
+    isLoop: boolean;
+    /** Start delay in seconds. */
+    startDelay: ParticleCompositeCurve;
+    /** The initial lifetime of particles when emitted. */
+    startLifetime: ParticleCompositeCurve;
+    /** The initial speed of particles when the Particle Generator first spawns them. */
+    startSpeed: ParticleCompositeCurve;
+    /** A flag to enable specifying particle size individually for each axis. */
+    startSize3D: boolean;
+    /** The initial size of particles when the Particle Generator first spawns them. */
+    startSize: ParticleCompositeCurve;
+    /** The initial size of particles along the x-axis when the Particle Generator first spawns them. */
+    startSizeX: ParticleCompositeCurve;
+    /** The initial size of particles along the y-axis when the Particle Generator first spawns them. */
+    startSizeY: ParticleCompositeCurve;
+    /** The initial size of particles along the z-axis when the Particle Generator first spawns them. */
+    startSizeZ: ParticleCompositeCurve;
+    /** A flag to enable 3D particle rotation. */
+    startRotation3D: boolean;
+    /** The initial rotation of particles when the Particle Generator first spawns them. */
+    startRotation: ParticleCompositeCurve;
+    /** The initial rotation of particles around the x-axis when emitted.*/
+    startRotationX: ParticleCompositeCurve;
+    /** The initial rotation of particles around the y-axis when emitted. */
+    startRotationY: ParticleCompositeCurve;
+    startRotationZ: ParticleCompositeCurve;
+    /** Makes some particles spin in the opposite direction. */
+    flipRotation: number;
+    /** The mode of start color */
+    startColor: ParticleCompositeGradient;
+    /** A scale that this Particle Generator applies to gravity, defined by Physics.gravity. */
+    gravityModifier: ParticleCompositeCurve;
+    /** 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 Generator. */
+    simulationSpeed: number;
+    /** Control how the Particle Generator applies its Transform component to the particles it emits. */
+    scalingMode: ParticleScaleMode;
+    /** If set to true, the Particle Generator automatically begins to play on startup. */
+    playOnEnabled: boolean;
+    private _maxParticles;
+    private _generator;
+    private _gravity;
+    /**
+     * Max particles count.
+     */
+    get maxParticles(): number;
+    set maxParticles(value: number);
+}

package/types/particle/modules/ParticleCompositeCurve.d.ts

@@ -0,0 +1,56 @@
+import { ParticleCurveMode } from "../enums/ParticleCurveMode";
+import { ParticleCurve } from "./ParticleCurve";
+/**
+ * Particle composite curve.
+ */
+export declare class ParticleCompositeCurve {
+    /** The curve mode. */
+    mode: ParticleCurveMode;
+    /** The min constant value used by the curve if mode is set to `TwoConstants`.*/
+    constantMin: number;
+    /** The max constant value used by the curve if mode is set to `TwoConstants`.*/
+    constantMax: number;
+    /** The min curve used by the curve if mode is set to `TwoCurves`. */
+    curveMin: ParticleCurve;
+    /** The max curve used by the curve if mode is set to `TwoCurves`. */
+    curveMax: ParticleCurve;
+    /**
+     * The constant value used by the curve if mode is set to `Constant`.
+     */
+    get constant(): number;
+    set constant(value: number);
+    /**
+     * The curve used by the curve if mode is set to `Curve`.
+     */
+    get curve(): ParticleCurve;
+    set curve(value: ParticleCurve);
+    /**
+     * Create a particle curve that generates a constant value.
+     * @param constant - The constant value
+     */
+    constructor(constant: number);
+    /**
+     * Create a particle curve that can generate values between a minimum constant and a maximum constant.
+     * @param constantMin - The min constant value
+     * @param constantMax - The max constant value
+     */
+    constructor(constantMin: number, constantMax: number);
+    /**
+     * Create a particle composite curve by a curve.
+     * @param curve - The curve
+     */
+    constructor(curve: ParticleCurve);
+    /**
+     * Create a particle composite curve by min and max curves.
+     * @param curveMin - The min curve
+     * @param curveMax - The max curve
+     */
+    constructor(curveMin: ParticleCurve, curveMax: ParticleCurve);
+    /**
+     * Query the value at the specified time.
+     * @param time - Normalized time at which to evaluate the curve, Valid when `mode` is set to `Curve` or `TwoCurves`
+     * @param lerpFactor - Lerp factor between two constants or curves, Valid when `mode` is set to `TwoConstants` or `TwoCurves`
+     * @returns - The result curve value
+     */
+    evaluate(time: number, lerpFactor: number): number;
+}

package/types/particle/modules/ParticleCompositeGradient.d.ts

@@ -0,0 +1,55 @@
+import { Color } from "@galacean/engine-math";
+import { ParticleGradientMode } from "../enums/ParticleGradientMode";
+import { ParticleGradient } from "./ParticleGradient";
+/**
+ * Particle composite gradient.
+ */
+export declare class ParticleCompositeGradient {
+    /** The gradient mode. */
+    mode: ParticleGradientMode;
+    constantMin: Color;
+    constantMax: Color;
+    /** The min gradient used by the gradient if mode is set to `Gradient`. */
+    gradientMin: ParticleGradient;
+    /** The max gradient used by the gradient if mode is set to `Gradient`. */
+    gradientMax: ParticleGradient;
+    /**
+     *  The constant color used by the gradient if mode is set to `Constant`.
+     */
+    get constant(): Color;
+    set constant(value: Color);
+    /**
+     * The gradient used by the gradient if mode is set to `Gradient`.
+     */
+    get gradient(): ParticleGradient;
+    set gradient(value: ParticleGradient);
+    /**
+     * Create a particle gradient that generates a constant color.
+     * @param constant - The constant color
+     */
+    constructor(constant: Color);
+    /**
+     * Create a particle gradient that can generate color between a minimum constant and a maximum constant.
+     * @param constantMin - The min constant color
+     * @param constantMax - The max constant color
+     */
+    constructor(constantMin: Color, constantMax: Color);
+    /**
+     * Create a particle gradient that generates a color from a gradient.
+     * @param gradient - The gradient
+     */
+    constructor(gradient: ParticleGradient);
+    /**
+     * Create a particle gradient that can generate color from a minimum gradient and a maximum gradient.
+     * @param gradientMin - The min gradient
+     *
+     */
+    constructor(gradientMin: ParticleGradient, gradientMax: ParticleGradient);
+    /**
+     * Query the color at the specified time.
+     * @param time - Normalized time at which to evaluate the gradient, Valid when `mode` is set to `Gradient` or `TwoGradients`
+     * @param lerpFactor - Lerp factor between two constants or gradients, Valid when `mode` is set to `TwoConstants` or `TwoGradients`
+     * @param out - The result color
+     */
+    evaluate(time: number, lerpFactor: number, out: Color): void;
+}

package/types/particle/modules/ParticleCurve.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Particle curve.
+ */
+export declare class ParticleCurve {
+    private _keys;
+    private _typeArray;
+    private _typeArrayDirty;
+    /**
+     * The keys of the curve.
+     */
+    get keys(): ReadonlyArray<CurveKey>;
+    /**
+     * Create a new particle curve.
+     * @param keys - The keys of the curve
+     */
+    constructor(...keys: CurveKey[]);
+    /**
+     * Add an key to the curve.
+     * @param key - The key
+     */
+    addKey(key: CurveKey): void;
+    /**
+     * Add an key to the curve.
+     * @param time - The key time
+     * @param value - The key value
+     */
+    addKey(time: number, value: number): void;
+    /**
+     * Remove a key from the curve.
+     * @param index - The remove key index
+     */
+    removeKey(index: number): void;
+    /**
+     * Set the keys of the curve.
+     * @param keys - The keys
+     */
+    setKeys(keys: CurveKey[]): void;
+    private _addKey;
+}
+/**
+ * The key of the curve.
+ */
+export declare class CurveKey {
+    /** The key time. */
+    time: number;
+    /** The key value. */
+    value: number;
+    /**
+     * Create a new key.
+     */
+    constructor(
+    /** The key time. */
+    time: number, 
+    /** The key value. */
+    value: number);
+}

package/types/particle/modules/ParticleGeneratorModule.d.ts

@@ -0,0 +1,12 @@
+import { ShaderData, ShaderMacro } from "../../shader";
+import { ParticleGenerator } from "../ParticleGenerator";
+/**
+ * Particle generator module.
+ */
+export declare abstract class ParticleGeneratorModule {
+    /** Specifies whether the module is enabled or not. */
+    enabled: boolean;
+    protected _generator: ParticleGenerator;
+    constructor(generator: ParticleGenerator);
+    protected _enableMacro(shaderData: ShaderData, lastEnableMacro: ShaderMacro, enableMacro: ShaderMacro): ShaderMacro;
+}