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

package/types/particle/module/TextureSheetAnimationModule.d.ts

@@ -0,0 +1,37 @@
+import { FrameOverTime } from "./FrameOverTime";
+import { StartFrame } from "./StartFrame";
+import { IClone } from "@galacean/engine-design";
+import { ParticleAnimationRowMode, ParticleAnimationType } from "../enum";
+/**
+ * This module allows you to add animations to your particle textures.
+ */
+export declare class TextureSheetAnimationModule implements IClone {
+    /** Specifies the animation type.*/
+    animation: ParticleAnimationType;
+    /** Specifies how many times the animation loops during the lifetime of the particle. */
+    cyclesCount: number;
+    /** Specifies whether the TextureSheetAnimationModule is enabled or disabled. */
+    enable: boolean;
+    /** A curve to control which frame of the Texture sheet animation to play. */
+    frameOverTime: FrameOverTime;
+    /** Defines the tiling of the Texture in the x-axis. */
+    numTilesX: number;
+    /** Defines the tiling of the texture in the y-axis. */
+    numTilesY: number;
+    /** Explicitly select which row of the Texture sheet to use.  */
+    rowIndex: number;
+    /** Select how particles choose which row of a Texture Sheet Animation to use. */
+    rowMode: ParticleAnimationRowMode;
+    /** Define a random starting frame for the Texture sheet animation. */
+    startFrame: StartFrame;
+    /**
+     * @override
+     * @inheritDoc
+     */
+    cloneTo(destTextureSheetAnimation: TextureSheetAnimationModule): void;
+    /**
+     * @override
+     * @inheritDoc
+     */
+    clone(): TextureSheetAnimationModule;
+}

package/types/particle/module/VelocityGradient.d.ts

@@ -0,0 +1,110 @@
+import { ParticleCurve } from "./ParticleCurve";
+import { IClone } from "@galacean/engine-design";
+import { Vector3 } from "@galacean/engine-math";
+import { ParticleCurveMode } from "../enum";
+/**
+ * Curve to control particle speed based on lifetime
+ */
+export declare class VelocityGradient implements IClone {
+    /**
+     * A single constant value for the entire curve.
+     * @param constant - Constant value.
+     */
+    static createByConstant(constant: Vector3): VelocityGradient;
+    /**
+     * Use one curve when evaluating numbers along this Min-Max curve.
+     * @param gradientX - A single curve to evaluate against on X.
+     * @param gradientY - A single curve to evaluate against on Y.
+     * @param gradientZ - A single curve to evaluate against on Z.
+     */
+    static createByGradient(gradientX: ParticleCurve, gradientY: ParticleCurve, gradientZ: ParticleCurve): VelocityGradient;
+    /**
+     * Randomly select values based on the interval between the minimum and maximum constants.
+     * @param constantMin - The constant describing the minimum values to be evaluated.
+     * @param constantMax - The constant describing the maximum values to be evaluated.
+     */
+    static createByRandomTwoConstant(constantMin: Vector3, constantMax: Vector3): VelocityGradient;
+    /**
+     * Randomly select values based on the interval between the minimum and maximum curves.
+     * @param gradientXMin - The curve describing the minimum values to be evaluated on X.
+     * @param gradientXMax - The curve describing the maximum values to be evaluated on X.
+     * @param gradientYMin - The curve describing the minimum values to be evaluated on Y.
+     * @param gradientYMax - The curve describing the maximum values to be evaluated on Y.
+     * @param gradientZMin - The curve describing the minimum values to be evaluated on Z.
+     * @param gradientZMax - The curve describing the maximum values to be evaluated on Z.
+     */
+    static createByRandomTwoGradient(gradientXMin: ParticleCurve, gradientXMax: ParticleCurve, gradientYMin: ParticleCurve, gradientYMax: ParticleCurve, gradientZMin: ParticleCurve, gradientZMax: ParticleCurve): VelocityGradient;
+    private _mode;
+    private _constant;
+    private _constantMin;
+    private _constantMax;
+    private _gradientX;
+    private _gradientY;
+    private _gradientZ;
+    private _gradientXMin;
+    private _gradientYMin;
+    private _gradientZMin;
+    private _gradientXMax;
+    private _gradientYMax;
+    private _gradientZMax;
+    /**
+     * The mode that the min-max curve uses to evaluate values.
+     */
+    get mode(): ParticleCurveMode;
+    /**
+     * The constant value.
+     */
+    get constant(): Vector3;
+    /**
+     * The curve on X.
+     */
+    get gradientX(): ParticleCurve;
+    /**
+     * The curve on Y.
+     */
+    get gradientY(): ParticleCurve;
+    /**
+     * The curve on Z.
+     */
+    get gradientZ(): ParticleCurve;
+    /**
+     * The constant for the lower bound.
+     */
+    get constantMin(): Vector3;
+    /**
+     * The constant for the upper bound.
+     */
+    get constantMax(): Vector3;
+    /**
+     * The curve for the lower bound on X.
+     */
+    get gradientXMin(): ParticleCurve;
+    /**
+     * The curve for the upper bound on X.
+     */
+    get gradientXMax(): ParticleCurve;
+    /**
+     * The curve for the lower bound on Y.
+     */
+    get gradientYMin(): ParticleCurve;
+    /**
+     * The curve for the upper bound on Y.
+     */
+    get gradientYMax(): ParticleCurve;
+    /**
+     * The curve for the lower bound on Z.
+     */
+    get gradientZMin(): ParticleCurve;
+    /**
+     * The curve for the upper bound on Z.
+     */
+    get gradientZMax(): ParticleCurve;
+    /**
+     * @override
+     */
+    cloneTo(destGradientVelocity: VelocityGradient): void;
+    /**
+     * @override
+     */
+    clone(): VelocityGradient;
+}

package/types/particle/module/VelocityOverLifetimeModule.d.ts

@@ -0,0 +1,22 @@
+import { VelocityGradient } from "./VelocityGradient";
+import { IClone } from "@galacean/engine-design";
+import { ParticleSimulationSpace } from "../enum";
+/**
+ * This module sets the velocity of particles during their lifetime.
+ */
+export declare class VelocityOverLifetimeModule implements IClone {
+    /** Get Gradient Velocity。 */
+    velocity: VelocityGradient;
+    /** Specifies whether the VelocityOverLifetimeModule is enabled or disabled. */
+    enable: boolean;
+    /** Specifies if the velocities are in local space (rotated with the transform) or world space. */
+    space: ParticleSimulationSpace;
+    /**
+     * @override
+     */
+    cloneTo(destVelocityOverLifetime: VelocityOverLifetimeModule): void;
+    /**
+     * @override
+     */
+    clone(): VelocityOverLifetimeModule;
+}

package/types/particle/module/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./shape";
+export { Burst } from "./Burst";
+export { EmissionModule } from "./EmissionModule";
+export { ColorGradient } from "./ColorGradient";
+export { ColorOverLifetimeModule } from "./ColorOverLifetimeModule";
+export { ParticleCurve } from "./ParticleCurve";
+export { VelocityGradient } from "./VelocityGradient";
+export { VelocityOverLifetimeModule } from "./VelocityOverLifetimeModule";
+export { RotationVelocityGradient } from "./RotationVelocityGradient";
+export { RotationOverLifetimeModule } from "./RotationOverLifetimeModule";
+export { SizeGradient } from "./SizeGradient";
+export { SizeOverLifetimeModule } from "./SizeOverLifetimeModule";
+export { StartFrame } from "./StartFrame";
+export { FrameOverTime } from "./FrameOverTime";
+export { TextureSheetAnimationModule } from "./TextureSheetAnimationModule";

package/types/particle/module/shape/BaseShape.d.ts

@@ -0,0 +1,26 @@
+import { IClone } from "@galacean/engine-design";
+import { BoundingBox } from "@galacean/engine-math";
+import { ParticleShapeType } from "../../enum/ParticleShapeType";
+/**
+ * Configures the initial positions and directions of particles.
+ */
+export declare class BaseShape implements IClone {
+    /** The type of shape to emit particles from. */
+    shapeType: ParticleShapeType;
+    /** Specifies whether the ShapeModule is enabled or disabled. */
+    enable: boolean;
+    /** Randomizes the starting direction of particles. */
+    randomDirectionAmount: number;
+    /**
+     * @override
+     * @inheritDoc
+     */
+    cloneTo(destShape: BaseShape): void;
+    /**
+     * @override
+     * @inheritDoc
+     */
+    clone(): BaseShape;
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+}

package/types/particle/module/shape/BoxShape.d.ts

@@ -0,0 +1,20 @@
+import { BaseShape } from "./BaseShape";
+import { BoundingBox, Vector3 } from "@galacean/engine-math";
+/**
+ * Box emitter shape
+ */
+export declare class BoxShape extends BaseShape {
+    /** Thickness of the box to emit particles from. */
+    boxThickness: Vector3;
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    /**
+     * @inheritDoc
+     */
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+    cloneTo(destShape: BoxShape): void;
+    clone(): BoxShape;
+}

package/types/particle/module/shape/CircleShape.d.ts

@@ -0,0 +1,27 @@
+import { BaseShape } from "./BaseShape";
+import { BoundingBox, Rand, Vector2, Vector3 } from "@galacean/engine-math";
+import { ParticleShapeMultiModeValue } from "../../enum";
+/**
+ * Circle Particle Emitter
+ */
+export declare class CircleShape extends BaseShape {
+    protected static _tempPositionPoint: Vector2;
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    /** Angle of the circle arc to emit particles from. */
+    arc: number;
+    /** The mode to generate particles around the arc. */
+    arcMode: ParticleShapeMultiModeValue;
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    /**
+     * @inheritDoc
+     */
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+    _generatePositionAndDirection(position: Vector3, direction: Vector3, rand?: Rand, randomSeeds?: Uint32Array): void;
+    cloneTo(destShape: CircleShape): void;
+    clone(): CircleShape;
+}

package/types/particle/module/shape/ConeShape.d.ts

@@ -0,0 +1,35 @@
+import { BaseShape } from "./BaseShape";
+import { BoundingBox, Rand, Vector2, Vector3 } from "@galacean/engine-math";
+export declare enum ConeEmitType {
+    Base = 0,
+    BaseShell = 1,
+    Volume = 2,
+    VolumeShell = 3
+}
+/**
+ * Cone particle emitter
+ */
+export declare class ConeShape extends BaseShape {
+    protected static _tempPositionPoint: Vector2;
+    protected static _tempDirectionPoint: Vector2;
+    /** Angle of the cone to emit particles from. */
+    angle: number;
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    /** Length of the cone to emit particles from. */
+    length: number;
+    /** Cone emitter subtype */
+    emitType: ConeEmitType;
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    /**
+     * @inheritDoc
+     */
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+    _generatePositionAndDirection(position: Vector3, direction: Vector3, rand?: Rand, randomSeeds?: Uint32Array): void;
+    cloneTo(destShape: ConeShape): void;
+    clone(): ConeShape;
+}

package/types/particle/module/shape/HemisphereShape.d.ts

@@ -0,0 +1,23 @@
+import { BaseShape } from "./BaseShape";
+import { BoundingBox, Rand, Vector3 } from "@galacean/engine-math";
+/**
+ * Hemisphere emitter
+ */
+export declare class HemisphereShape extends BaseShape {
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    /** Whether emit from shell */
+    emitFromShell: boolean;
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    /**
+     * @inheritDoc
+     */
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+    _generatePositionAndDirection(position: Vector3, direction: Vector3, rand?: Rand, randomSeeds?: Uint32Array): void;
+    cloneTo(destShape: HemisphereShape): void;
+    clone(): HemisphereShape;
+}

package/types/particle/module/shape/ShapeUtils.d.ts

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

package/types/particle/module/shape/SphereShape.d.ts

@@ -0,0 +1,23 @@
+import { BaseShape } from "./BaseShape";
+import { BoundingBox, Rand, Vector3 } from "@galacean/engine-math";
+/**
+ * Sphere emitter
+ */
+export declare class SphereShape extends BaseShape {
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    /** Whether emit from shell */
+    emitFromShell: boolean;
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    /**
+     * @inheritDoc
+     */
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+    _generatePositionAndDirection(position: Vector3, direction: Vector3, rand?: Rand, randomSeeds?: Uint32Array): void;
+    cloneTo(destShape: SphereShape): void;
+    clone(): SphereShape;
+}

package/types/particle/module/shape/index.d.ts

@@ -0,0 +1,5 @@
+export { BoxShape } from "./BoxShape";
+export { CircleShape } from "./CircleShape";
+export { ConeShape, ConeEmitType } from "./ConeShape";
+export { HemisphereShape } from "./HemisphereShape";
+export { SphereShape } from "./SphereShape";

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;
+}