@galacean/effects-core 2.5.1 → 2.6.0-alpha.0

package/dist/math/value-getters/color-curve.d.ts

@@ -9,4 +9,5 @@ export declare class ColorCurve extends ValueGetter<Color> {
     private aCurve;
     onCreate(arg: spec.ColorCurveData): void;
     getValue(t: number): Color;
+    getMaxTime(): number;
 }

package/dist/math/value-getters/vector-curves.d.ts

@@ -1,7 +1,8 @@
 import { Vector2 } from '@galacean/effects-math/es/core/vector2';
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
 import { Vector4 } from '@galacean/effects-math/es/core/vector4';
-import { ValueGetter } from './value-getter';
 import type * as spec from '@galacean/effects-specification';
+import { ValueGetter } from './value-getter';
 export declare class Vector4Curve extends ValueGetter<Vector4> {
     private value;
     private xCurve;
@@ -10,6 +11,16 @@ export declare class Vector4Curve extends ValueGetter<Vector4> {
     private wCurve;
     onCreate(arg: spec.Vector4CurveData): void;
     getValue(t: number): Vector4;
+    getMaxTime(): number;
+}
+export declare class Vector3Curve extends ValueGetter<Vector3> {
+    private value;
+    private xCurve;
+    private yCurve;
+    private zCurve;
+    onCreate(arg: spec.Vector3CurveData): void;
+    getValue(t: number): Vector3;
+    getMaxTime(): number;
 }
 export declare class Vector2Curve extends ValueGetter<Vector2> {
     private value;
@@ -17,4 +28,5 @@ export declare class Vector2Curve extends ValueGetter<Vector2> {
     private yCurve;
     onCreate(arg: spec.Vector2CurveData): void;
     getValue(t: number): Vector2;
+    getMaxTime(): number;
 }

package/dist/plugins/animation-graph/animation-graph-asset.d.ts

@@ -0,0 +1,13 @@
+import type * as spec from '@galacean/effects-specification';
+import { EffectsObject } from '../../effects-object';
+import { GraphDataSet } from './graph-data-set';
+import { type GraphNodeData } from './graph-node';
+export declare class AnimationGraphAsset extends EffectsObject {
+    nodeDatas: GraphNodeData[];
+    graphDataSet: GraphDataSet;
+    controlParameterIDs: string[];
+    parameterLookupMap: Map<string, number>;
+    rootNodeIndex: number;
+    static createNodeData(type: spec.NodeDataType): GraphNodeData;
+    fromData(data: spec.AnimationGraphAssetData): void;
+}

package/dist/plugins/animation-graph/blender.d.ts

@@ -0,0 +1,38 @@
+import type { Color, Vector3 } from '@galacean/effects-math/es/core';
+import { Quaternion } from '@galacean/effects-math/es/core/quaternion';
+import type { Pose } from './pose';
+export declare abstract class BlendFunction {
+    abstract blendVector3(source: Vector3, target: Vector3, weight: number, result: Vector3): void;
+    abstract blendQuaternion(source: Quaternion, target: Quaternion, weight: number, result: Quaternion): void;
+    abstract blendEuler(source: Vector3, target: Vector3, weight: number, result: Vector3): void;
+    abstract blendColor(source: Color, target: Color, weight: number, result: Color): void;
+    abstract blendFloat(source: number, target: number, weight: number): number;
+}
+export declare class NormalBlend extends BlendFunction {
+    blendVector3(source: Vector3, target: Vector3, weight: number, result: Vector3): void;
+    blendQuaternion(source: Quaternion, target: Quaternion, weight: number, result: Quaternion): void;
+    blendEuler(source: Vector3, target: Vector3, weight: number, result: Vector3): void;
+    blendFloat(source: number, target: number, weight: number): number;
+    blendColor(source: Color, target: Color, weight: number, result: Color): void;
+    private lerpEuler;
+    private normalizeAngle;
+    /**
+     * 计算两个角度之间的最短路径差
+     */
+    private shortestAngleDiff;
+    private lerpAngle;
+}
+export declare class AdditiveBlend extends BlendFunction {
+    blendVector3(source: Vector3, target: Vector3, weight: number, result: Vector3): void;
+    blendQuaternion(source: Quaternion, target: Quaternion, weight: number, result: Quaternion): void;
+    blendEuler(source: Vector3, target: Vector3, weight: number, result: Vector3): void;
+    blendFloat(source: number, target: number, weight: number): number;
+    blendColor(source: Color, target: Color, weight: number, result: Color): void;
+}
+export declare class Blender {
+    private static normalBlendFunction;
+    private static additiveBlendFunction;
+    static localBlend(sourcePose: Pose, targetPose: Pose, blendWeight: number, resultPose: Pose): void;
+    static additiveBlend(sourcePose: Pose, targetPose: Pose, blendWeight: number, resultPose: Pose): void;
+    private static localBlendInternal;
+}

package/dist/plugins/animation-graph/graph-context.d.ts

@@ -0,0 +1,20 @@
+import type { GraphDataSet } from './graph-data-set';
+import type { GraphNode, GraphNodeData } from './graph-node';
+import type { Skeleton } from './skeleton';
+export declare enum BranchState {
+    Active = 0,
+    Inactive = 1
+}
+export declare class GraphContext {
+    deltaTime: number;
+    updateID: number;
+    skeleton: Skeleton;
+    branchState: BranchState;
+    update(deltaTime: number): void;
+}
+export declare class InstantiationContext {
+    nodeDatas: GraphNodeData[];
+    nodes: GraphNode[];
+    dataSet: GraphDataSet;
+    getNode<T extends GraphNode>(index: number): T;
+}

package/dist/plugins/animation-graph/graph-data-set.d.ts

@@ -0,0 +1,5 @@
+import type { AnimationClip } from '../cal/calculate-vfx-item';
+export declare class GraphDataSet {
+    resources: AnimationClip[];
+    getResource(index: number): AnimationClip | null;
+}

package/dist/plugins/animation-graph/graph-instance.d.ts

@@ -0,0 +1,30 @@
+import type { VFXItem } from '../../vfx-item';
+import type { AnimationGraphAsset } from './animation-graph-asset';
+import type { GraphNode, PoseNodeDebugInfo } from './graph-node';
+import { PoseResult } from './pose-result';
+import { Skeleton } from './skeleton';
+export declare class GraphInstance {
+    private graphAsset;
+    nodes: GraphNode[];
+    skeleton: Skeleton;
+    private rootNode;
+    private context;
+    private result;
+    constructor(graphAsset: AnimationGraphAsset, rootBone: VFXItem);
+    evaluateGraph(deltaTime: number): PoseResult;
+    isInitialized(): boolean;
+    isNodeActive(nodeIdx: number): boolean;
+    resetGraphState(): void;
+    getNumControlParameters(): number;
+    getControlParameterIndex(parameterID: string): number;
+    getControlParameterID(parameterNodeIndex: number): string;
+    setBool(name: string, value: boolean): void;
+    setFloat(name: string, value: number): void;
+    setTrigger(name: string): void;
+    resetTrigger(name: string): void;
+    getPoseNodeDebugInfo(nodeIdx: number): PoseNodeDebugInfo;
+    getRuntimeNodeDebugValue<T>(nodeIdx: number): T;
+    getNodeDebugInstance(nodeIdx: number): GraphNode;
+    private isControlParameter;
+    private setControlParameterValue;
+}

package/dist/plugins/animation-graph/graph-node.d.ts

@@ -0,0 +1,70 @@
+import type * as spec from '@galacean/effects-specification';
+import type { GraphContext, InstantiationContext } from './graph-context';
+import type { PoseResult } from './pose-result';
+export declare const InvalidIndex = -1;
+export declare class GraphNode {
+    private initializationCount;
+    private lastUpdateID;
+    constructor();
+    getNodeData<T extends GraphNodeData>(): T;
+    isValid(): boolean;
+    isInitialized(): boolean;
+    initialize(context: GraphContext): void;
+    /**
+     * Shutdown this node
+     */
+    shutdown(context: GraphContext): void;
+    isNodeActive(updateID: number): boolean;
+    isUpdated(context: GraphContext): boolean;
+    /**
+     * Mark this node as active for the current update
+     */
+    markNodeActive(context: GraphContext): void;
+    /**
+     * Internal initialization logic
+     */
+    protected initializeInternal(context: GraphContext): void;
+    /**
+     * Internal shutdown logic
+     */
+    protected shutdownInternal(context: GraphContext): void;
+}
+export declare abstract class GraphNodeData {
+    index: number;
+    abstract instantiate(context: InstantiationContext): void;
+    load(data: spec.GraphNodeData): void;
+    protected createNode<T extends GraphNode>(nodeType: new () => T, context: InstantiationContext): T;
+}
+export interface PoseNodeDebugInfo {
+    duration: number;
+    currentTime: number;
+    previousTime: number;
+}
+export declare abstract class PoseNode extends GraphNode {
+    protected duration: number;
+    protected previousTime: number;
+    protected currentTime: number;
+    /**
+     * Get current clamped percentage over the duration
+     */
+    getCurrentTime(): number;
+    /**
+     * Get previous clamped percentage over the duration
+     */
+    getPreviousTime(): number;
+    /**
+     * Get node duration
+     */
+    getDuration(): number;
+    getDebugInfo(): PoseNodeDebugInfo;
+    abstract evaluate(context: GraphContext, result: PoseResult): PoseResult;
+    protected initializeInternal(context: GraphContext): void;
+}
+export declare abstract class ValueNode extends GraphNode {
+    setValue<T>(value: T): void;
+    abstract getValue<T>(context: GraphContext): T;
+}
+export declare abstract class FloatValueNode extends ValueNode {
+}
+export declare abstract class BoolValueNode extends ValueNode {
+}

package/dist/plugins/animation-graph/index.d.ts

@@ -0,0 +1,6 @@
+export * from './animation-graph-asset';
+export * from './graph-instance';
+export * from './graph-node';
+export * from './nodes';
+export * from './pose';
+export * from './node-asset-type';

package/dist/plugins/animation-graph/node-asset-type.d.ts

@@ -0,0 +1,3 @@
+import type { Constructor } from '../../utils';
+export declare function nodeDataClass(className: string): (target: Object, context?: unknown) => void;
+export declare function getNodeDataClass<T>(className: string): Constructor<T> | null;

package/dist/plugins/animation-graph/nodes/animation-clip-node.d.ts

@@ -0,0 +1,52 @@
+import * as spec from '@galacean/effects-specification';
+import type { AnimationClip, AnimationCurve, ColorAnimationCurve, FloatAnimationCurve } from '../../cal/calculate-vfx-item';
+import type { GraphContext, InstantiationContext } from '../graph-context';
+import { GraphNodeData, PoseNode } from '../graph-node';
+import type { PoseResult } from '../pose-result';
+import type { Skeleton } from '../skeleton';
+import type { Pose } from '../pose';
+export declare class AnimationClipNodeData extends GraphNodeData {
+    playRate: number;
+    loopAnimation: boolean;
+    dataSlotIndex: number;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.AnimationClipNodeData): void;
+}
+export declare class AnimationClipNode extends PoseNode {
+    animation: AnimationClip | null;
+    private animatable;
+    evaluate(context: GraphContext, result: PoseResult): PoseResult;
+    protected initializeInternal(context: GraphContext): void;
+}
+declare enum TransformCurveType {
+    Position = 0,
+    Scale = 1,
+    Rotation = 2,
+    Euler = 3
+}
+export interface TransformCurveInfo {
+    type: TransformCurveType;
+    curve: AnimationCurve;
+    boneIndex: number;
+}
+export interface FloatCurveInfo {
+    curve: FloatAnimationCurve;
+    animatedObjectIndex: number;
+}
+export interface ColorCurveInfo {
+    curve: ColorAnimationCurve;
+    animatedObjectIndex: number;
+}
+export declare class Animatable {
+    private skeleton;
+    private animationClip;
+    private transformCurveInfos;
+    private floatCurveInfos;
+    private colorCurveInfos;
+    constructor(skeleton: Skeleton, animationClip: AnimationClip);
+    getPose(time: number, outPose: Pose): void;
+    private addTransformCurveInfo;
+    private addFloatCurveInfo;
+    private addColorCurveInfo;
+}
+export {};

package/dist/plugins/animation-graph/nodes/apply-additive-node.d.ts

@@ -0,0 +1,23 @@
+import * as spec from '@galacean/effects-specification';
+import type { GraphContext, InstantiationContext } from '../graph-context';
+import { PoseResult } from '../pose-result';
+import type { FloatValueNode } from '../graph-node';
+import { GraphNodeData, PoseNode } from '../graph-node';
+export declare class ApplyAdditiveNodeData extends GraphNodeData {
+    baseNodeIndex: number;
+    additiveNodeIndex: number;
+    inputParameterValueNodeIndex: number;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.ApplyAdditiveNodeData): void;
+}
+export declare class ApplyAdditiveNode extends PoseNode {
+    baseNode: PoseNode | null;
+    additiveNode: PoseNode | null;
+    inputParameterValueNode: FloatValueNode | null;
+    baseNodeResult: PoseResult;
+    additiveNodeResult: PoseResult;
+    protected initializeInternal(context: GraphContext): void;
+    protected shutdownInternal(context: GraphContext): void;
+    evaluate(context: GraphContext, result: PoseResult): PoseResult;
+    private applyAdditive;
+}

package/dist/plugins/animation-graph/nodes/blend-1d-node.d.ts

@@ -0,0 +1,23 @@
+import * as spec from '@galacean/effects-specification';
+import type { GraphContext, InstantiationContext } from '../graph-context';
+import type { FloatValueNode } from '../graph-node';
+import { GraphNodeData, PoseNode } from '../graph-node';
+import { PoseResult } from '../pose-result';
+export declare class BlendNodeData extends GraphNodeData {
+    sourceNodeIndex0: number;
+    sourceNodeIndex1: number;
+    inputParameterValueNodeIndex: number;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.BlendNodeData): void;
+}
+export declare class BlendNode extends PoseNode {
+    source0: PoseNode | null;
+    source1: PoseNode | null;
+    inputParameterValueNode: FloatValueNode | null;
+    source0Result: PoseResult;
+    source1Result: PoseResult;
+    protected initializeInternal(context: GraphContext): void;
+    protected shutdownInternal(context: GraphContext): void;
+    evaluate(context: GraphContext, result: PoseResult): PoseResult;
+    private localBlend;
+}

package/dist/plugins/animation-graph/nodes/bool-nodes.d.ts

@@ -0,0 +1,39 @@
+import * as spec from '@galacean/effects-specification';
+import type { InstantiationContext, GraphContext } from '../graph-context';
+import { BoolValueNode, GraphNodeData } from '../graph-node';
+export declare class AndNodeData extends GraphNodeData {
+    private conditionNodeIndices;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.AndNodeData): void;
+}
+export declare class AndNode extends BoolValueNode {
+    conditionNodes: BoolValueNode[];
+    private result;
+    getValue<T>(context: GraphContext): T;
+    protected initializeInternal(context: GraphContext): void;
+    protected shutdownInternal(context: GraphContext): void;
+}
+export declare class OrNodeData extends GraphNodeData {
+    private conditionNodeIndices;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.OrNodeData): void;
+}
+export declare class OrNode extends BoolValueNode {
+    conditionNodes: BoolValueNode[];
+    private result;
+    getValue<T>(context: GraphContext): T;
+    protected initializeInternal(context: GraphContext): void;
+    protected shutdownInternal(context: GraphContext): void;
+}
+export declare class NotNodeData extends GraphNodeData {
+    private inputValueNodeIndex;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.NotNodeData): void;
+}
+export declare class NotNode extends BoolValueNode {
+    inputValueNode: BoolValueNode | null;
+    private result;
+    getValue<T>(context: GraphContext): T;
+    protected initializeInternal(context: GraphContext): void;
+    protected shutdownInternal(context: GraphContext): void;
+}

package/dist/plugins/animation-graph/nodes/const-value-nodes.d.ts

@@ -0,0 +1,21 @@
+import * as spec from '@galacean/effects-specification';
+import type { GraphContext, InstantiationContext } from '../graph-context';
+import { BoolValueNode, FloatValueNode, GraphNodeData } from '../graph-node';
+export declare class ConstFloatNodeData extends GraphNodeData {
+    value: number;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.ConstFloatNodeData): void;
+}
+export declare class ConstFloatNode extends FloatValueNode {
+    value: number;
+    getValue<T>(context: GraphContext): T;
+}
+export declare class ConstBoolNodeData extends GraphNodeData {
+    value: boolean;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.ConstBoolNodeData): void;
+}
+export declare class ConstBoolNode extends BoolValueNode {
+    value: boolean;
+    getValue<T>(context: GraphContext): T;
+}

package/dist/plugins/animation-graph/nodes/control-parameter-nodes.d.ts

@@ -0,0 +1,32 @@
+import * as spec from '@galacean/effects-specification';
+import type { GraphContext, InstantiationContext } from '../graph-context';
+import { BoolValueNode, FloatValueNode, GraphNodeData } from '../graph-node';
+export declare class ControlParameterFloatNodeData extends GraphNodeData {
+    value: number;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.ControlParameterFloatNodeData): void;
+}
+export declare class ControlParameterFloatNode extends FloatValueNode {
+    private value;
+    getValue<T>(context: GraphContext): T;
+    setValue<T>(value: T): void;
+}
+export declare class ControlParameterBoolNodeData extends GraphNodeData {
+    private value;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.ControlParameterBoolNodeData): void;
+}
+export declare class ControlParameterBoolNode extends BoolValueNode {
+    private value;
+    getValue<T>(context: GraphContext): T;
+    setValue<T>(value: T): void;
+}
+export declare class ControlParameterTriggerNodeData extends GraphNodeData {
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.ControlParameterTriggerNodeData): void;
+}
+export declare class ControlParameterTriggerNode extends BoolValueNode {
+    private value;
+    getValue<T>(context: GraphContext): T;
+    setValue<T>(value: T): void;
+}

package/dist/plugins/animation-graph/nodes/index.d.ts

@@ -0,0 +1,10 @@
+export * from './animation-clip-node';
+export * from './apply-additive-node';
+export * from './blend-1d-node';
+export * from './bool-nodes';
+export * from './const-value-nodes';
+export * from './control-parameter-nodes';
+export * from './operator-nodes';
+export * from './state-machine-node';
+export * from './state-node';
+export * from './transition-node';

package/dist/plugins/animation-graph/nodes/operator-nodes.d.ts

@@ -0,0 +1,35 @@
+import * as spec from '@galacean/effects-specification';
+import type { GraphContext, InstantiationContext } from '../graph-context';
+import type { FloatValueNode } from '../graph-node';
+import { BoolValueNode, GraphNodeData } from '../graph-node';
+export declare class EqualNodeData extends GraphNodeData {
+    private inputValueNodeIndex;
+    private comparandValueNodeIndex;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.EqualNodeData): void;
+}
+export declare abstract class FloatComparisonNodeData extends GraphNodeData {
+    protected inputValueNodeIndex: number;
+    protected comparandValueNodeIndex: number;
+    load(data: spec.FloatComparisonNodeData): void;
+}
+declare enum Comparison {
+    GreaterThan = 0,
+    LessThan = 1
+}
+export declare class FloatComparisonNode extends BoolValueNode {
+    inputValueNode: FloatValueNode | null;
+    comparandValueNode: FloatValueNode | null;
+    comparison: Comparison;
+    private result;
+    protected initializeInternal(context: GraphContext): void;
+    protected shutdownInternal(context: GraphContext): void;
+    getValue<T>(context: GraphContext): T;
+}
+export declare class GreaterNodeData extends FloatComparisonNodeData {
+    instantiate(context: InstantiationContext): void;
+}
+export declare class LessNodeData extends FloatComparisonNodeData {
+    instantiate(context: InstantiationContext): void;
+}
+export {};

package/dist/plugins/animation-graph/nodes/state-machine-node.d.ts

@@ -0,0 +1,35 @@
+import * as spec from '@galacean/effects-specification';
+import { type GraphContext, type InstantiationContext } from '../graph-context';
+import type { PoseResult } from '../pose-result';
+import type { BoolValueNode } from '../graph-node';
+import { GraphNodeData, PoseNode } from '../graph-node';
+import type { StateNode } from './state-node';
+import type { TransitionNode } from './transition-node';
+export declare class StateMachineNodeData extends GraphNodeData {
+    stateDatas: spec.StateData[];
+    defaultStateIndex: number;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.StateMachineNodeData): void;
+}
+export interface TransitionInfo {
+    transitionNode: TransitionNode;
+    conditionNode: BoolValueNode;
+    targetStateIndex: number;
+}
+export interface StateInfo {
+    stateNode: StateNode;
+    transitions: TransitionInfo[];
+}
+export declare class StateMachineNode extends PoseNode {
+    states: StateInfo[];
+    defaultStateIndex: number;
+    private activeTransition;
+    private activeStateIndex;
+    evaluate(context: GraphContext, result: PoseResult): PoseResult;
+    private evaluateTransitions;
+    private selectDefaultState;
+    protected initializeInternal(context: GraphContext): void;
+    protected shutdownInternal(context: GraphContext): void;
+    private initializeTransitionConditions;
+    private shutdownTransitionConditions;
+}

package/dist/plugins/animation-graph/nodes/state-node.d.ts

@@ -0,0 +1,30 @@
+import * as spec from '@galacean/effects-specification';
+import type { GraphContext, InstantiationContext } from '../graph-context';
+import type { PoseResult } from '../pose-result';
+import { GraphNodeData, PoseNode } from '../graph-node';
+export declare enum TransitionState {
+    None = 0,
+    TransitioningIn = 1,
+    TransitioningOut = 2
+}
+export declare class StateNodeData extends GraphNodeData {
+    childNodeIndex: number;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.StateNodeData): void;
+}
+export declare class StateNode extends PoseNode {
+    childNode: PoseNode | null;
+    private transitionState;
+    private elapsedTimeInState;
+    private isFirstStateUpdate;
+    isTransitioning(): boolean;
+    isTransitioningIn(): boolean;
+    isTransitioningOut(): boolean;
+    startTransitionIn(context: GraphContext): void;
+    startTransitionOut(context: GraphContext): void;
+    setTransitioningState(newState: TransitionState): void;
+    getElapsedTimeInState(): number;
+    evaluate(context: GraphContext, result: PoseResult): PoseResult;
+    protected initializeInternal(context: GraphContext): void;
+    protected shutdownInternal(context: GraphContext): void;
+}

package/dist/plugins/animation-graph/nodes/transition-node.d.ts

@@ -0,0 +1,48 @@
+import * as spec from '@galacean/effects-specification';
+import type { InstantiationContext, GraphContext } from '../graph-context';
+import { PoseResult } from '../pose-result';
+import { GraphNodeData, PoseNode } from '../graph-node';
+import { type StateNode } from './state-node';
+export declare enum SourceType {
+    State = 0,
+    Transition = 1,
+    CachedPose = 2
+}
+export declare class TransitionNodeData extends GraphNodeData {
+    duration: number;
+    hasExitTime: boolean;
+    exitTime: number;
+    targetStateNodeIndex: number;
+    instantiate(context: InstantiationContext): void;
+    load(data: spec.TransitionNodeData): void;
+}
+export declare class TransitionNode extends PoseNode {
+    targetNode: StateNode;
+    hasExitTime: boolean;
+    exitTime: number;
+    private transitionLength;
+    private transitionProgress;
+    private blendWeight;
+    private sourceNode;
+    private sourceNodeResult;
+    private sourceType;
+    private targetNodeResult;
+    private blendedDuration;
+    evaluate(context: GraphContext, result: PoseResult): PoseResult;
+    isComplete(context: GraphContext): boolean;
+    getProgressPercentage(): number;
+    getSourceType(): SourceType;
+    isSourceATransition(): boolean;
+    isSourceAState(): boolean;
+    startTransitionFromState(context: GraphContext, sourceNodeResult: PoseResult, sourceState: StateNode, outResult: PoseResult): PoseResult;
+    startTransitionFromTransition(context: GraphContext, sourceNodeResult: PoseResult, sourceTransition: TransitionNode, outResult: PoseResult): PoseResult;
+    getSourceStateNode(): StateNode;
+    getSourceTransitionNode(): TransitionNode;
+    notifyNewTransitionStarting(context: GraphContext, targetStateNode: StateNode): void;
+    protected initializeInternal(context: GraphContext): void;
+    protected shutdownInternal(context: GraphContext): void;
+    private endSourceTransition;
+    private initializeTargetStateAndUpdateTransition;
+    private calculateBlendWeight;
+    private registerPoseTasksAndUpdateRootMotion;
+}

package/dist/plugins/animation-graph/pose-result.d.ts

@@ -0,0 +1,6 @@
+import { Pose } from './pose';
+import type { Skeleton } from './skeleton';
+export declare class PoseResult {
+    pose: Pose;
+    constructor(skeleton: Skeleton);
+}

package/dist/plugins/animation-graph/pose.d.ts

@@ -0,0 +1,25 @@
+import { Quaternion } from '@galacean/effects-math/es/core/quaternion';
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
+import type { Color } from '@galacean/effects-math/es/core/color';
+import type { Skeleton } from './skeleton';
+import type { Transform } from '../../transform';
+export declare class NodeTransform {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+    euler: Vector3;
+    constructor(transform?: Transform);
+    copyFrom(transform: NodeTransform): this;
+}
+export declare class Pose {
+    skeleton: Skeleton;
+    parentSpaceTransforms: NodeTransform[];
+    floatPropertyValues: number[];
+    colorPropertyValues: Color[];
+    constructor(skeleton: Skeleton);
+    setPosition(path: string, position: Vector3): void;
+    setRotation(path: string, rotation: Quaternion): void;
+    setEuler(path: string, euler: Vector3): void;
+    setScale(path: string, scale: Vector3): void;
+    setFloat(path: string, value: number): void;
+}