@galacean/engine-core 0.9.0-beta.80

package/types/UpdateFlag.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Used to update tags.
+ */
+export declare abstract class UpdateFlag {
+    /**
+     * Dispatch.
+     * @param bit - Bit
+     * @param param - Parameter
+     */
+    abstract dispatch(bit?: number, param?: Object): void;
+    /**
+     * Clear.
+     */
+    clearFromManagers(): void;
+    /**
+     * Destroy.
+     */
+    destroy(): void;
+    private _removeFromManagers;
+}

package/types/UpdateFlagManager.d.ts

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

package/types/Utils.d.ts

@@ -0,0 +1,3 @@
+export declare class Utils {
+    private static _stringToPath;
+}

package/types/VirtualCamera.d.ts

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

package/types/animation/AnimationClip.d.ts

@@ -0,0 +1,58 @@
+import { Component } from "../Component";
+import { Entity } from "../Entity";
+import { AnimationClipCurveBinding } from "./AnimationClipCurveBinding";
+import { AnimationCurve } from "./animationCurve/AnimationCurve";
+import { AnimationEvent } from "./AnimationEvent";
+import { KeyframeValueType } from "./Keyframe";
+/**
+ * Stores keyframe based animations.
+ */
+export declare class AnimationClip {
+    readonly name: string;
+    private _length;
+    private _events;
+    /**
+     * Animation events for this animation clip.
+     */
+    get events(): Readonly<AnimationEvent[]>;
+    /**
+     * Animation curve bindings for this animation clip.
+     */
+    get curveBindings(): Readonly<AnimationClipCurveBinding[]>;
+    /**
+     * Animation length in seconds.
+     */
+    get length(): number;
+    /**
+     * @param name - The AnimationClip's name
+     */
+    constructor(name: string);
+    /**
+     * Adds an animation event to the clip.
+     * @param functionName - The name of the method called in the script
+     * @param time - The time when the event be triggered
+     * @param parameter - The parameter that is stored in the event and will be sent to the function
+     */
+    addEvent(functionName: string, time: number, parameter: Object): void;
+    /**
+     * Adds an animation event to the clip.
+     * @param event - The animation event
+     */
+    addEvent(event: AnimationEvent): void;
+    /**
+     * Clears all events from the clip.
+     */
+    clearEvents(): void;
+    /**
+     * Add curve binding for the clip.
+     * @param relativePath - Path to the game object this curve applies to. The relativePath is formatted similar to a pathname, e.g. "/root/spine/leftArm"
+     * @param type- The class type of the component that is animated
+     * @param propertyName - The name or path to the property being animated
+     * @param curve - The animation curve
+     */
+    addCurveBinding<T extends Component>(relativePath: string, type: new (entity: Entity) => T, propertyName: string, curve: AnimationCurve<KeyframeValueType>): void;
+    /**
+     * Clears all curve bindings from the clip.
+     */
+    clearCurveBindings(): void;
+}

package/types/animation/AnimationClipCurveBinding.d.ts

@@ -0,0 +1,21 @@
+import { Component } from "../Component";
+import { Entity } from "../Entity";
+import { AnimationCurve } from "./animationCurve";
+import { KeyframeValueType } from "./Keyframe";
+/**
+ * Associate AnimationCurve and the Entity
+ */
+export declare class AnimationClipCurveBinding {
+    /**
+     * Path to the entity this curve applies to. The relativePath is formatted similar to a pathname,
+     * e.g. "root/spine/leftArm". If relativePath is empty it refers to the entity the animation clip is attached to.
+     */
+    relativePath: string;
+    /** The class type of the component that is animated. */
+    type: new (entity: Entity) => Component;
+    /** The name or path to the property being animated. */
+    property: string;
+    /** The animation curve. */
+    curve: AnimationCurve<KeyframeValueType>;
+    private _tempCurveOwner;
+}

package/types/animation/AnimationEvent.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AnimationEvent lets you call a script function similar to SendMessage as part of playing back an animation.
+ */
+export declare class AnimationEvent {
+    /** The time when the event be triggered. */
+    time: number;
+    /** The name of the method called in the script. */
+    functionName: string;
+    /** The parameter that is stored in the event and will be sent to the function. */
+    parameter: Object;
+}

package/types/animation/Animator.d.ts

@@ -0,0 +1,86 @@
+import { BoolUpdateFlag } from "../BoolUpdateFlag";
+import { Component } from "../Component";
+import { AnimatorController } from "./AnimatorController";
+import { AnimatorState } from "./AnimatorState";
+import { AnimatorCullingMode } from "./enums/AnimatorCullingMode";
+/**
+ * The controller of the animation system.
+ */
+export declare class Animator extends Component {
+    /** Culling mode of this Animator. */
+    cullingMode: AnimatorCullingMode;
+    /** The playback speed of the Animator, 1.0 is normal playback speed. */
+    speed: number;
+    protected _animatorController: AnimatorController;
+    protected _controllerUpdateFlag: BoolUpdateFlag;
+    private _animatorLayersData;
+    private _crossOwnerCollection;
+    private _animationCurveOwners;
+    private _animationEventHandlerPool;
+    private _tempAnimatorStateInfo;
+    private _controlledRenderers;
+    /**
+     * All layers from the AnimatorController which belongs this Animator.
+     */
+    get animatorController(): AnimatorController;
+    set animatorController(animatorController: AnimatorController);
+    /**
+     * Play a state by name.
+     * @param stateName - The state name
+     * @param layerIndex - The layer index(default -1). If layer is -1, play the first state with the given state name
+     * @param normalizedTimeOffset - The time offset between 0 and 1(default 0)
+     */
+    play(stateName: string, layerIndex?: number, normalizedTimeOffset?: number): void;
+    /**
+     * Create a cross fade from the current state to another state.
+     * @param stateName - The state name
+     * @param normalizedTransitionDuration - The duration of the transition (normalized)
+     * @param layerIndex - The layer index(default -1). If layer is -1, play the first state with the given state name
+     * @param normalizedTimeOffset - The time offset between 0 and 1(default 0)
+     */
+    crossFade(stateName: string, normalizedTransitionDuration: number, layerIndex?: number, normalizedTimeOffset?: number): void;
+    /**
+     * Evaluates the animator component based on deltaTime.
+     * @param deltaTime - The deltaTime when the animation update
+     */
+    update(deltaTime: number): void;
+    /**
+     * Get the playing state from the target layerIndex.
+     * @param layerIndex - The layer index
+     */
+    getCurrentAnimatorState(layerIndex: number): AnimatorState;
+    /**
+     * Get the state by name.
+     * @param stateName - The state name
+     * @param layerIndex - The layer index(default -1). If layer is -1, find the first state with the given state name
+     */
+    findAnimatorState(stateName: string, layerIndex?: number): AnimatorState;
+    private _getAnimatorStateInfo;
+    private _saveDefaultValues;
+    private _getAnimatorStateData;
+    private _saveAnimatorStateData;
+    private _saveAnimatorEventHandlers;
+    private _clearCrossData;
+    private _addCrossCurveData;
+    private _prepareCrossFading;
+    private _prepareStandbyCrossFading;
+    private _prepareFixedPoseCrossFading;
+    private _prepareSrcCrossData;
+    private _prepareDestCrossData;
+    private _getAnimatorLayerData;
+    private _updateLayer;
+    private _updatePlayingState;
+    private _updateCrossFade;
+    private _updateCrossFadeFromPose;
+    private _updateCrossFadeData;
+    private _preparePlay;
+    private _checkTransition;
+    private _crossFadeByTransition;
+    private _fireAnimationEvents;
+    private _fireSubAnimationEvents;
+    private _fireBackwardSubAnimationEvents;
+    private _callAnimatorScriptOnEnter;
+    private _callAnimatorScriptOnUpdate;
+    private _callAnimatorScriptOnExit;
+    private _checkAutoPlay;
+}

package/types/animation/AnimatorController.d.ts

@@ -0,0 +1,32 @@
+import { AnimatorControllerLayer } from "./AnimatorControllerLayer";
+/**
+ * Store the data for Animator playback.
+ */
+export declare class AnimatorController {
+    private _updateFlagManager;
+    private _layers;
+    private _layersMap;
+    /**
+     * The layers in the controller.
+     */
+    get layers(): Readonly<AnimatorControllerLayer[]>;
+    /**
+     * Get the layer by name.
+     * @param name - The layer's name.
+     */
+    findLayerByName(name: string): AnimatorControllerLayer;
+    /**
+     * Add a layer to the controller.
+     * @param layer - The layer to add
+     */
+    addLayer(layer: AnimatorControllerLayer): void;
+    /**
+     * Remove a layer from the controller.
+     * @param layerIndex - The index of the AnimatorLayer
+     */
+    removeLayer(layerIndex: number): void;
+    /**
+     * Clear layers.
+     */
+    clearLayers(): void;
+}

package/types/animation/AnimatorControllerLayer.d.ts

@@ -0,0 +1,18 @@
+import { AnimatorStateMachine } from "./AnimatorStateMachine";
+import { AnimatorLayerBlendingMode } from "./enums/AnimatorLayerBlendingMode";
+/**
+ * The Animation Layer contains a state machine that controls animations of a model or part of it.
+ */
+export declare class AnimatorControllerLayer {
+    readonly name: string;
+    /** The blending weight that the layers has. It is not taken into account for the first layer. */
+    weight: number;
+    /** The blending mode used by the layer. It is not taken into account for the first layer. */
+    blendingMode: AnimatorLayerBlendingMode;
+    /** The state machine for the layer. */
+    stateMachine: AnimatorStateMachine;
+    /**
+     * @param name - The layer's name
+     */
+    constructor(name: string);
+}

package/types/animation/AnimatorState.d.ts

@@ -0,0 +1,60 @@
+import { AnimationClip } from "./AnimationClip";
+import { AnimatorStateTransition } from "./AnimatorTransition";
+import { WrapMode } from "./enums/WrapMode";
+import { StateMachineScript } from "./StateMachineScript";
+/**
+ * States are the basic building blocks of a state machine. Each state contains a AnimationClip which will play while the character is in that state.
+ */
+export declare class AnimatorState {
+    readonly name: string;
+    /** The speed of the clip. 1 is normal speed, default 1. */
+    speed: number;
+    /** The wrap mode used in the state. */
+    wrapMode: WrapMode;
+    private _clipStartTime;
+    private _clipEndTime;
+    private _clip;
+    private _transitions;
+    /**
+     * The transitions that are going out of the state.
+     */
+    get transitions(): Readonly<AnimatorStateTransition[]>;
+    /**
+     * The clip that is being played by this animator state.
+     */
+    get clip(): AnimationClip;
+    set clip(clip: AnimationClip);
+    /**
+     * The start time of the clip, the range is 0 to 1, default is 0.
+     */
+    get clipStartTime(): number;
+    set clipStartTime(time: number);
+    /**
+     * The end time of the clip, the range is 0 to 1, default is 1.
+     */
+    get clipEndTime(): number;
+    set clipEndTime(time: number);
+    /**
+     * @param name - The state's name
+     */
+    constructor(name: string);
+    /**
+     * Add an outgoing transition to the destination state.
+     * @param transition - The transition
+     */
+    addTransition(transition: AnimatorStateTransition): void;
+    /**
+     * Remove a transition from the state.
+     * @param transition - The transition
+     */
+    removeTransition(transition: AnimatorStateTransition): void;
+    /**
+     * Adds a state machine script class of type T to the AnimatorState.
+     * @param scriptType - The state machine script class of type T
+     */
+    addStateMachineScript<T extends StateMachineScript>(scriptType: new () => T): T;
+    /**
+     * Clears all transitions from the state.
+     */
+    clearTransitions(): void;
+}

package/types/animation/AnimatorStateMachine.d.ts

@@ -0,0 +1,37 @@
+import { AnimatorState } from "./AnimatorState";
+export interface AnimatorStateMap {
+    [key: string]: AnimatorState;
+}
+/**
+ * A graph controlling the interaction of states. Each state references a motion.
+ */
+export declare class AnimatorStateMachine {
+    /** The list of states. */
+    readonly states: AnimatorState[];
+    /**
+     * The state will be played automatically.
+     * @remarks When the Animator's AnimatorController changed or the Animator's onEnable be triggered.
+     */
+    defaultState: AnimatorState;
+    /**
+     * Add a state to the state machine.
+     * @param name - The name of the new state
+     */
+    addState(name: string): AnimatorState;
+    /**
+     * Remove a state from the state machine.
+     * @param state - The state
+     */
+    removeState(state: AnimatorState): void;
+    /**
+     * Get the state by name.
+     * @param name - The layer's name
+     */
+    findStateByName(name: string): AnimatorState;
+    /**
+     * Makes a unique state name in the state machine.
+     * @param name - Desired name for the state.
+     * @returns Unique name.
+     */
+    makeUniqueStateName(name: string): string;
+}

package/types/animation/AnimatorTransition.d.ts

@@ -0,0 +1,14 @@
+import { AnimatorState } from "./AnimatorState";
+/**
+ * Transitions define when and how the state machine switch from on state to another. AnimatorTransition always originate from a StateMachine or a StateMachine entry.
+ */
+export declare class AnimatorStateTransition {
+    /** The duration of the transition. This is represented in normalized time. */
+    duration: number;
+    /** The time at which the destination state will start. This is represented in normalized time. */
+    offset: number;
+    /** ExitTime represents the exact time at which the transition can take effect. This is represented in normalized time. */
+    exitTime: number;
+    /** The destination state of the transition. */
+    destinationState: AnimatorState;
+}

package/types/animation/Keyframe.d.ts

@@ -0,0 +1,19 @@
+import { Color, Quaternion, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+/**
+ * Keyframe.
+ * @typeParam V - Type of Keyframe value
+ */
+export declare class Keyframe<V extends KeyframeValueType, T = V extends number ? number : V extends Vector2 ? Vector2 : V extends Vector3 ? Vector3 : V extends Vector4 | Color | Quaternion ? Vector4 : V extends number[] | Float32Array ? number[] : never> {
+    /** The time of the Keyframe. */
+    time: number;
+    /** The value of the Keyframe. */
+    value: V;
+    /** Sets the incoming tangent for this key. The incoming tangent affects the slope of the curve from the previous key to this key. */
+    inTangent?: T;
+    /** Sets the outgoing tangent for this key. The outgoing tangent affects the slope of the curve from this key to the next key. */
+    outTangent?: T;
+}
+/**
+ * Type of Keyframe value.
+ */
+export type KeyframeValueType = number | Vector2 | Vector3 | Vector4 | number[] | Float32Array | Quaternion | Color | boolean;

package/types/animation/StateMachineScript.d.ts

@@ -0,0 +1,32 @@
+import { Animator } from "../animation/Animator";
+import { AnimatorState } from "../animation/AnimatorState";
+/**
+ * StateMachineScript is a component that can be added to a animator state. It's the base class every script on a state derives from.
+ */
+export declare class StateMachineScript {
+    /**
+     * onStateEnter is called when a transition starts and the state machine starts to evaluate this state.
+     * @param animator - The animator
+     * @param animatorState - The state be evaluated
+     * @param layerIndex - The index of the layer where the state is located
+     */
+    onStateEnter(animator: Animator, animatorState: AnimatorState, layerIndex: number): void;
+    /**
+     * onStateUpdate is called on each Update frame between onStateEnter and onStateExit callbacks.
+     * @param animator - The animator
+     * @param animatorState - The state be evaluated
+     * @param layerIndex - The index of the layer where the state is located
+     */
+    onStateUpdate(animator: Animator, animatorState: AnimatorState, layerIndex: number): void;
+    /**
+     * onStateExit is called when a transition ends and the state machine finishes evaluating this state.
+     * @param animator - The animator
+     * @param animatorState - The state be evaluated
+     * @param layerIndex - The index of the layer where the state is located
+     */
+    onStateExit(animator: Animator, animatorState: AnimatorState, layerIndex: number): void;
+    /**
+     * Destroy this instance.
+     */
+    destroy(): void;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+import { InterpolationType } from "../enums/InterpolationType";
+import { IEvaluateData } from "../internal/animationCurveOwner/AnimationCurveOwner";
+import { Keyframe, KeyframeValueType } from "../Keyframe";
+/**
+ * Store a collection of Keyframes that can be evaluated over time.
+ */
+export declare abstract class AnimationCurve<V extends KeyframeValueType> {
+    /** All keys defined in the animation curve. */
+    keys: Keyframe<V>[];
+    protected _evaluateData: IEvaluateData<V>;
+    protected _length: number;
+    protected _interpolation: InterpolationType;
+    private _type;
+    /**
+     * The interpolationType of the animation curve.
+     */
+    get interpolation(): InterpolationType;
+    set interpolation(value: InterpolationType);
+    /**
+     * Animation curve length in seconds.
+     */
+    get length(): number;
+    constructor();
+    /**
+     * Add a new key to the curve.
+     * @param key - The keyframe
+     */
+    addKey(key: Keyframe<V>): void;
+    /**
+     * Evaluate the curve at time.
+     * @param time - The time within the curve you want to evaluate
+     */
+    evaluate(time: number): V;
+    /**
+     * Removes a key.
+     * @param index - The index of the key to remove
+     */
+    removeKey(index: number): void;
+}

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

@@ -0,0 +1,12 @@
+import { Keyframe } from "../Keyframe";
+import { AnimationCurve } from "./AnimationCurve";
+/**
+ * Store a collection of Keyframes that can be evaluated over time.
+ */
+export declare class AnimationFloatArrayCurve extends AnimationCurve<Float32Array> {
+    /**
+     * @inheritdoc
+     * @override
+     */
+    addKey(key: Keyframe<Float32Array>): void;
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+export { AnimationArrayCurve } from "./AnimationArrayCurve";
+export { AnimationBoolCurve } from "./AnimationBoolCurve";
+export { AnimationColorCurve } from "./AnimationColorCurve";
+export { AnimationCurve } from "./AnimationCurve";
+export { AnimationFloatArrayCurve } from "./AnimationFloatArrayCurve";
+export { AnimationFloatCurve } from "./AnimationFloatCurve";
+export { AnimationQuaternionCurve } from "./AnimationQuaternionCurve";
+export { AnimationVector2Curve } from "./AnimationVector2Curve";
+export { AnimationVector3Curve } from "./AnimationVector3Curve";
+export { AnimationVector4Curve } from "./AnimationVector4Curve";

package/types/animation/animationCurve/interfaces/IAnimationCurveCalculator.d.ts

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

package/types/animation/enums/AnimatorConditionMode.d.ts

@@ -0,0 +1,8 @@
+export declare enum AnimatorConditionMode {
+    If = 0,
+    IfNot = 1,
+    Greater = 2,
+    Less = 3,
+    Equals = 4,
+    NotEquals = 5
+}

package/types/animation/enums/AnimatorCullingMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Animator culling mode.
+ */
+export declare enum AnimatorCullingMode {
+    /** Disable Culling. */
+    None = 0,
+    /** Completely disabled when renderers are all culled. */
+    Complete = 1
+}

package/types/animation/enums/AnimatorLayerBlendingMode.d.ts

@@ -0,0 +1,4 @@
+export declare enum AnimatorLayerBlendingMode {
+    Override = 0,
+    Additive = 1
+}

package/types/animation/enums/AnimatorStatePlayState.d.ts

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

package/types/animation/enums/InterpolationType.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Animation interpolation method.
+ */
+export declare enum InterpolationType {
+    /** Linear interpolation */
+    Linear = 0,
+    /** Cubic spline interpolation */
+    CubicSpine = 1,
+    /** Stepped interpolation */
+    Step = 2,
+    /** Hermite interpolation */
+    Hermite = 3
+}

package/types/animation/enums/LayerState.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Layer state.
+ */
+export declare enum LayerState {
+    /** Standby state. */
+    Standby = 0,
+    /** Playing state. */
+    Playing = 1,
+    /** CrossFading state. */
+    CrossFading = 2,
+    /** FixedCrossFading state. */
+    FixedCrossFading = 3
+}

package/types/animation/enums/PlayState.d.ts

@@ -0,0 +1,13 @@
+/**
+ * State play state.
+ */
+export declare enum PlayState {
+    /** Playing state. */
+    Playing = 0,
+    /** Crossing state. */
+    Crossing = 1,
+    /** Fading state. */
+    Fading = 2,
+    /** Finished state. */
+    Finished = 3
+}

package/types/animation/enums/WrapMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Animation wrap mode.
+ */
+export declare enum WrapMode {
+    /** Play once */
+    Once = 0,
+    /** Loop play */
+    Loop = 1
+}