@galacean/engine-core 1.6.8 → 1.6.9

package/types/Transform.d.ts

@@ -0,0 +1,304 @@
+import { Matrix, Quaternion, Vector3 } from "@galacean/engine-math";
+import { BoolUpdateFlag } from "./BoolUpdateFlag";
+import { Component } from "./Component";
+/**
+ * Used to implement transformation related functions.
+ */
+export declare class Transform extends Component {
+    private static _tempQuat0;
+    private static _tempVec30;
+    private static _tempVec31;
+    private static _tempVec32;
+    private static _tempMat30;
+    private static _tempMat31;
+    private static _tempMat32;
+    private static _tempMat41;
+    private static _tempMat42;
+    private _position;
+    private _rotation;
+    private _rotationQuaternion;
+    private _scale;
+    private _localUniformScaling;
+    private _worldPosition;
+    private _worldRotation;
+    private _worldRotationQuaternion;
+    private _worldUniformScaling;
+    private _lossyWorldScale;
+    private _localMatrix;
+    private _worldMatrix;
+    private _worldForward;
+    private _worldRight;
+    private _worldUp;
+    protected _isParentDirty: boolean;
+    private _parentTransformCache;
+    private _dirtyFlag;
+    /**
+     * Local position.
+     */
+    get position(): Vector3;
+    set position(value: Vector3);
+    /**
+     * World position.
+     */
+    get worldPosition(): Vector3;
+    set worldPosition(value: Vector3);
+    /**
+     * Local rotation, defining the rotation value in degrees.
+     * Rotations are performed around the Y axis, the X axis, and the Z axis, in that order.
+     */
+    get rotation(): Vector3;
+    set rotation(value: Vector3);
+    /**
+     * World rotation, defining the rotation value in degrees.
+     * Rotations are performed around the Y axis, the X axis, and the Z axis, in that order.
+     */
+    get worldRotation(): Vector3;
+    set worldRotation(value: Vector3);
+    /**
+     * Local rotation, defining the rotation by using a unit quaternion.
+     */
+    get rotationQuaternion(): Quaternion;
+    set rotationQuaternion(value: Quaternion);
+    /**
+     * World rotation, defining the rotation by using a unit quaternion.
+     */
+    get worldRotationQuaternion(): Quaternion;
+    set worldRotationQuaternion(value: Quaternion);
+    /**
+     * Local scaling.
+     */
+    get scale(): Vector3;
+    set scale(value: Vector3);
+    /**
+     * Local lossy scaling.
+     * @remarks The value obtained may not be correct under certain conditions(for example, the parent node has non-uniform world scaling,
+     * and the child node has a rotation), the scaling will be tilted.
+     */
+    get lossyWorldScale(): Vector3;
+    /**
+     * Local matrix.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get localMatrix(): Matrix;
+    set localMatrix(value: Matrix);
+    /**
+     * World matrix.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get worldMatrix(): Matrix;
+    set worldMatrix(value: Matrix);
+    /**
+     * Set local position by X, Y, Z value.
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @param z - Z coordinate
+     */
+    setPosition(x: number, y: number, z: number): void;
+    /**
+     * Set local rotation by the X, Y, Z components of the euler angle, unit in degrees.
+     * Rotations are performed around the Y axis, the X axis, and the Z axis, in that order.
+     * @param x - The angle of rotation around the X axis
+     * @param y - The angle of rotation around the Y axis
+     * @param z - The angle of rotation around the Z axis
+     */
+    setRotation(x: number, y: number, z: number): void;
+    /**
+     * Set local rotation by the X, Y, Z, and W components of the quaternion.
+     * @param x - X component of quaternion
+     * @param y - Y component of quaternion
+     * @param z - Z component of quaternion
+     * @param w - W component of quaternion
+     */
+    setRotationQuaternion(x: number, y: number, z: number, w: number): void;
+    /**
+     * Set local scaling by scaling values along X, Y, Z axis.
+     * @param x - Scaling along X axis
+     * @param y - Scaling along Y axis
+     * @param z - Scaling along Z axis
+     */
+    setScale(x: number, y: number, z: number): void;
+    /**
+     * Set world position by X, Y, Z value.
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @param z - Z coordinate
+     */
+    setWorldPosition(x: number, y: number, z: number): void;
+    /**
+     * Set world rotation by the X, Y, Z components of the euler angle, unit in degrees, Yaw/Pitch/Roll sequence.
+     * @param x - The angle of rotation around the X axis
+     * @param y - The angle of rotation around the Y axis
+     * @param z - The angle of rotation around the Z axis
+     */
+    setWorldRotation(x: number, y: number, z: number): void;
+    /**
+     * Set local rotation by the X, Y, Z, and W components of the quaternion.
+     * @param x - X component of quaternion
+     * @param y - Y component of quaternion
+     * @param z - Z component of quaternion
+     * @param w - W component of quaternion
+     */
+    setWorldRotationQuaternion(x: number, y: number, z: number, w: number): void;
+    /**
+     * The forward direction in world space.
+     */
+    get worldForward(): Vector3;
+    /**
+     * The right direction in world space.
+     */
+    get worldRight(): Vector3;
+    /**
+     * The up direction in world space.
+     */
+    get worldUp(): Vector3;
+    /**
+     * Translate in the direction and distance of the translation.
+     * @param translation - Direction and distance of translation
+     * @param relativeToLocal = `true` - Is relative to the local coordinate system
+     */
+    translate(translation: Vector3, relativeToLocal?: boolean): void;
+    /**
+     * Translate some distance by x along the x axis, y along the y axis, and z along the z axis.
+     * @param x - Distance along the x axis
+     * @param y - Distance along the y axis
+     * @param z - Distance along the z axis
+     * @param relativeToLocal = `true` - Is relative to the local coordinate system
+     */
+    translate(x: number, y: number, z: number, relativeToLocal?: boolean): void;
+    /**
+     * Rotate around the passed Vector3.
+     * @param rotation - Euler angle in degrees
+     * @param relativeToLocal = `true` - Is relative to the local coordinate system
+     */
+    rotate(rotation: Vector3, relativeToLocal?: boolean): void;
+    /**
+     * Rotate around the passed Vector3.
+     * @param x - Rotation along x axis, in degrees
+     * @param y - Rotation along y axis, in degrees
+     * @param z - Rotation along z axis, in degrees
+     * @param relativeToLocal = `true` - Is relative to the local coordinate system
+     */
+    rotate(x: number, y: number, z: number, relativeToLocal?: boolean): void;
+    /**
+     * Rotate around the specified axis according to the specified angle.
+     * @param axis - Rotate axis
+     * @param angle - Rotate angle in degrees
+     * @param relativeToLocal = `true` - Relative to local space
+     */
+    rotateByAxis(axis: Vector3, angle: number, relativeToLocal?: boolean): void;
+    /**
+     * Rotate and ensure that the world front vector points to the target world position.
+     * @param targetPosition - Target world position
+     * @param worldUp - Up direction in world space, default is Vector3(0, 1, 0)
+     */
+    lookAt(targetPosition: Vector3, worldUp?: Vector3): void;
+    protected _onLocalMatrixChanging(): void;
+    protected _onWorldMatrixChanging(): void;
+    protected _isContainDirtyFlags(targetDirtyFlags: number): boolean;
+    protected _isContainDirtyFlag(type: number): boolean;
+    protected _setDirtyFlagTrue(type: number): void;
+    protected _setDirtyFlagFalse(type: number): void;
+    protected _worldAssociatedChange(type: number): void;
+    protected _getParentTransform(): Transform | null;
+    protected _onPositionChanged(): void;
+    protected _onWorldPositionChanged(): void;
+    /**
+     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
+     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
+     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
+     */
+    private _updateWorldPositionFlag;
+    /**
+     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
+     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
+     * Get worldRotationQuaternion: Will trigger the world rotation (in quaternion) update of itself and all parent entities.
+     * Get worldRotation: Will trigger the world rotation(in euler and quaternion) update of itself and world rotation(in quaternion) update of all parent entities.
+     * Get worldScale: Will trigger the scaling update of itself and all parent entities.
+     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
+     */
+    private _updateWorldRotationFlag;
+    /**
+     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
+     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
+     * Get worldRotationQuaternion: Will trigger the world rotation (in quaternion) update of itself and all parent entities.
+     * Get worldRotation: Will trigger the world rotation(in euler and quaternion) update of itself and world rotation(in quaternion) update of all parent entities.
+     * Get worldScale: Will trigger the scaling update of itself and all parent entities.
+     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
+     * @param flags - Dirty flag
+     */
+    private _updateWorldPositionAndRotationFlag;
+    /**
+     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
+     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
+     * Get worldScale: Will trigger the scaling update of itself and all parent entities.
+     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix) to be false.
+     * @param flags - Dirty flag
+     */
+    private _updateWorldScaleFlag;
+    /**
+     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
+     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
+     * Get worldScale: Will trigger the scaling update of itself and all parent entities.
+     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix) to be false.
+     * @param flags - Dirty flag
+     */
+    private _updateWorldPositionAndScaleFlag;
+    /**
+     * Update all world transform property dirty flag, the principle is the same as above.
+     * @param flags - Dirty flag
+     */
+    private _updateAllWorldFlag;
+    private _getScaleMatrix;
+    private _rotateByQuat;
+    private _translate;
+    private _rotateXYZ;
+    private _onRotationChanged;
+    private _onWorldRotationChanged;
+    private _onRotationQuaternionChanged;
+    private _onWorldRotationQuaternionChanged;
+    private _onScaleChanged;
+    private _getWorldUniformScaling;
+    /**
+     * @deprecated
+     * Listen for changes in the world pose of this `Entity`.
+     * @returns Change flag
+     */
+    registerWorldChangeFlag(): BoolUpdateFlag;
+}
+/**
+ * Dirty flag of transform.
+ */
+export declare enum TransformModifyFlags {
+    LocalEuler = 1,
+    LocalQuat = 2,
+    WorldPosition = 4,
+    WorldEuler = 8,
+    WorldQuat = 16,
+    WorldScale = 32,
+    LocalMatrix = 64,
+    WorldMatrix = 128,
+    /** This is an internal flag used to assist in determining the dispatch
+     *  of world scaling dirty flags in the case of non-uniform scaling.
+     */
+    IsWorldUniformScaling = 256,
+    /** WorldMatrix | WorldPosition */
+    WmWp = 132,
+    /** WorldMatrix | WorldEuler | WorldQuat */
+    WmWeWq = 152,
+    /** WorldMatrix | WorldEuler | WorldQuat | WorldScale*/
+    WmWeWqWs = 184,
+    /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat */
+    WmWpWeWq = 156,
+    /** WorldMatrix | WorldScale */
+    WmWs = 160,
+    /** WorldMatrix | WorldScale | WorldUniformScaling */
+    WmWsWus = 416,
+    /** WorldMatrix | WorldPosition | WorldScale */
+    WmWpWs = 164,
+    /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale */
+    WmWpWeWqWs = 188,
+    /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling */
+    WmWpWeWqWsWus = 444,
+    /** LocalQuat | LocalMatrix | WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling */
+    LqLmWmWpWeWqWsWus = 510
+}

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,37 @@
+export declare class Utils {
+    /**
+     * Fast remove an element from array.
+     * @param array - Array
+     * @param item - Element
+     */
+    static removeFromArray(array: any[], item: any): boolean;
+    /**
+     * Decodes a given Uint8Array into a string.
+     */
+    static decodeText(array: Uint8Array): string;
+    /**
+     * Judge whether the url is absolute url.
+     * @param url - The url to be judged.
+     * @returns Whether the url is absolute url.
+     */
+    static isAbsoluteUrl(url: string): boolean;
+    /**
+     * Judge whether the url is base64 url.
+     * @param url - The url to be judged.
+     * @returns Whether the url is base64 url.
+     */
+    static isBase64Url(url: string): boolean;
+    /**
+     * Get the values of an object.
+     */
+    static objectValues(obj: any): any[];
+    /**
+     * Convert a relative URL to an absolute URL based on a given base URL.
+     * @param baseUrl - The base url.
+     * @param relativeUrl - The relative url.
+     * @returns The resolved url.
+     */
+    static resolveAbsoluteUrl(baseUrl: string, relativeUrl: string): string;
+    private static _stringToPath;
+    private static _insertionSort;
+}

package/types/VirtualCamera.d.ts

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

package/types/animation/AnimationClip.d.ts

@@ -0,0 +1,87 @@
+import { EngineObject } from "../base/EngineObject";
+import { Component } from "../Component";
+import { ComponentConstructor } 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 extends EngineObject {
+    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 entityPath - Path to the game object this curve applies to. The entityPath is formatted similar to a pathname, e.g. "/root/spine/leftArm"
+     * @param componentType - The class type of the component that is animated
+     * @param propertyPath - The path to the property being animated, support "a.b" and "a.b[x]" description mode
+     * @param curve - The animation curve
+     */
+    addCurveBinding<T extends Component>(entityPath: string, componentType: ComponentConstructor<T>, propertyPath: string, curve: AnimationCurve<KeyframeValueType>): void;
+    /**
+     * Add curve binding for the clip.
+     * @param entityPath - Path to the game object this curve applies to. The entityPath is formatted similar to a pathname, e.g. "/root/spine/leftArm"
+     * @param componentType - The class type of the component that is animated
+     * @param setPropertyPath - The path to set the property being animated, support "a.b", "a.b[x]" and "a.b('c', 0, $value)" description mode
+     * @param getPropertyPath - The path to get the value when being animated, support "a.b", "a.b[x]" and "a.b('c', 0, $value)" description mode
+     * @param curve - The animation curve
+     */
+    addCurveBinding<T extends Component>(entityPath: string, componentType: ComponentConstructor<T>, setPropertyPath: string, getPropertyPath: string, curve: AnimationCurve<KeyframeValueType>): void;
+    /**
+     * Add curve binding for the clip.
+     * @param entityPath - Path to the game object this curve applies to. The entityPath is formatted similar to a pathname, e.g. "/root/spine/leftArm"
+     * @param componentType - The type index of the component that is animated
+     * @param componentIndex - The class type of the component that is animated
+     * @param propertyPath - The path to the property being animated, support "a.b" and "a.b[x]" description mode
+     * @param curve - The animation curve
+     */
+    addCurveBinding<T extends Component>(entityPath: string, componentType: ComponentConstructor<T>, componentIndex: number, propertyPath: string, curve: AnimationCurve<KeyframeValueType>): void;
+    /**
+     * Add curve binding for the clip.
+     * @param entityPath - Path to the game object this curve applies to. The entityPath is formatted similar to a pathname, e.g. "/root/spine/leftArm"
+     * @param componentType - The class type of the component that is animated
+     * @param componentIndex - The class type of the component that is animated
+     * @param setPropertyPath - The path to set the property being animated, support "a.b", "a.b[x]" and "a.b('c', 0, $value)" description mode
+     * @param getPropertyPath - The path to get the value when being animated, support "a.b", "a.b[x]" and "a.b('c', 0, $value)" description mode
+     * @param curve - The animation curve
+     */
+    addCurveBinding<T extends Component>(entityPath: string, componentType: ComponentConstructor<T>, componentIndex: number, setPropertyPath: string, getPropertyPath: string, curve: AnimationCurve<KeyframeValueType>): void;
+    /**
+     * Clears all curve bindings from the clip.
+     */
+    clearCurveBindings(): void;
+}

package/types/animation/AnimationClipCurveBinding.d.ts

@@ -0,0 +1,30 @@
+import { ComponentConstructor } from "../Entity";
+import { KeyframeValueType } from "./Keyframe";
+import { AnimationCurve } from "./animationCurve";
+/**
+ * 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: ComponentConstructor;
+    /** The index of the component that is animated. */
+    typeIndex: number;
+    /**
+     * The name or path to the property being animated.
+     * @remarks support property:"a.b", array: "a.b[0]", method: "a.b('c', 0, $value)"
+     */
+    property: string;
+    /**
+     * The name or path to get the value when being animated.
+     * @remarks support property:"a.b", array: "a.b[0]", method: "a.b('c', 0)"
+     */
+    getProperty?: 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,154 @@
+import { BoolUpdateFlag } from "../BoolUpdateFlag";
+import { Component } from "../Component";
+import { AnimatorController } from "./AnimatorController";
+import { AnimatorControllerLayer } from "./AnimatorControllerLayer";
+import { AnimatorControllerParameter, AnimatorControllerParameterValue } from "./AnimatorControllerParameter";
+import { AnimatorState } from "./AnimatorState";
+import { AnimatorCullingMode } from "./enums/AnimatorCullingMode";
+/**
+ * The controller of the animation system.
+ */
+export declare class Animator extends Component {
+    private static _passedTriggerParameterNames;
+    /** 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;
+    protected _updateMark: number;
+    private _animatorLayersData;
+    private _curveOwnerPool;
+    private _animationEventHandlerPool;
+    private _parametersValueMap;
+    private _tempAnimatorStateInfo;
+    private _controlledRenderers;
+    /**
+     * All layers from the AnimatorController which belongs this Animator.
+     */
+    get animatorController(): AnimatorController;
+    set animatorController(animatorController: AnimatorController);
+    /**
+     * The layers in the animator's controller.
+     */
+    get layers(): Readonly<AnimatorControllerLayer[]>;
+    /**
+     * The parameters in the animator's controller.
+     */
+    get parameters(): Readonly<AnimatorControllerParameter[]>;
+    /**
+     * 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 normalized time offset (between 0 and 1, default 0) to start the state's animation from
+     */
+    play(stateName: string, layerIndex?: number, normalizedTimeOffset?: number): void;
+    /**
+     * Create a cross fade from the current state to another state with a normalized duration.
+     * @param stateName - The state name
+     * @param normalizedDuration - The normalized duration of the transition, relative to the destination state's duration (range: 0 to 1)
+     * @param layerIndex - The layer index(default -1). If layer is -1, play the first state with the given state name
+     * @param normalizedTimeOffset - The normalized time offset (between 0 and 1, default 0) to start the destination state's animation from
+     */
+    crossFade(stateName: string, normalizedDuration: number, layerIndex?: number, normalizedTimeOffset?: number): void;
+    /**
+     * Create a cross fade from the current state to another state with a fixed duration.
+     * @param stateName - The state name
+     * @param fixedDuration - The duration of the transition in seconds
+     * @param layerIndex - The layer index(default -1). If layer is -1, play the first state with the given state name
+     * @param normalizedTimeOffset - The normalized time offset (between 0 and 1, default 0) to start the destination state's animation from
+     */
+    crossFadeInFixedDuration(stateName: string, fixedDuration: 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;
+    /**
+     * Get the layer by name.
+     * @param name - The layer's name.
+     */
+    findLayerByName(name: string): AnimatorControllerLayer;
+    /**
+     * Get the parameter by name from animatorController.
+     * @param name - The name of the parameter
+     */
+    getParameter(name: string): AnimatorControllerParameter;
+    /**
+     * Get the value of the given parameter.
+     * @param name - The name of the parameter
+     * @param value - The value of the parameter
+     */
+    getParameterValue(name: string): AnimatorControllerParameterValue;
+    /**
+     * Set the value of the given parameter.
+     * @param name - The name of the parameter
+     * @param value - The value of the parameter
+     */
+    setParameterValue(name: string, value: AnimatorControllerParameterValue): void;
+    /**
+     * Activate the trigger parameter by name.
+     * @param name - The name of the trigger parameter
+     */
+    activateTriggerParameter(name: string): void;
+    /**
+     * Reset the trigger parameter to deactivate it by name.
+     * @param name - The name of the trigger parameter
+     */
+    deactivateTriggerParameter(name: string): void;
+    protected _onDestroy(): void;
+    private _crossFade;
+    private _getAnimatorStateInfo;
+    private _getAnimatorStateData;
+    private _saveAnimatorStateData;
+    private _saveAnimatorEventHandlers;
+    private _clearCrossData;
+    private _addCrossOwner;
+    private _prepareCrossFading;
+    private _prepareStandbyCrossFading;
+    private _prepareFixedPoseCrossFading;
+    private _prepareSrcCrossData;
+    private _prepareDestCrossData;
+    private _getAnimatorLayerData;
+    private _updateState;
+    private _updatePlayingState;
+    private _evaluatePlayingState;
+    private _updateCrossFadeState;
+    private _evaluateCrossFadeState;
+    private _updateCrossFadeFromPoseState;
+    private _evaluateCrossFadeFromPoseState;
+    private _updateFinishedState;
+    private _evaluateFinishedState;
+    private _updateCrossFadeData;
+    private _preparePlayOwner;
+    private _applyStateTransitions;
+    private _checkNoExitTimeTransition;
+    private _checkSubTransition;
+    private _checkBackwardsSubTransition;
+    private _applyTransitionsByCondition;
+    private _preparePlay;
+    private _applyTransition;
+    private _checkConditions;
+    private _prepareCrossFadeByTransition;
+    private _fireAnimationEvents;
+    private _fireSubAnimationEvents;
+    private _fireBackwardSubAnimationEvents;
+    private _callAnimatorScriptOnEnter;
+    private _callAnimatorScriptOnUpdate;
+    private _callAnimatorScriptOnExit;
+    private _checkAnyAndEntryState;
+    private _checkRevertOwner;
+    private _fireAnimationEventsAndCallScripts;
+    private _deactivateTriggeredParameters;
+}

package/types/animation/AnimatorCondition.d.ts

@@ -0,0 +1,13 @@
+import { AnimatorControllerParameterValue } from "./AnimatorControllerParameter";
+import { AnimatorConditionMode } from "./enums/AnimatorConditionMode";
+/**
+ * Condition that is used to determine if a transition must be taken.
+ */
+export declare class AnimatorCondition {
+    /** The mode of the condition. */
+    mode: AnimatorConditionMode;
+    /** The name of the parameter used in the condition. */
+    parameterName: string;
+    /** The AnimatorParameter's threshold value for the condition to be true. */
+    threshold?: AnimatorControllerParameterValue;
+}