@galacean/engine-core 1.6.8 → 1.6.9

package/types/animation/AnimatorController.d.ts

@@ -0,0 +1,72 @@
+import { AnimatorControllerParameter, AnimatorControllerParameterValue } from "./AnimatorControllerParameter";
+import { AnimatorControllerLayer } from "./AnimatorControllerLayer";
+import { ReferResource } from "../asset/ReferResource";
+import { Engine } from "../Engine";
+/**
+ * Store the data for Animator playback.
+ */
+export declare class AnimatorController extends ReferResource {
+    private _updateFlagManager;
+    /**
+     * The layers in the controller.
+     */
+    get layers(): Readonly<AnimatorControllerLayer[]>;
+    /**
+     * The parameters in the controller.
+     */
+    get parameters(): Readonly<AnimatorControllerParameter[]>;
+    /**
+     * Create an AnimatorController.
+     * @param engine - Engine to which the animatorController belongs
+     */
+    constructor(engine: Engine);
+    /**
+     * @deprecated
+     */
+    constructor();
+    /**
+     * Add a parameter to the controller.
+     * @param name - The name of the parameter
+     * @param defaultValue - The default value of the parameter
+     */
+    addParameter(name: string, defaultValue?: AnimatorControllerParameterValue): AnimatorControllerParameter;
+    /**
+     * Add a trigger parameter to the controller.
+     * @param name - The name of the parameter
+     */
+    addTriggerParameter(name: string): AnimatorControllerParameter;
+    /**
+     * Remove a parameter from the controller by name, including trigger parameters.
+     * @param name - The name of the parameter
+     */
+    removeParameter(name: string): void;
+    /**
+     * Clear all parameters, including trigger parameters.
+     */
+    clearParameters(): void;
+    /**
+     * Get the parameter by name.
+     * @param name - The name of the parameter
+     */
+    getParameter(name: string): AnimatorControllerParameter;
+    /**
+     * 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;
+    private _addParameter;
+}

package/types/animation/AnimatorControllerLayer.d.ts

@@ -0,0 +1,21 @@
+import { AnimatorStateMachine } from "./AnimatorStateMachine";
+import { AnimatorLayerBlendingMode } from "./enums/AnimatorLayerBlendingMode";
+import { AnimatorLayerMask } from "./AnimatorLayerMask";
+/**
+ * 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;
+    /** The AnimatorLayerMask is used to mask out certain entities from being animated by an AnimatorLayer. */
+    mask: AnimatorLayerMask;
+    /**
+     * @param name - The layer's name
+     */
+    constructor(name: string);
+}

package/types/animation/AnimatorControllerParameter.d.ts

@@ -0,0 +1,14 @@
+export type AnimatorControllerParameterValue = number | string | boolean;
+/**
+ * Used to communicate between scripting and the controller, parameters can be set in scripting and used by the controller.
+ */
+export declare class AnimatorControllerParameter {
+    /** The default value of the parameter. */
+    defaultValue: AnimatorControllerParameterValue;
+    private _name;
+    /**
+     * The name of the parameter.
+     */
+    get name(): string;
+    set name(name: string);
+}

package/types/animation/AnimatorLayerMask.d.ts

@@ -0,0 +1,45 @@
+import { Entity } from "../Entity";
+import { LayerPathMask } from "./LayerPathMask";
+/**
+ * AnimatorLayerMask is used to mask out certain entities from being animated by an AnimatorLayer.
+ */
+export declare class AnimatorLayerMask {
+    /**
+     * Creates an AnimatorLayerMask instance by specifying an entity.
+     * This will automatically add path masks for the entity and all its children.
+     * @param entity - The root entity to create path masks for
+     */
+    static createByEntity(entity: Entity): AnimatorLayerMask;
+    private static _addPathMaskWithChildren;
+    private _pathMasks;
+    private _pathMaskMap;
+    /**
+     * The list of path masks.
+     */
+    get pathMasks(): Readonly<LayerPathMask[]>;
+    /**
+     * Adds a path mask to the AnimatorLayerMask, the root path is "".
+     * @param path - The path to add a mask for
+     * @returns The created or existing LayerPathMask
+     */
+    addPathMask(path: string): LayerPathMask;
+    /**
+     * Removes a path mask from the AnimatorLayerMask.
+     * @param path - The path of the mask to remove
+     */
+    removePathMask(path: string): void;
+    /**
+     * Get a path mask based on the given path.
+     * @param path - The path of the mask to get
+     * @returns The LayerPathMask for the given path
+     */
+    getPathMask(path: string): LayerPathMask;
+    /**
+     * Sets the active state of a path mask.
+     * If recursive is true, it also sets the active state of all child path masks.
+     * @param path - The path of the mask to modify
+     * @param active - The active state to set
+     * @param withChildren - Whether to apply the active state recursively to child paths
+     */
+    setPathMaskActive(path: string, active: boolean, withChildren?: boolean): void;
+}

package/types/animation/AnimatorState.d.ts

@@ -0,0 +1,69 @@
+import { AnimationClip } from "./AnimationClip";
+import { AnimatorStateTransition } from "./AnimatorStateTransition";
+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;
+    /**
+     * 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 normalized start time of the clip, the range is 0 to 1, default is 0.
+     */
+    get clipStartTime(): number;
+    set clipStartTime(time: number);
+    /**
+     * The normalized 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.
+     * @param transition - The transition
+     */
+    addTransition(transition: AnimatorStateTransition): AnimatorStateTransition;
+    /**
+     * Add an outgoing transition to the destination state.
+     * @param animatorState - The destination state
+     */
+    addTransition(animatorState: AnimatorState): AnimatorStateTransition;
+    /**
+     * Add an outgoing transition to exit of the stateMachine.
+     * @param exitTime - The time at which the transition can take effect. This is represented in normalized time.
+     */
+    addExitTransition(exitTime?: number): AnimatorStateTransition;
+    /**
+     * 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,85 @@
+import { AnimatorState } from "./AnimatorState";
+import { AnimatorStateTransition } from "./AnimatorStateTransition";
+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;
+    private _statesMap;
+    /**
+     * The list of entry transitions in the state machine.
+     */
+    get entryTransitions(): Readonly<AnimatorStateTransition[]>;
+    /**
+     * The list of AnyState transitions.
+     */
+    get anyStateTransitions(): Readonly<AnimatorStateTransition[]>;
+    /**
+     * 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;
+    /**
+     * Add an entry transition.
+     * @param transition - The transition
+     */
+    addEntryStateTransition(transition: AnimatorStateTransition): AnimatorStateTransition;
+    /**
+     * Add an entry transition to the destination state, the default value of entry transition's hasExitTime is false.
+     * @param animatorState - The destination state
+     */
+    addEntryStateTransition(animatorState: AnimatorState): AnimatorStateTransition;
+    /**
+     * Remove an entry transition.
+     * @param transition - The transition
+     */
+    removeEntryStateTransition(transition: AnimatorStateTransition): void;
+    /**
+     * Add an any transition.
+     * @param transition - The transition
+     */
+    addAnyStateTransition(transition: AnimatorStateTransition): AnimatorStateTransition;
+    /**
+     * Add an any transition to the destination state, the default value of any transition's hasExitTime is false.
+     * @param animatorState - The destination state
+     */
+    addAnyStateTransition(animatorState: AnimatorState): AnimatorStateTransition;
+    /**
+     * Remove an any transition.
+     * @param transition - The transition
+     */
+    removeAnyStateTransition(transition: AnimatorStateTransition): void;
+    /**
+     * Clear all entry state transitions.
+     */
+    clearEntryStateTransitions(): void;
+    /**
+     * Clear all any state transitions.
+     */
+    clearAnyStateTransitions(): void;
+}

package/types/animation/AnimatorStateTransition.d.ts

@@ -0,0 +1,59 @@
+import { AnimatorCondition } from "./AnimatorCondition";
+import { AnimatorControllerParameterValue } from "./AnimatorControllerParameter";
+import { AnimatorState } from "./AnimatorState";
+import { AnimatorConditionMode } from "./enums/AnimatorConditionMode";
+/**
+ * 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. The duration is in normalized time by default. To set it to be in seconds, set isFixedDuration to true. */
+    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;
+    /** Mutes the transition. The transition will never occur. */
+    mute: boolean;
+    /** Determines whether the duration of the transition is reported in a fixed duration in seconds or as a normalized time. */
+    isFixedDuration: boolean;
+    private _conditions;
+    private _solo;
+    private _hasExitTime;
+    /**
+     * Is the transition destination the exit of the current state machine.
+     */
+    get isExit(): Readonly<boolean>;
+    /**
+     * Mutes all other transitions in the source state.
+     */
+    get solo(): boolean;
+    set solo(value: boolean);
+    /**
+     * The conditions in the transition.
+     */
+    get conditions(): Readonly<AnimatorCondition[]>;
+    /**
+     * When active the transition will have an exit time condition.
+     */
+    get hasExitTime(): boolean;
+    set hasExitTime(value: boolean);
+    /**
+     * Add a condition to a transition.
+     * @param parameterName - The name of the parameter
+     * @param mode - The AnimatorCondition mode of the condition
+     * @param threshold - The threshold value of the condition
+     */
+    addCondition(parameterName: string, mode?: AnimatorConditionMode, threshold?: AnimatorControllerParameterValue): AnimatorCondition;
+    /**
+     * Add a condition to a transition.
+     * @param animatorCondition - The condition to add
+     */
+    addCondition(animatorCondition: AnimatorCondition): AnimatorCondition;
+    /**
+     * Remove a condition from the transition.
+     * @param condition - The condition to remove
+     */
+    removeCondition(condition: AnimatorCondition): void;
+}

package/types/animation/AnimatorStateTransitionCollection.d.ts

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

package/types/animation/Keyframe.d.ts

@@ -0,0 +1,20 @@
+import { Color, Quaternion, Rect, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+import { ReferResource } from "../asset/ReferResource";
+/**
+ * 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 | Rect ? Vector4 : V extends number[] | Float32Array ? number[] : V extends ReferResource ? ReferResource : 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 | Rect | string | boolean | ReferResource;

package/types/animation/LayerPathMask.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LayerPathMask represents a mask for a specific entity in an animation layer.
+ * It is used to control the animation whether to be applied to the entity or not.
+ */
+export declare class LayerPathMask {
+    /**
+     * It identifies a particular entity in the hierarchy.
+     * Example: "arm/left/hand" could be a path to the left hand of a character.
+     */
+    path: string;
+    /**
+     * The active property is indicating whether the animation at this path is active or not.
+     * When true, the animation for this path is applied; when false, the animation for this path is ignored.
+     */
+    active: 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,11 @@
+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
+     */
+    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/AnimationRectCurve.d.ts

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

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

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

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

@@ -0,0 +1,7 @@
+import { AnimationCurve } from "./AnimationCurve";
+/**
+ * Store a collection of Keyframes that can be evaluated over time.
+ */
+export declare class AnimationStringCurve extends AnimationCurve<string> {
+    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,13 @@
+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";
+export { AnimationRefCurve } from "./AnimationRefCurve";
+export { AnimationRectCurve } from "./AnimationRectCurve";
+export { AnimationStringCurve } from "./AnimationStringCurve";

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * The mode of the animator condition.
+ */
+export declare enum AnimatorConditionMode {
+    /** The condition is true when the parameter value is true. */
+    If = 0,
+    /** The condition is true when the parameter value is false. */
+    IfNot = 1,
+    /** The condition is true when the parameter value is greater than the threshold. */
+    Greater = 2,
+    /** The condition is true when the parameter value is less than the threshold. */
+    Less = 3,
+    /** The condition is true when the parameter value is equal to the threshold. */
+    Equals = 4,
+    /** The condition is true when the parameter value is not equal to the threshold. */
+    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 {};