@galacean/effects-core 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/material/material.d.ts

@@ -1,5 +1,5 @@
-import type { Matrix3, Matrix4, Quaternion, Vector2, Vector3, Vector4 } from '@galacean/effects-math/es/core/index';
-import type { GlobalUniforms, Renderer, ShaderWithSource } from '../render';
+import type { Matrix3, Matrix4, Quaternion, Vector2, Vector3, Vector4, Color } from '@galacean/effects-math/es/core/index';
+import type { GlobalUniforms, Renderer, Shader, ShaderWithSource } from '../render';
 import type { Texture } from '../texture';
 import type { DestroyOptions, Disposable } from '../utils';
 import type { UniformSemantic, UniformValue } from './types';
@@ -55,7 +55,9 @@ export interface MaterialProps {
  * Material 抽象类
  */
 export declare abstract class Material extends EffectsObject implements Disposable {
+    shader: Shader;
     shaderSource: ShaderWithSource;
+    stringTags: Record<string, string>;
     readonly uniformSemantics: Record<string, UniformSemantic>;
     readonly renderType: MaterialRenderType;
     readonly name: string;
@@ -247,6 +249,17 @@ export declare abstract class Material extends EffectsObject implements Disposab
      * @param value - 要设置的 uniform 数据
      */
     abstract setVector4(name: string, value: Vector4): void;
+    /**
+     * 获取 Material 的 Color 类型的 uniform 数据
+     * @param name
+     */
+    abstract getColor(name: string): Color | null;
+    /**
+     * 设置 Color 类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setColor(name: string, value: Color): void;
     /**
      * 获取 Material 的 Quaternion 类型的 uniform 数据
      * @param name
@@ -320,9 +333,9 @@ export declare abstract class Material extends EffectsObject implements Disposab
      */
     abstract hasUniform(name: string): boolean;
     /******** 预留接口，暂时不用实现 ***********************/
-    abstract enableKeyword(keyword: string): void;
-    abstract disableKeyword(keyword: string): void;
-    abstract isKeywordEnabled(keyword: string): boolean;
+    abstract enableMacro(keyword: string, value?: boolean | number): void;
+    abstract disableMacro(keyword: string): void;
+    abstract isMacroEnabled(keyword: string): boolean;
     /***************************************************/
     /**
      * Material 的克隆方法（不接入滤镜，本方法可以不做实现）

package/dist/material/types.d.ts

@@ -33,11 +33,6 @@ export interface MaterialStates extends MaterialBlendingStates, MaterialStencilS
     polygonOffset?: [factor: number, units: number];
     polygonOffsetFill?: boolean;
 }
-export interface FilterMaterialStates extends MaterialStates {
-    blendMode?: spec.BlendingMode;
-    side?: spec.SideMode;
-    maskMode?: spec.MaskMode;
-}
 export interface MaterialDataBlockDestroyOptions {
     textures?: DestroyOptions;
 }

package/dist/material/utils.d.ts

@@ -1,17 +1,17 @@
 import * as spec from '@galacean/effects-specification';
-import type { ShaderMarcos } from '../render';
+import type { ShaderMacros } from '../render';
 import type { Material } from './material';
 import { ShaderType } from './types';
 export declare function valIfUndefined<T>(val: any, def: T): T;
 export declare function getPreMultiAlpha(blending?: number): number;
 /**
  * 生成 shader，检测到 WebGL1 上下文会降级
- * @param marcos - 宏定义数组
+ * @param macros - 宏定义数组
  * @param shader - 原始 shader 文本
  * @param shaderType - shader 类型
  * @return 去除版本号的 shader 文本
  */
-export declare function createShaderWithMarcos(marcos: ShaderMarcos, shader: string, shaderType: ShaderType, level: number): string;
+export declare function createShaderWithMacros(macros: ShaderMacros, shader: string, shaderType: ShaderType, level: number): string;
 export declare function setBlendMode(material: Material, blendMode?: number): void;
 export declare function setSideMode(material: Material, side: spec.SideMode): void;
-export declare function setMaskMode(material: Material, maskMode: number): void;
+export declare function setMaskMode(material: Material, maskMode: spec.MaskMode): void;

package/dist/math/bezier.d.ts

@@ -0,0 +1,99 @@
+import type * as spec from '@galacean/effects-specification';
+import { Vector2 } from '@galacean/effects-math/es/core/vector2';
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
+import { Quaternion } from '@galacean/effects-math/es/core/quaternion';
+export declare class BezierLengthData {
+    points: Array<{
+        partialLength: number;
+        point: Vector3;
+    }>;
+    totalLength: number;
+    constructor(points: Array<{
+        partialLength: number;
+        point: Vector3;
+    }>, totalLength: number);
+}
+export declare const BezierMap: Record<string, BezierEasing>;
+export declare const BezierDataMap: Record<string, BezierLengthData>;
+/**
+ * @param p1 起始点
+ * @param p2 终点
+ * @param p3 起始控制点
+ * @param p4 终止控制点
+ * @returns
+ */
+export declare function buildBezierData(p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3): {
+    data: BezierLengthData;
+    interval: Vector3;
+};
+export declare class BezierPath {
+    p1: Vector3;
+    p2: Vector3;
+    p3: Vector3;
+    p4: Vector3;
+    readonly lengthData: BezierLengthData;
+    readonly interval: Vector3;
+    readonly totalLength: number;
+    private catching;
+    constructor(p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3);
+    /**
+     * 获取路径在指定比例长度上点的坐标
+     * @param percent 路径长度的比例
+     */
+    getPointInPercent(percent: number): Vector3;
+}
+export declare class BezierQuat {
+    p1: Quaternion;
+    p2: Quaternion;
+    p3: Quaternion;
+    p4: Quaternion;
+    private temp;
+    readonly totalLength: number;
+    constructor(p1: Quaternion, p2: Quaternion, p3: Quaternion, p4: Quaternion);
+    /**
+     * 获取路径在指定比例长度上点的坐标
+     * @param percent 路径长度的比例
+     */
+    getPointInPercent(percent: number): Quaternion;
+}
+export declare class BezierEasing {
+    mX1: number;
+    mY1: number;
+    mX2: number;
+    mY2: number;
+    private precomputed;
+    private mSampleValues;
+    constructor(mX1: number, mY1: number, mX2: number, mY2: number);
+    precompute(): void;
+    getValue(x: number): number;
+    calcSampleValues(): void;
+    getTForX(aX: number): number;
+}
+export declare function buildEasingCurve(leftKeyframe: spec.BezierKeyframeValue, rightKeyframe: spec.BezierKeyframeValue): {
+    points: Vector2[];
+    timeInterval: number;
+    valueInterval: number;
+    curve: BezierEasing;
+};
+/**
+ * 根据关键帧类型获取贝塞尔曲线上的关键点
+ */
+export declare function getControlPoints(leftKeyframe: spec.BezierKeyframeValue, rightKeyframe: spec.BezierKeyframeValue, lineToBezier: boolean): ({
+    type: 'ease';
+    p0: Vector2;
+    p1: Vector2;
+    p2: Vector2;
+    p3: Vector2;
+    isHold?: boolean;
+    leftHoldLine?: boolean;
+    rightHoldLine?: boolean;
+} | {
+    type: 'line';
+    p0: Vector2;
+    p1: Vector2;
+    p2?: Vector2;
+    p3?: Vector2;
+    isHold?: boolean;
+    leftHoldLine?: boolean;
+    rightHoldLine?: boolean;
+});

package/dist/math/keyframe-info.d.ts

@@ -0,0 +1,39 @@
+import { Vector2 } from '@galacean/effects-math/es/core/vector2';
+import * as spec from '@galacean/effects-specification';
+export declare const keyframeInfo: {
+    /**
+     * 根据不同关键帧类型，获取位于曲线上的点
+     */
+    getPointInCurve(keyframe: spec.BezierKeyframeValue): Vector2;
+    /**
+     * 根据不同关键帧类型，获取位于曲线上的点的索引
+     */
+    getPointIndexInCurve(keyframe: spec.BezierKeyframeValue): {
+        xIndex: number;
+        yIndex: number;
+    };
+    /**
+     * 关键帧左侧是否为缓动类型（否则为线段）
+     */
+    isLeftSideEase(keyframe: spec.BezierKeyframeValue): keyframe is spec.EaseKeyframeValue | spec.EaseInKeyframeValue | spec.EaseHoldOutKeyframeValue;
+    /**
+     * 关键帧右侧是否为缓动类型（否则为线段）
+     */
+    isRightSideEase(keyframe: spec.BezierKeyframeValue): keyframe is spec.EaseKeyframeValue | spec.EaseOutKeyframeValue | spec.EaseHoldInKeyframeValue;
+    /**
+     * 关键帧左侧是否为缓动类型（否则为线段）
+     */
+    isKeyframeTypeLeftSideEase(keyframeType: spec.BezierKeyframeType): boolean;
+    /**
+     * 关键帧右侧是否为缓动类型（否则为线段）
+     */
+    isKeyframeTypeRightSideEase(keyframeType: spec.BezierKeyframeType): boolean;
+    /**
+     * 是否为定格进关键帧
+     */
+    isHoldInKeyframe(keyframe: spec.BezierKeyframeValue): boolean;
+    /**
+     * 是否为定格出关键帧
+     */
+    isHoldOutKeyframe(keyframe: spec.BezierKeyframeValue): boolean;
+};

package/dist/math/translate.d.ts

@@ -1,10 +1,11 @@
-import type { ValueGetter } from './value-getter';
 import { Vector3 } from '@galacean/effects-math/es/core/index';
+import type { ItemLinearVelOverLifetime } from '../plugins';
+import type { ValueGetter } from './value-getter';
 export declare function translatePoint(x: number, y: number): number[];
 export interface TranslateTarget {
     speedOverLifetime?: ValueGetter<number>;
     gravityModifier?: ValueGetter<number>;
-    linearVelOverLifetime?: any;
+    linearVelOverLifetime?: ItemLinearVelOverLifetime;
     orbitalVelOverLifetime?: any;
 }
 export declare function calculateTranslation(out: Vector3, target: TranslateTarget, acc: Vector3, time: number, duration: number, posData: Vector3, velData: Vector3): Vector3;

package/dist/math/utils.d.ts

@@ -1,6 +1,7 @@
 import type { vec2, vec3, vec4 } from '@galacean/effects-specification';
-import type { TriangleLike } from '@galacean/effects-math/es/core/index';
-import { Vector3, Ray } from '@galacean/effects-math/es/core/index';
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
+import { Ray } from '@galacean/effects-math/es/core/ray';
+import type { TriangleLike } from '@galacean/effects-math/es/core/type';
 import type { Camera } from '../camera';
 export type vec = number[];
 export declare function ensureVec3(num?: any): vec3;
@@ -12,3 +13,6 @@ export declare const particleOriginTranslateMap: Record<number, vec2>;
 export declare function nearestPowerOfTwo(value: number): number;
 export declare function setRayFromCamera(x: number, y: number, camera: Camera): Ray;
 export declare function trianglesFromRect(position: Vector3, halfWidth: number, halfHeight: number): TriangleLike[];
+export declare function decimalEqual(a: number, b: number, epsilon?: number): boolean;
+export declare function numberToFix(a: number, fixed?: number): number;
+export declare function pointOnLine(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): boolean;

package/dist/math/value-getter.d.ts

@@ -1,5 +1,10 @@
+import type { Vector2 } from '@galacean/effects-math/es/core/vector2';
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
+import { Quaternion } from '@galacean/effects-math/es/core/quaternion';
 import * as spec from '@galacean/effects-specification';
 import type { ColorStop } from '../utils';
+import type { BezierEasing } from './bezier';
+import { BezierPath, BezierQuat } from './bezier';
 interface KeyFrameMeta {
     curves: ValueGetter<any>[];
     index: number;
@@ -8,14 +13,17 @@ interface KeyFrameMeta {
     curveCount: number;
 }
 export declare class ValueGetter<T> {
+    static getAllData(meta: KeyFrameMeta, halfFloat?: boolean): Uint16Array | Float32Array;
     constructor(arg: any);
     onCreate(props: any): void;
     getIntegrateValue(t0: number, t1: number, timeScale?: number): T;
     getIntegrateByTime(t0: number, time: number): T;
     getValue(time?: number): T;
+    getMaxTime(): number;
     toUniform(meta: KeyFrameMeta): Float32Array;
     map(func: (n: T) => T): void;
     scaleXCoord(scale: number): ValueGetter<T>;
+    toData(): ArrayLike<number>;
 }
 export declare class StaticValue extends ValueGetter<number> {
     private value;
@@ -25,6 +33,7 @@ export declare class StaticValue extends ValueGetter<number> {
     getValue(time?: number): number;
     toUniform(): Float32Array;
     map(func: (n: number) => number): this;
+    getMaxTime(): number;
 }
 export declare class RandomSetValue<T> extends ValueGetter<T> {
     private items;
@@ -65,28 +74,6 @@ export declare class GradientValue extends ValueGetter<number[]> {
     getStops(): ColorStop[];
     getValue(time: number): number[];
 }
-export type KeyFrame = {
-    inTangent: number;
-    outTangent: number;
-    time: number;
-    value: number;
-};
-export declare class CurveValue extends ValueGetter<number> {
-    keys: KeyFrame[] | number[][];
-    min: number;
-    dist: number;
-    isCurveValue: boolean;
-    static getAllData(meta: KeyFrameMeta, halfFloat?: boolean): Uint16Array | Float32Array;
-    onCreate(props: number[] & number[][]): void;
-    getValue(time: number): number;
-    getIntegrateByTime(t0: number, t1: number): number;
-    getIntegrateValue(t0: number, t1: number, ts: number): number;
-    integrate(time: number, byTime: boolean): number;
-    toData(): Float32Array;
-    toUniform(meta: any): Float32Array;
-    map(func: (num: number) => number): this;
-    scaleXCoord(scale: number): this;
-}
 export declare class LineSegments extends ValueGetter<number> {
     isLineSeg: boolean;
     keys: number[][];
@@ -103,6 +90,24 @@ export declare class LineSegments extends ValueGetter<number> {
     map(func: (k: number) => number): this;
     scaleXCoord(scale: number): this;
 }
+export declare class BezierCurve extends ValueGetter<number> {
+    curveMap: Record<string, {
+        points: Vector2[];
+        timeInterval: number;
+        valueInterval: number;
+        curve: BezierEasing;
+    }>;
+    keys: number[][];
+    onCreate(props: spec.BezierKeyframeValue[]): void;
+    getValue(time: number): number;
+    getIntegrateValue(t0: number, t1: number, ts?: number): number;
+    getIntegrateByTime(t0: number, t1: number): number;
+    getCurveIntegrateValue(curveKey: string, time: number): number;
+    getCurveValue(curveKey: string, time: number): number;
+    toUniform(meta: KeyFrameMeta): Float32Array;
+    toData(): Float32Array;
+    getMaxTime(): number;
+}
 export declare class PathSegments extends ValueGetter<number[]> {
     keys: number[][];
     values: number[][];
@@ -110,10 +115,31 @@ export declare class PathSegments extends ValueGetter<number[]> {
     getValue(time: number): number[];
     calculateVec(i: number, dt: number): number[];
 }
-export declare class BezierSegments extends PathSegments {
-    cps: number[][];
-    onCreate(props: number[][][]): void;
-    calculateVec(i: number, t: number): number[];
+export declare class BezierCurvePath extends ValueGetter<Vector3> {
+    curveSegments: Record<string, {
+        points: Vector2[];
+        easingCurve: BezierEasing;
+        timeInterval: number;
+        valueInterval: number;
+        pathCurve: BezierPath;
+    }>;
+    onCreate(props: spec.BezierCurvePathValue): void;
+    getValue(time: number): Vector3;
+    getPercValue(curveKey: string, time: number): number;
+    getMaxTime(): number;
+}
+export declare class BezierCurveQuat extends ValueGetter<Quaternion> {
+    curveSegments: Record<string, {
+        points: Vector2[];
+        easingCurve: BezierEasing;
+        timeInterval: number;
+        valueInterval: number;
+        pathCurve: BezierQuat;
+    }>;
+    onCreate(props: spec.BezierCurveQuatValue): void;
+    getValue(time: number): Quaternion;
+    getPercValue(curveKey: string, time: number): number;
+    getMaxTime(): number;
 }
 export declare function createValueGetter(args: any): ValueGetter<any>;
 export declare function getKeyFrameMetaByRawValue(meta: KeyFrameMeta, value?: [type: spec.ValueType, value: any]): void;

package/dist/pass-render-level.d.ts

@@ -1 +1,3 @@
-export declare function passRenderLevel(l?: string, renderLevel?: string): boolean;
+import * as spec from '@galacean/effects-specification';
+import type { SceneRenderLevel } from './scene';
+export declare function passRenderLevel(l?: spec.RenderLevel, renderLevel?: SceneRenderLevel): boolean;

package/dist/plugin-system.d.ts

@@ -1,9 +1,8 @@
 import type * as spec from '@galacean/effects-specification';
-import type { SceneLoadOptions } from './asset-manager';
 import type { Composition } from './composition';
 import type { Plugin, PluginConstructor } from './plugins';
 import type { RenderFrame, Renderer } from './render';
-import type { Scene } from './scene';
+import type { Scene, SceneLoadOptions } from './scene';
 import type { VFXItemConstructor, VFXItemProps } from './vfx-item';
 import { VFXItem } from './vfx-item';
 export declare const pluginLoaderMap: Record<string, PluginConstructor>;
@@ -26,9 +25,9 @@ export declare class PluginSystem {
     initializeComposition(composition: Composition, scene: Scene): void;
     destroyComposition(comp: Composition): void;
     resetComposition(comp: Composition, renderFrame: RenderFrame): void;
-    createPluginItem(name: string, props: VFXItemProps, composition: Composition): VFXItem<any>;
+    createPluginItem(name: string, props: VFXItemProps, composition: Composition): VFXItem;
     processRawJSON(json: spec.JSONScene, options: SceneLoadOptions): Promise<void[]>;
     private callStatic;
-    precompile(compositions: spec.Composition[], renderer: Renderer, options?: PrecompileOptions): Promise<void[]>;
+    precompile(compositions: spec.CompositionData[], renderer: Renderer, options?: PrecompileOptions): Promise<void[]>;
     loadResources(scene: Scene, options: SceneLoadOptions): Promise<void[]>;
 }

package/dist/plugins/cal/animation-mixer-playable.d.ts

@@ -1,4 +1,4 @@
 import { AnimationPlayable } from './animation-playable';
 export declare class AnimationMixerPlayable extends AnimationPlayable {
-    processFrame(dt: number): void;
+    processFrame(): void;
 }

package/dist/plugins/cal/animation-playable-output.d.ts

@@ -1,4 +1,4 @@
 import { PlayableOutput } from './playable-graph';
 export declare class AnimationPlayableOutput extends PlayableOutput {
-    processFrame(dt: number): void;
+    processFrame(): void;
 }

package/dist/plugins/cal/animation-playable.d.ts

@@ -1,6 +1,7 @@
 import { AnimationStream } from './animation-stream';
+import type { PlayableGraph } from './playable-graph';
 import { Playable } from './playable-graph';
 export declare class AnimationPlayable extends Playable {
     animationStream: AnimationStream;
-    constructor();
+    constructor(graph: PlayableGraph);
 }

package/dist/plugins/cal/calculate-item.d.ts

@@ -1,10 +1,7 @@
-import * as spec from '@galacean/effects-specification';
 import type { Euler, Vector3 } from '@galacean/effects-math/es/core/index';
-import { ItemBehaviour } from '../../components';
-import type { Engine } from '../../engine';
 import type { ValueGetter } from '../../math';
-import { PlayableGraph } from './playable-graph';
-import { Track } from './track';
+import { TrackAsset } from '../timeline/track';
+import type { TimelineAsset } from './timeline-asset';
 /**
  * 基础位移属性数据
  */
@@ -12,7 +9,7 @@ export type ItemBasicTransform = {
     position: Vector3;
     rotation: Euler;
     scale: Vector3;
-    path?: ValueGetter<spec.vec3>;
+    path?: ValueGetter<Vector3>;
 };
 export type ItemLinearVelOverLifetime = {
     asMovement?: boolean;
@@ -21,41 +18,10 @@ export type ItemLinearVelOverLifetime = {
     z?: ValueGetter<number>;
     enabled?: boolean;
 };
-export interface CalculateItemOptions {
-    start: number;
-    duration: number;
-    looping: boolean;
-    endBehavior: number;
-    startRotation?: number;
-    start3DRotation?: number;
-}
 /**
  * @since 2.0.0
  * @internal
  */
-export declare class TimelineComponent extends ItemBehaviour {
-    id: string;
-    reusable: boolean;
-    timelineStarted: boolean;
-    playableGraph: PlayableGraph;
-    options: CalculateItemOptions;
-    /**
-     * 元素动画已经播放的时间
-     */
-    private time;
-    private tracks;
-    private trackSeed;
-    constructor(engine: Engine);
-    start(): void;
-    update(dt: number): void;
-    setTime(time: number): void;
-    getTime(): number;
-    toLocalTime(time: number): number;
-    createTrack<T extends Track>(classConstructor: new () => T, name?: string): T;
-    getTracks(): Track[];
-    findTrack(name: string): Track | undefined;
-    rebuildGraph(): void;
-    compileTracks(graph: PlayableGraph): void;
-    fromData(data: spec.NullContent): void;
-    toData(): void;
+export declare class ObjectBindingTrack extends TrackAsset {
+    create(timelineAsset: TimelineAsset): void;
 }

package/dist/plugins/cal/calculate-vfx-item.d.ts

@@ -1,14 +1,18 @@
 import { Vector3 } from '@galacean/effects-math/es/core/vector3';
-import type * as spec from '@galacean/effects-specification';
+import type { Quaternion } from '@galacean/effects-math/es/core/quaternion';
+import * as spec from '@galacean/effects-specification';
 import type { ValueGetter } from '../../math';
 import { AnimationPlayable } from './animation-playable';
 import type { ItemBasicTransform, ItemLinearVelOverLifetime } from './calculate-item';
-import { Playable } from './playable-graph';
+import type { FrameContext, PlayableGraph } from './playable-graph';
+import { Playable, PlayableAsset } from './playable-graph';
+import { EffectsObject } from '../../effects-object';
+import { VFXItem } from '../../vfx-item';
 /**
  * @since 2.0.0
  * @internal
  */
-export declare class AnimationClipPlayable extends AnimationPlayable {
+export declare class TransformAnimationPlayable extends AnimationPlayable {
     originalTransform: ItemBasicTransform;
     protected sizeSeparateAxes: boolean;
     protected sizeXOverLifetime: ValueGetter<number>;
@@ -37,15 +41,22 @@ export declare class AnimationClipPlayable extends AnimationPlayable {
     gravity: Vector3;
     direction: Vector3;
     startSpeed: number;
+    data: TransformPlayableAssetData;
     private velocity;
-    processFrame(dt: number): void;
+    private binding;
+    start(): void;
+    processFrame(context: FrameContext): void;
     /**
      * 应用时间轴K帧数据到对象
      */
     private sampleAnimation;
-    fromData(data: TransformAnimationData): void;
 }
-export interface TransformAnimationData {
+export declare class TransformPlayableAsset extends PlayableAsset {
+    transformAnimationData: TransformPlayableAssetData;
+    createPlayable(graph: PlayableGraph): Playable;
+    fromData(data: TransformPlayableAssetData): void;
+}
+export interface TransformPlayableAssetData extends spec.EffectsObjectData {
     /**
      * 元素大小变化属性
      */
@@ -63,10 +74,45 @@ export interface TransformAnimationData {
  * @since 2.0.0
  * @internal
  */
-export declare class ActivationClipPlayable extends Playable {
-    onGraphStart(): void;
-    onPlayablePlay(): void;
-    onPlayableDestroy(): void;
-    private hideRendererComponents;
-    private showRendererComponents;
+export declare class ActivationPlayable extends Playable {
+    processFrame(context: FrameContext): void;
+}
+export declare class ActivationPlayableAsset extends PlayableAsset {
+    createPlayable(graph: PlayableGraph): Playable;
+}
+export interface PositionCurve {
+    path: string;
+    keyFrames: ValueGetter<Vector3>;
+}
+export interface EulerCurve {
+    path: string;
+    keyFrames: ValueGetter<Vector3>;
+}
+export interface RotationCurve {
+    path: string;
+    keyFrames: ValueGetter<Quaternion>;
+}
+export interface ScaleCurve {
+    path: string;
+    keyFrames: ValueGetter<Vector3>;
+}
+export interface FloatCurve {
+    path: string;
+    property: string;
+    className: string;
+    keyFrames: ValueGetter<number>;
+}
+export declare class AnimationClip extends EffectsObject {
+    duration: number;
+    positionCurves: PositionCurve[];
+    rotationCurves: RotationCurve[];
+    scaleCurves: ScaleCurve[];
+    floatCurves: FloatCurve[];
+    sampleAnimation(vfxItem: VFXItem, time: number): void;
+    fromData(data: spec.AnimationClipData): void;
+    private findTarget;
+}
+export declare class AnimationClipPlayable extends Playable {
+    clip: AnimationClip;
+    processFrame(context: FrameContext): void;
 }