@galacean/engine-core 2.0.0-alpha.43 → 2.0.0-alpha.45

package/types/Utils.d.ts

@@ -1,3 +1,4 @@
+import { Matrix } from "@galacean/engine-math";
 export declare class Utils {
     /**
      * Fast remove an element from array.
@@ -32,6 +33,25 @@ export declare class Utils {
      * @returns The resolved url.
      */
     static resolveAbsoluteUrl(baseUrl: string, relativeUrl: string): string;
+    /**
+     * @internal
+     */
+    static _floatMatrixMultiply(left: Matrix, re: Float32Array, rOffset: number, oe: Float32Array, offset: number): void;
+    /**
+     * @internal
+     * Simplify lodash get: https://github.com/lodash/lodash/blob/master/get.js.
+     * @param target - The object to query.
+     * @param path - The path of the property to get.
+     * @returns Returns the resolved value.
+     */
+    static _reflectGet(target: object, path: string): object;
+    /**
+     * @internal
+     * @remarks
+     * Modified based on v8.
+     * https://github.com/v8/v8/blob/7.2-lkgr/src/js/array.js
+     */
+    static _quickSort<T>(a: T[], from: number, to: number, compareFunc: Function): void;
     private static _stringToPath;
     private static _insertionSort;
     private static _encodePathComponents;

package/types/VirtualCamera.d.ts

@@ -1 +1,16 @@
-export {};
+import { DataObject } from "./base/DataObject";
+import { Matrix, Vector3 } from "@galacean/engine-math";
+/**
+ * @internal
+ */
+export declare class VirtualCamera extends DataObject {
+    isOrthographic: boolean;
+    nearClipPlane: number;
+    farClipPlane: number;
+    position: Vector3;
+    viewMatrix: Matrix;
+    projectionMatrix: Matrix;
+    viewProjectionMatrix: Matrix;
+    /** Only orth mode use. */
+    forward: Vector3;
+}

package/types/animation/AnimationClip.d.ts

@@ -1,6 +1,7 @@
 import { EngineObject } from "../base/EngineObject";
 import { Component } from "../Component";
 import { ComponentConstructor, Entity } from "../Entity";
+import { UpdateFlagManager } from "../UpdateFlagManager";
 import { AnimationClipCurveBinding } from "./AnimationClipCurveBinding";
 import { AnimationCurve } from "./animationCurve/AnimationCurve";
 import { AnimationEvent } from "./AnimationEvent";
@@ -10,6 +11,10 @@ import { KeyframeValueType } from "./Keyframe";
  */
 export declare class AnimationClip extends EngineObject {
     readonly name: string;
+    /** @internal */
+    _curveBindings: AnimationClipCurveBinding[];
+    /** @internal */
+    _updateFlagManager: UpdateFlagManager;
     private _length;
     private _events;
     /**

package/types/animation/AnimationClipCurveBinding.d.ts

@@ -1,6 +1,9 @@
-import { ComponentConstructor } from "../Entity";
+import { Component } from "../Component";
+import { ComponentConstructor, Entity } from "../Entity";
 import { KeyframeValueType } from "./Keyframe";
 import { AnimationCurve } from "./animationCurve";
+import { AnimationCurveLayerOwner } from "./internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "./internal/animationCurveOwner/AnimationCurveOwner";
 /**
  * Associate AnimationCurve and the Entity
  */
@@ -27,4 +30,16 @@ export declare class AnimationClipCurveBinding {
     /** The animation curve. */
     curve: AnimationCurve<KeyframeValueType>;
     private _tempCurveOwner;
+    /**
+     * @internal
+     */
+    _createCurveOwner(entity: Entity, component: Component): AnimationCurveOwner<KeyframeValueType>;
+    /**
+     * @internal
+     */
+    _createCurveLayerOwner(owner: AnimationCurveOwner<KeyframeValueType>): AnimationCurveLayerOwner;
+    /**
+     * @internal
+     */
+    _getTempCurveOwner(entity: Entity, component: Component): AnimationCurveOwner<KeyframeValueType>;
 }

package/types/animation/Animator.d.ts

@@ -1,5 +1,6 @@
 import { BoolUpdateFlag } from "../BoolUpdateFlag";
 import { Component } from "../Component";
+import { Entity } from "../Entity";
 import type { ICloneHook } from "../clone/ICloneHook";
 import { AnimatorController } from "./AnimatorController";
 import { AnimatorControllerLayer } from "./AnimatorControllerLayer";
@@ -18,6 +19,10 @@ export declare class Animator extends Component implements ICloneHook<Animator>
     speed: number;
     /** Whether the Animator sends AnimationEvent callbacks. */
     fireEvents: boolean;
+    /** @internal */
+    _playFrameCount: number;
+    /** @internal */
+    _onUpdateIndex: number;
     protected _animatorController: AnimatorController;
     protected _controllerUpdateFlag: BoolUpdateFlag;
     protected _updateMark: number;
@@ -39,6 +44,10 @@ export declare class Animator extends Component implements ICloneHook<Animator>
      * The parameters in the animator's controller.
      */
     get parameters(): Readonly<AnimatorControllerParameter[]>;
+    /**
+     * @internal
+     */
+    constructor(entity: Entity);
     /**
      * Play a state by name.
      * @param stateName - The state name
@@ -115,6 +124,22 @@ export declare class Animator extends Component implements ICloneHook<Animator>
      * @param name - The name of the trigger parameter
      */
     deactivateTriggerParameter(name: string): void;
+    /**
+     * @internal
+     */
+    _onEnable(): void;
+    /**
+     * @internal
+     */
+    _onEnableInScene(): void;
+    /**
+     * @internal
+     */
+    _onDisableInScene(): void;
+    /**
+     * @internal
+     */
+    _reset(): void;
     private _resetIfControllerUpdated;
     /**
      * @inheritdoc

package/types/animation/AnimatorController.d.ts

@@ -1,3 +1,4 @@
+import { BoolUpdateFlag } from "../BoolUpdateFlag";
 import { AnimatorControllerParameter, AnimatorControllerParameterValue } from "./AnimatorControllerParameter";
 import { AnimatorControllerLayer } from "./AnimatorControllerLayer";
 import { ReferResource } from "../asset/ReferResource";
@@ -6,6 +7,14 @@ import { Engine } from "../Engine";
  * Store the data for Animator playback.
  */
 export declare class AnimatorController extends ReferResource {
+    /** @internal */
+    _parameters: AnimatorControllerParameter[];
+    /** @internal */
+    _parametersMap: Record<string, AnimatorControllerParameter>;
+    /** @internal */
+    _layers: AnimatorControllerLayer[];
+    /** @internal */
+    _layersMap: Record<string, AnimatorControllerLayer>;
     private _updateFlagManager;
     private _onStatesInvalidate;
     /**
@@ -69,5 +78,13 @@ export declare class AnimatorController extends ReferResource {
      * Clear layers.
      */
     clearLayers(): void;
+    /**
+     * @internal
+     */
+    _registerChangeFlag(): BoolUpdateFlag;
+    /**
+     * @internal
+     */
+    _setEngine(engine: Engine): void;
     private _addParameter;
 }

package/types/animation/AnimatorControllerLayer.d.ts

@@ -1,3 +1,4 @@
+import { Engine } from "../Engine";
 import { AnimatorStateMachine } from "./AnimatorStateMachine";
 import { AnimatorLayerBlendingMode } from "./enums/AnimatorLayerBlendingMode";
 import { AnimatorLayerMask } from "./AnimatorLayerMask";
@@ -24,4 +25,12 @@ export declare class AnimatorControllerLayer {
      * @param name - The layer's name
      */
     constructor(name: string);
+    /**
+     * @internal
+     */
+    _setEngine(engine: Engine): void;
+    /**
+     * @internal
+     */
+    _setStatesInvalidateCallback(onStatesInvalidate: (() => void) | null): void;
 }

package/types/animation/AnimatorControllerParameter.d.ts

@@ -5,6 +5,10 @@ export type AnimatorControllerParameterValue = number | string | boolean;
 export declare class AnimatorControllerParameter {
     /** The default value of the parameter. */
     defaultValue: AnimatorControllerParameterValue;
+    /** @internal */
+    _onNameChanged: (oldName: string, newName: string) => void;
+    /** @internal */
+    _isTrigger: boolean;
     private _name;
     /**
      * The name of the parameter.

package/types/animation/AnimatorState.d.ts

@@ -1,5 +1,9 @@
+import { Engine } from "../Engine";
+import { UpdateFlagManager } from "../UpdateFlagManager";
 import { AnimationClip } from "./AnimationClip";
+import type { Animator } from "./Animator";
 import { AnimatorStateTransition } from "./AnimatorStateTransition";
+import { AnimatorStateTransitionCollection } from "./AnimatorStateTransitionCollection";
 import { WrapMode } from "./enums/WrapMode";
 import { StateMachineScript } from "./StateMachineScript";
 /**
@@ -11,6 +15,10 @@ export declare class AnimatorState {
     speed: number;
     /** The wrap mode used in the state. */
     wrapMode: WrapMode;
+    /** @internal */
+    _updateFlagManager: UpdateFlagManager;
+    /** @internal */
+    _transitionCollection: AnimatorStateTransitionCollection;
     private _onStateEnterScripts;
     private _onStateUpdateScripts;
     private _onStateExitScripts;
@@ -70,4 +78,40 @@ export declare class AnimatorState {
      * Clears all transitions from the state.
      */
     clearTransitions(): void;
+    /**
+     * @internal
+     */
+    _callOnEnter(animator: Animator, layerIndex: number): void;
+    /**
+     * @internal
+     */
+    _callOnUpdate(animator: Animator, layerIndex: number): void;
+    /**
+     * @internal
+     */
+    _callOnExit(animator: Animator, layerIndex: number): void;
+    /**
+     * @internal
+     */
+    _getDuration(): number;
+    /**
+     * @internal
+     */
+    _removeStateMachineScript(script: StateMachineScript): void;
+    /**
+     * @internal
+     */
+    _onClipChanged(): void;
+    /**
+     * @internal
+     */
+    _getClipActualStartTime(): number;
+    /**
+     * @internal
+     */
+    _getClipActualEndTime(): number;
+    /**
+     * @internal
+     */
+    _setEngine(engine: Engine): void;
 }

package/types/animation/AnimatorStateInstance.d.ts

@@ -1,4 +1,6 @@
 import { AnimationClip } from "./AnimationClip";
+import { AnimatorState } from "./AnimatorState";
+import { AnimatorStatePlayData } from "./internal/AnimatorStatePlayData";
 import { WrapMode } from "./enums/WrapMode";
 /**
  * Per-Animator view of an `AnimatorState`.
@@ -7,6 +9,10 @@ import { WrapMode } from "./enums/WrapMode";
  * fall through to the underlying state asset.
  */
 export declare class AnimatorStateInstance {
+    /** @internal */
+    readonly _state: AnimatorState;
+    /** @internal */
+    readonly _playData: AnimatorStatePlayData;
     private _speed;
     private _wrapMode;
     /**
@@ -35,4 +41,6 @@ export declare class AnimatorStateInstance {
      */
     get wrapMode(): WrapMode;
     set wrapMode(value: WrapMode);
+    /** @internal */
+    constructor(state: AnimatorState);
 }

package/types/animation/AnimatorStateMachine.d.ts

@@ -1,5 +1,7 @@
+import { Engine } from "../Engine";
 import { AnimatorState } from "./AnimatorState";
 import { AnimatorStateTransition } from "./AnimatorStateTransition";
+import { AnimatorStateTransitionCollection } from "./AnimatorStateTransitionCollection";
 export interface AnimatorStateMap {
     [key: string]: AnimatorState;
 }
@@ -16,6 +18,10 @@ export declare class AnimatorStateMachine {
      * @remarks When the Animator's AnimatorController changed or the Animator's onEnable be triggered. Cleared to `null` if the state is removed via `removeState`.
      */
     defaultState: AnimatorState | null;
+    /** @internal */
+    _entryTransitionCollection: AnimatorStateTransitionCollection;
+    /** @internal */
+    _anyStateTransitionCollection: AnimatorStateTransitionCollection;
     private _statesMap;
     /**
      * The list of entry transitions in the state machine.
@@ -84,4 +90,12 @@ export declare class AnimatorStateMachine {
      * Clear all any state transitions.
      */
     clearAnyStateTransitions(): void;
+    /**
+     * @internal
+     */
+    _setEngine(engine: Engine): void;
+    /**
+     * @internal
+     */
+    _setStatesInvalidateCallback(onStatesInvalidate: (() => void) | null): void;
 }

package/types/animation/AnimatorStateTransition.d.ts

@@ -1,6 +1,7 @@
 import { AnimatorCondition } from "./AnimatorCondition";
 import { AnimatorControllerParameterValue } from "./AnimatorControllerParameter";
 import { AnimatorState } from "./AnimatorState";
+import { AnimatorStateTransitionCollection } from "./AnimatorStateTransitionCollection";
 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.
@@ -18,6 +19,10 @@ export declare class AnimatorStateTransition {
     mute: boolean;
     /** Determines whether the duration of the transition is reported in a fixed duration in seconds or as a normalized time. */
     isFixedDuration: boolean;
+    /** @internal */
+    _collection: AnimatorStateTransitionCollection;
+    /** @internal */
+    _isExit: boolean;
     private _conditions;
     private _solo;
     private _hasExitTime;
@@ -56,4 +61,8 @@ export declare class AnimatorStateTransition {
      * @param condition - The condition to remove
      */
     removeCondition(condition: AnimatorCondition): void;
+    /**
+     * @internal
+     */
+    _getFixedDuration(): number;
 }

package/types/animation/AnimatorStateTransitionCollection.d.ts

@@ -1 +1,23 @@
-export {};
+import { AnimatorState } from "./AnimatorState";
+import { AnimatorStateTransition } from "./AnimatorStateTransition";
+/**
+ * @internal
+ */
+export declare class AnimatorStateTransitionCollection {
+    transitions: AnimatorStateTransition[];
+    noExitTimeCount: number;
+    needResetCurrentCheckIndex: boolean;
+    currentCheckIndex: number;
+    private _soloCount;
+    get isSoloMode(): boolean;
+    get count(): number;
+    get(index: number): AnimatorStateTransition;
+    add(transitionOrAnimatorState: AnimatorStateTransition | AnimatorState): AnimatorStateTransition;
+    remove(transition: AnimatorStateTransition): void;
+    clear(): void;
+    updateTransitionSolo(isModifiedSolo: boolean): void;
+    updateTransitionsIndex(transition: AnimatorStateTransition, newHasExitTime: boolean): void;
+    updateCurrentCheckIndex(isForward: boolean): void;
+    resetCurrentCheckIndex(isForward: boolean): void;
+    private _addTransition;
+}

package/types/animation/StateMachineScript.d.ts

@@ -5,6 +5,8 @@ import { EngineObject } from "../base/EngineObject";
  * 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 extends EngineObject {
+    /** @internal */
+    _state: AnimatorState;
     constructor();
     /**
      * onStateEnter is called when a transition starts and the state machine starts to evaluate this state.

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

@@ -1,7 +1,46 @@
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
+import { Keyframe } from "../Keyframe";
 import { AnimationCurve } from "./AnimationCurve";
 /**
  * Store a collection of Keyframes that can be evaluated over time.
  */
 export declare class AnimationArrayCurve extends AnimationCurve<number[]> {
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<number[]>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _lerpValue(srcValue: number[], destValue: number[], weight: number, out: number[]): number[];
+    /**
+     * @internal
+     */
+    static _subtractValue(src: number[], base: number[], out: number[]): number[];
+    /**
+     * @internal
+     */
+    static _getZeroValue(out: number[]): number[];
+    /**
+     * @internal
+     */
+    static _additiveValue(value: number[], weight: number, out: number[]): number[];
+    /**
+     * @internal
+     */
+    static _setValue(source: number[], out: number[]): number[];
+    /**
+     * @internal
+     */
+    static _hermiteInterpolationValue(frame: Keyframe<number[]>, nextFrame: Keyframe<number[]>, t: number, duration: number, out: number[]): number[];
     constructor();
 }

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

@@ -1,7 +1,46 @@
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
+import { Keyframe } from "../Keyframe";
 import { AnimationCurve } from "./AnimationCurve";
 /**
  * Store a collection of Keyframes that can be evaluated over time.
  */
 export declare class AnimationBoolCurve extends AnimationCurve<boolean> {
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<boolean>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _lerpValue(srcValue: boolean, destValue: boolean): boolean;
+    /**
+     * @internal
+     */
+    static _subtractValue(src: boolean, base: boolean, out: boolean): boolean;
+    /**
+     * @internal
+     */
+    static _getZeroValue(): boolean;
+    /**
+     * @internal
+     */
+    static _additiveValue(value: boolean, weight: number, source: boolean): boolean;
+    /**
+     * @internal
+     */
+    static _setValue(value: boolean): boolean;
+    /**
+     * @internal
+     */
+    static _hermiteInterpolationValue(frame: Keyframe<boolean>): boolean;
     constructor();
 }

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

@@ -1,8 +1,47 @@
 import { Color } from "@galacean/engine-math";
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
+import { Keyframe } from "../Keyframe";
 import { AnimationCurve } from "./AnimationCurve";
 /**
  * Store a collection of Keyframes that can be evaluated over time.
  */
 export declare class AnimationColorCurve extends AnimationCurve<Color> {
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<Color>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _lerpValue(srcValue: Color, destValue: Color, weight: number, out: Color): Color;
+    /**
+     * @internal
+     */
+    static _subtractValue(src: Color, base: Color, out: Color): Color;
+    /**
+     * @internal
+     */
+    static _getZeroValue(out: Color): Color;
+    /**
+     * @internal
+     */
+    static _additiveValue(value: Color, weight: number, out: Color): Color;
+    /**
+     * @internal
+     */
+    static _setValue(source: Color, out: Color): Color;
+    /**
+     * @internal
+     */
+    static _hermiteInterpolationValue(frame: Keyframe<Color>, nextFrame: Keyframe<Color>, t: number, dur: number, out: Color): Color;
     constructor();
 }

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

@@ -36,4 +36,12 @@ export declare abstract class AnimationCurve<V extends KeyframeValueType> {
      * @param index - The index of the key to remove
      */
     removeKey(index: number): void;
+    /**
+     * @internal
+     */
+    _evaluate(time: number, evaluateData: IEvaluateData<V>): V;
+    /**
+     * @internal
+     */
+    _evaluateAdditive(time: number, evaluateData: IEvaluateData<V>): V;
 }

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

@@ -1,9 +1,47 @@
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
 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> {
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<Float32Array>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _lerpValue(srcValue: Float32Array, destValue: Float32Array, weight: number, out: Float32Array): Float32Array;
+    /**
+     * @internal
+     */
+    static _subtractValue(src: Float32Array, base: Float32Array, out: Float32Array): Float32Array;
+    /**
+     * @internal
+     */
+    static _getZeroValue(out: Float32Array): Float32Array;
+    /**
+     * @internal
+     */
+    static _additiveValue(value: Float32Array, weight: number, out: Float32Array): Float32Array;
+    /**
+     * @internal
+     */
+    static _setValue(source: Float32Array, out: Float32Array): Float32Array;
+    /**
+     * @internal
+     */
+    static _hermiteInterpolationValue(frame: Keyframe<Float32Array>, nextFrame: Keyframe<Float32Array>, t: number, dur: number, out: Float32Array): Float32Array;
     /**
      * @inheritdoc
      */

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

@@ -1,7 +1,46 @@
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
+import { Keyframe } from "../Keyframe";
 import { AnimationCurve } from "./AnimationCurve";
 /**
  * Store a collection of Keyframes that can be evaluated over time.
  */
 export declare class AnimationFloatCurve extends AnimationCurve<number> {
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<number>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _lerpValue(srcValue: number, destValue: number, crossWeight: number): number;
+    /**
+     * @internal
+     */
+    static _additiveValue(value: number, weight: number, source: number): number;
+    /**
+     * @internal
+     */
+    static _subtractValue(src: number, base: number): number;
+    /**
+     * @internal
+     */
+    static _getZeroValue(): number;
+    /**
+     * @internal
+     */
+    static _setValue(source: number): number;
+    /**
+     * @internal
+     */
+    static _hermiteInterpolationValue(frame: Keyframe<number>, nextFrame: Keyframe<number>, t: number, dur: number): number;
     constructor();
 }