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

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 System.
+ */
+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 System in seconds. */
+    duration: number;
+    /** Specifies whether the Particle System 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 System 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 System first spawns them. */
+    startSize: ParticleCompositeCurve;
+    /** The initial size of particles along the x-axis when the Particle System first spawns them. */
+    startSizeX: ParticleCompositeCurve;
+    /** The initial size of particles along the y-axis when the Particle System first spawns them. */
+    startSizeY: ParticleCompositeCurve;
+    /** The initial size of particles along the z-axis when the Particle System first spawns them. */
+    startSizeZ: ParticleCompositeCurve;
+    /** A flag to enable 3D particle rotation. */
+    startRotation3D: boolean;
+    /** The initial rotation of particles when the Particle System 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 System 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 System. */
+    simulationSpeed: number;
+    /** Control how the Particle System 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;
+}

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

@@ -0,0 +1,94 @@
+import { Color } from "@galacean/engine-math";
+/**
+ * Particle gradient.
+ */
+export declare class ParticleGradient {
+    private _colorKeys;
+    private _alphaKeys;
+    private _colorTypeArray;
+    private _alphaTypeArray;
+    private _colorTypeArrayDirty;
+    private _alphaTypeArrayDirty;
+    /**
+     * The color keys of the gradient.
+     */
+    get colorKeys(): ReadonlyArray<GradientColorKey>;
+    /**
+     * The alpha keys of the gradient.
+     */
+    get alphaKeys(): ReadonlyArray<GradientAlphaKey>;
+    /**
+     * Create a new particle gradient.
+     * @param colorKeys - The color keys of the gradient
+     * @param alphaKeys - The alpha keys of the gradient
+     */
+    constructor(colorKeys?: GradientColorKey[], alphaKeys?: GradientAlphaKey[]);
+    /**
+     * Add a color key to the gradient.
+     * @param key - The key
+     */
+    addColorKey(key: GradientColorKey): void;
+    /**
+     * Add a color key to the gradient.
+     * @param time - The key time
+     * @param color - The key color
+     */
+    addColorKey(time: number, color: Color): void;
+    /**
+     * Add an alpha key to the gradient.
+     * @param key - The key
+     */
+    addAlphaKey(key: GradientAlphaKey): void;
+    /**
+     * Add an alpha key to the gradient.
+     * @param time - The key time
+     * @param alpha - The key alpha
+     */
+    addAlphaKey(time: number, alpha: number): void;
+    /**
+     * Remove a color key from the gradient.
+     * @param index - The remove color key index
+     */
+    removeColorKey(index: number): void;
+    /**
+     * Remove an alpha key from the gradient.
+     * @param index - The remove alpha key index
+     */
+    removeAlphaKey(index: number): void;
+    /**
+     * Set the keys of the gradient.
+     * @param colorKeys - The color keys
+     * @param alphaKeys - The alpha keys
+     */
+    setKeys(colorKeys: GradientColorKey[], alphaKeys: GradientAlphaKey[]): void;
+    private _addKey;
+    private _removeKey;
+}
+/**
+ * The color key of the particle gradient.
+ */
+export declare class GradientColorKey {
+    /** The key time. */
+    time: number;
+    /** The key color. */
+    color: Color;
+    constructor(
+    /** The key time. */
+    time: number, 
+    /** The key color. */
+    color: Color);
+}
+/**
+ * The alpha key of the particle gradient.
+ */
+export declare class GradientAlphaKey {
+    /** The key time. */
+    time: number;
+    /** The key alpha. */
+    alpha: number;
+    constructor(
+    /** The key time. */
+    time: number, 
+    /** The key alpha. */
+    alpha: number);
+}

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

@@ -0,0 +1,34 @@
+import { ShaderMacro } from "../../shader/ShaderMacro";
+import { ShaderProperty } from "../../shader/ShaderProperty";
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+/**
+ * Rotate particles throughout their lifetime.
+ */
+export declare class RotationOverLifetimeModule extends ParticleGeneratorModule {
+    static readonly _constantModeMacro: ShaderMacro;
+    static readonly _curveModeMacro: ShaderMacro;
+    static readonly _isSeparateMacro: ShaderMacro;
+    static readonly _isRandomTwoMacro: ShaderMacro;
+    static readonly _minConstantProperty: ShaderProperty;
+    static readonly _minCurveXProperty: ShaderProperty;
+    static readonly _minCurveYProperty: ShaderProperty;
+    static readonly _minCurveZProperty: ShaderProperty;
+    static readonly _maxConstantProperty: ShaderProperty;
+    static readonly _maxCurveXProperty: ShaderProperty;
+    static readonly _maxCurveYProperty: ShaderProperty;
+    static readonly _maxCurveZProperty: ShaderProperty;
+    /** Specifies whether the rotation is separate on each axis, when disabled only z axis is used. */
+    separateAxes: boolean;
+    /** Rotation over lifetime for z axis. */
+    rotationX: ParticleCompositeCurve;
+    /** Rotation over lifetime for z axis. */
+    rotationY: ParticleCompositeCurve;
+    /** Rotation over lifetime for z axis. */
+    rotationZ: ParticleCompositeCurve;
+    private _rotationMinConstant;
+    private _rotationMaxConstant;
+    private _enableSeparateMacro;
+    private _isCurveMacro;
+    private _isRandomTwoMacro;
+}

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

@@ -0,0 +1,9 @@
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+import { BaseShape } from "./shape/BaseShape";
+/**
+ * Shape module of `ParticleGenerator`.
+ */
+export declare class ShapeModule extends ParticleGeneratorModule {
+    /** The shape of the emitter. */
+    shape: BaseShape;
+}

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

@@ -0,0 +1,34 @@
+import { ShaderMacro } from "../../shader/ShaderMacro";
+import { ShaderProperty } from "../../shader/ShaderProperty";
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+/**
+ * Size over lifetime module.
+ */
+export declare class SizeOverLifetimeModule extends ParticleGeneratorModule {
+    static readonly _curveModeMacro: ShaderMacro;
+    static readonly _isSeparateMacro: ShaderMacro;
+    static readonly _isRandomTwoMacro: ShaderMacro;
+    static readonly _minCurveXProperty: ShaderProperty;
+    static readonly _minCurveYProperty: ShaderProperty;
+    static readonly _minCurveZProperty: ShaderProperty;
+    static readonly _maxCurveXProperty: ShaderProperty;
+    static readonly _maxCurveYProperty: ShaderProperty;
+    static readonly _maxCurveZProperty: ShaderProperty;
+    /** Specifies whether the Size is separate on each axis. */
+    separateAxes: boolean;
+    /** Size curve over lifetime for x axis. */
+    sizeX: ParticleCompositeCurve;
+    /** Size curve over lifetime for y axis. */
+    sizeY: ParticleCompositeCurve;
+    /** Size curve over lifetime for z axis. */
+    sizeZ: ParticleCompositeCurve;
+    private _enableSeparateMacro;
+    private _isCurveMacro;
+    private _isRandomTwoMacro;
+    /**
+     * Size curve over lifetime.
+     */
+    get size(): ParticleCompositeCurve;
+    set size(value: ParticleCompositeCurve);
+}

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

@@ -0,0 +1,42 @@
+import { Vector2 } from "@galacean/engine-math";
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+/**
+ * Texture sheet animation module.
+ */
+export declare class TextureSheetAnimationModule extends ParticleGeneratorModule {
+    private static readonly _frameCurveMacro;
+    private static readonly _frameRandomCurvesMacro;
+    private static readonly _cycleCountProperty;
+    private static readonly _tillingParamsProperty;
+    private static readonly _frameMinCurveProperty;
+    private static readonly _frameMaxCurveProperty;
+    /** Start frame of the texture sheet. */
+    readonly startFrame: ParticleCompositeCurve;
+    /** Frame over time curve of the texture sheet. */
+    readonly frameOverTime: ParticleCompositeCurve;
+    /** Texture sheet animation type. */
+    type: TextureSheetAnimationType;
+    /** Cycle count. */
+    cycleCount: number;
+    private _tiling;
+    private _textureSheetMacro;
+    /**
+     * Tiling of the texture sheet.
+     * */
+    get tiling(): Vector2;
+    set tiling(value: Vector2);
+    /**
+     * @inheritDoc
+     */
+    cloneTo(dest: TextureSheetAnimationModule): void;
+}
+/**
+ * Texture sheet animation type.
+ */
+export declare enum TextureSheetAnimationType {
+    /** Animate over the whole texture sheet from left to right, top to bottom. */
+    WholeSheet = 0,
+    /** Animate a single row in the sheet from left to right. */
+    SingleRow = 1
+}