@galacean/effects-core 2.0.0-alpha.12 → 2.0.0-alpha.13

package/dist/math/bezier.d.ts

@@ -1,6 +1,7 @@
 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;
@@ -41,6 +42,20 @@ export declare class BezierPath {
      */
     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;

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/value-getter.d.ts

@@ -1,9 +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 } from './bezier';
+import { BezierPath, BezierQuat } from './bezier';
 interface KeyFrameMeta {
     curves: ValueGetter<any>[];
     index: number;
@@ -18,6 +19,7 @@ export declare class ValueGetter<T> {
     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>;
@@ -103,6 +105,7 @@ export declare class BezierCurve extends ValueGetter<number> {
     getCurveValue(curveKey: string, time: number): number;
     toUniform(meta: KeyFrameMeta): Float32Array;
     toData(): Float32Array;
+    getMaxTime(): number;
 }
 export declare class PathSegments extends ValueGetter<number[]> {
     keys: number[][];
@@ -122,6 +125,20 @@ export declare class BezierCurvePath extends ValueGetter<Vector3> {
     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/plugin-system.d.ts

@@ -25,7 +25,7 @@ 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[]>;

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,8 @@
-import * as spec from '@galacean/effects-specification';
 import type { Euler, Vector3 } from '@galacean/effects-math/es/core/index';
-import { ItemBehaviour } from '../../components';
+import * as spec from '@galacean/effects-specification';
 import type { Engine } from '../../engine';
 import type { ValueGetter } from '../../math';
-import { PlayableGraph } from './playable-graph';
-import { Track } from './track';
+import { TrackAsset } from '../timeline/track';
 /**
  * 基础位移属性数据
  */
@@ -33,29 +31,12 @@ export interface CalculateItemOptions {
  * @since 2.0.0
  * @internal
  */
-export declare class TimelineComponent extends ItemBehaviour {
-    id: string;
-    reusable: boolean;
-    timelineStarted: boolean;
-    playableGraph: PlayableGraph;
+export declare class ObjectBindingTrack extends TrackAsset {
     options: CalculateItemOptions;
-    /**
-     * 元素动画已经播放的时间
-     */
-    private time;
-    private tracks;
+    data: spec.EffectsObjectData;
     private trackSeed;
-    constructor(engine: Engine);
-    start(): void;
-    update(dt: number): void;
-    setTime(time: number): void;
-    getTime(): number;
+    create(): void;
     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;
+    createTrack<T extends TrackAsset>(classConstructor: new (engine: Engine) => T, name?: string): T;
+    fromData(data: spec.EffectsObjectData): void;
 }

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

@@ -1,11 +1,13 @@
 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 type { FrameContext, PlayableGraph } from './playable-graph';
 import { Playable, PlayableAsset } from './playable-graph';
 import { EffectsObject } from '../../effects-object';
-import type { VFXItem, VFXItemContent } from '../../vfx-item';
+import type { VFXItem } from '../../vfx-item';
 /**
  * @since 2.0.0
  * @internal
@@ -39,20 +41,22 @@ export declare class TransformAnimationPlayable 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 declare class TransformAnimationPlayableAsset extends PlayableAsset {
-    transformAnimationData: TransformAnimationData;
-    createPlayable(): Playable;
-    fromData(data: TransformAnimationData): void;
+export declare class TransformPlayableAsset extends PlayableAsset {
+    transformAnimationData: TransformPlayableAssetData;
+    createPlayable(graph: PlayableGraph): Playable;
+    fromData(data: TransformPlayableAssetData): void;
 }
-export interface TransformAnimationData {
+export interface TransformPlayableAssetData extends spec.EffectsObjectData {
     /**
      * 元素大小变化属性
      */
@@ -71,41 +75,43 @@ export interface TransformAnimationData {
  * @internal
  */
 export declare class ActivationPlayable extends Playable {
-    onGraphStart(): void;
-    onPlayablePlay(): void;
-    onPlayableDestroy(): void;
-    private hideRendererComponents;
-    private showRendererComponents;
+    processFrame(context: FrameContext): void;
+}
+export declare class ActivationPlayableAsset extends PlayableAsset {
+    createPlayable(graph: PlayableGraph): Playable;
 }
 export interface PositionCurve {
-    path: string[];
+    path: string;
     keyFrames: ValueGetter<Vector3>;
 }
 export interface EulerCurve {
-    path: string[];
+    path: string;
     keyFrames: ValueGetter<Vector3>;
 }
+export interface RotationCurve {
+    path: string;
+    keyFrames: ValueGetter<Quaternion>;
+}
 export interface ScaleCurve {
-    path: string[];
+    path: string;
     keyFrames: ValueGetter<Vector3>;
 }
 export interface FloatCurve {
-    path: string[];
-    property: string[];
+    path: string;
+    property: string;
     className: string;
     keyFrames: ValueGetter<number>;
 }
 export declare class AnimationClip extends EffectsObject {
     positionCurves: PositionCurve[];
-    eulerCurves: EulerCurve[];
+    rotationCurves: RotationCurve[];
     scaleCurves: ScaleCurve[];
     floatCurves: FloatCurve[];
-    sampleAnimation(vfxItem: VFXItem<VFXItemContent>, time: number): void;
+    sampleAnimation(vfxItem: VFXItem, time: number): void;
     fromData(data: spec.AnimationClipData): void;
     private findTarget;
 }
 export declare class AnimationClipPlayable extends Playable {
     clip: AnimationClip;
-    processFrame(dt: number): void;
-    fromData(data: any): void;
+    processFrame(context: FrameContext): void;
 }

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

@@ -1,4 +1,5 @@
-import type { VFXItem, VFXItemContent } from '../../vfx-item';
+import { EffectsObject } from '../../effects-object';
+import type { Disposable } from '../../utils';
 /**
  * 动画图，负责更新所有的动画节点
  * @since 2.0.0
@@ -6,36 +7,70 @@ import type { VFXItem, VFXItemContent } from '../../vfx-item';
  */
 export declare class PlayableGraph {
     private playableOutputs;
-    constructor();
+    private playables;
     evaluate(dt: number): void;
-    connect(source: Playable, destination: Playable): void;
+    connect(source: Playable, sourceOutputPort: number, destination: Playable, destinationInputPort: number): void;
     addOutput(output: PlayableOutput): void;
-    private callProcessFrame;
+    addPlayable(playable: Playable): void;
+    private processFrameWithRoot;
+    private prepareFrameWithRoot;
+    private updatePlayableTime;
 }
 /**
  * 动画图可播放节点对象
  * @since 2.0.0
  * @internal
  */
-export declare class Playable {
-    bindingItem: VFXItem<VFXItemContent>;
+export declare class Playable implements Disposable {
+    onPlayablePlayFlag: boolean;
+    onPlayablePauseFlag: boolean;
+    overrideTimeNextEvaluation: boolean;
+    private destroyed;
     private inputs;
+    private inputOuputPorts;
+    private inputWeight;
+    private outputs;
+    private playState;
+    private traversalMode;
     /**
      * 当前本地播放的时间
      */
     protected time: number;
-    constructor();
-    connect(playable: Playable): void;
+    constructor(graph: PlayableGraph, inputCount?: number);
+    play(): void;
+    pause(): void;
+    connectInput(inputPort: number, sourcePlayable: Playable, sourceOutputPort: number, weight?: number): void;
+    addInput(sourcePlayable: Playable, sourceOutputPort: number, weight?: number): void;
+    getInputCount(): number;
     getInputs(): Playable[];
-    getInput(index: number): Playable | undefined;
+    getInput(index: number): Playable;
+    getOutputCount(): number;
+    getOutputs(): Playable[];
+    getOutput(index: number): Playable;
+    getInputWeight(inputIndex: number): number;
+    setInputWeight(playable: Playable, weight: number): void;
+    setInputWeight(inputIndex: number, weight: number): void;
     setTime(time: number): void;
     getTime(): number;
-    onGraphStart(): void;
-    onGraphStop(): void;
-    onPlayablePlay(): void;
-    processFrame(dt: number): void;
+    getPlayState(): PlayState;
+    setTraversalMode(mode: PlayableTraversalMode): void;
+    getTraversalMode(): PlayableTraversalMode;
+    onPlayablePlay(context: FrameContext): void;
+    onPlayablePause(context: FrameContext): void;
+    prepareFrame(context: FrameContext): void;
+    processFrame(context: FrameContext): void;
     onPlayableDestroy(): void;
-    fromData(data: any): void;
+    dispose(): void;
+    /**
+     * @internal
+     */
+    prepareFrameRecursive(context: FrameContext, passthroughPort: number): void;
+    /**
+     * @internal
+     */
+    processFrameRecursive(context: FrameContext, passthroughPort: number): void;
+    private setOutput;
+    private setInput;
 }
 /**
  * 动画图输出节点对象，将动画数据采样到绑定的元素属性上
@@ -46,21 +81,37 @@ export declare class PlayableOutput {
     /**
      * 绑定到的动画 item
      */
-    bindingItem: VFXItem<VFXItemContent>;
+    userData: object;
     /**
      * 源 playable 对象
      */
     sourcePlayable: Playable;
+    context: FrameContext;
     /**
      * 当前本地播放的时间
      */
     protected time: number;
+    private sourceOutputPort;
     constructor();
-    setSourcePlayeble(playable: Playable): void;
-    onGraphStart(): void;
-    processFrame(dt: number): void;
+    setSourcePlayeble(playable: Playable, port?: number): void;
+    getSourceOutputPort(): number;
+    setUserData(value: object): void;
+    getUserData(): object;
+    prepareFrame(): void;
+    processFrame(): void;
+}
+export declare abstract class PlayableAsset extends EffectsObject {
+    abstract createPlayable(graph: PlayableGraph): Playable;
+}
+export interface FrameContext {
+    deltaTime: number;
+    output: PlayableOutput;
+}
+export declare enum PlayState {
+    Playing = 0,
+    Paused = 1
 }
-export declare abstract class PlayableAsset {
-    abstract createPlayable(): Playable;
-    fromData(data: any): void;
+export declare enum PlayableTraversalMode {
+    Mix = 0,
+    Passthrough = 1
 }

package/dist/plugins/cal/timeline-asset.d.ts

@@ -0,0 +1,28 @@
+import type { DataPath, EffectsObjectData } from '@galacean/effects-specification';
+import type { RuntimeClip, TrackAsset } from '../timeline/track';
+import { ObjectBindingTrack } from './calculate-item';
+import type { FrameContext, PlayableGraph } from './playable-graph';
+import { Playable, PlayableAsset } from './playable-graph';
+export interface TimelineAssetData extends EffectsObjectData {
+    tracks: DataPath[];
+}
+export declare class TimelineAsset extends PlayableAsset {
+    tracks: TrackAsset[];
+    graph: PlayableGraph;
+    createPlayable(graph: PlayableGraph): Playable;
+    fromData(data: TimelineAssetData): void;
+}
+export declare class TimelinePlayable extends Playable {
+    clips: RuntimeClip[];
+    masterTracks: ObjectBindingTrack[];
+    prepareFrame(context: FrameContext): void;
+    evaluate(): void;
+    compileTracks(graph: PlayableGraph, tracks: TrackAsset[]): void;
+    private sortTracks;
+    private addSubTracksRecursive;
+}
+export declare class TrackSortWrapper {
+    track: TrackAsset;
+    originalIndex: number;
+    constructor(track: TrackAsset, originalIndex: number);
+}

package/dist/plugins/camera/camera-controller-node.d.ts

@@ -1,20 +1,9 @@
-import { Euler, Vector3 } from '@galacean/effects-math/es/core/index';
 import * as spec from '@galacean/effects-specification';
 import { ItemBehaviour } from '../../components';
 import type { Engine } from '../../engine';
 export declare class CameraController extends ItemBehaviour {
-    near: number;
-    far: number;
-    fov: number;
-    clipMode?: spec.CameraClipMode;
-    position: Vector3;
-    rotation: Euler;
     private options;
-    private translateOverLifetime?;
-    private rotationOverLifetime?;
     constructor(engine: Engine, props?: spec.CameraContent);
-    start(): void;
     update(): void;
     fromData(data: spec.CameraContent): void;
-    private updateCamera;
 }

package/dist/plugins/index.d.ts

@@ -18,6 +18,10 @@ export * from './particle/particle-system-renderer';
 export * from './cal/calculate-loader';
 export * from './cal/calculate-vfx-item';
 export * from './cal/calculate-item';
+export * from './timeline/track';
+export * from './timeline/tracks/transform-track';
+export * from './timeline/tracks/activation-track';
+export * from './timeline/tracks/sprite-color-track';
+export * from './cal/timeline-asset';
 export * from './text/text-item';
 export * from './text/text-loader';
-export * from './cal/track';

package/dist/plugins/interact/click-handler.d.ts

@@ -1,6 +1,6 @@
 import type { Matrix4, Ray, TriangleLike, Vector2, Vector3 } from '@galacean/effects-math/es/core/index';
 import type * as spec from '@galacean/effects-specification';
-import type { VFXItem, VFXItemContent } from '../../vfx-item';
+import type { VFXItem } from '../../vfx-item';
 export declare enum HitTestType {
     triangle = 1,
     box = 2,
@@ -46,7 +46,7 @@ export interface HitTestCustomParams {
     behavior?: spec.InteractBehavior;
 }
 export type Region = {
-    compContent: VFXItem<VFXItemContent>;
+    compContent: VFXItem;
     name: string;
     id: string;
     position: Vector3;

package/dist/plugins/interact/event-system.d.ts

@@ -1,10 +1,8 @@
-import * as spec from '@galacean/effects-specification';
 import type { Disposable } from '../../utils';
 export declare const EVENT_TYPE_CLICK = "click";
 export declare const EVENT_TYPE_TOUCH_START = "touchstart";
 export declare const EVENT_TYPE_TOUCH_MOVE = "touchmove";
 export declare const EVENT_TYPE_TOUCH_END = "touchend";
-export declare const InteractBehavior: typeof spec.InteractBehavior;
 export type TouchEventType = {
     x: number;
     y: number;

package/dist/plugins/particle/particle-system-renderer.d.ts

@@ -15,7 +15,7 @@ export declare class ParticleSystemRenderer extends RendererComponent {
     meshes: Mesh[];
     particleMesh: ParticleMesh;
     private trailMesh?;
-    constructor(engine: Engine, particleMeshProps: ParticleMeshProps, trailMeshProps?: TrailMeshProps);
+    constructor(engine: Engine, particleMeshProps?: ParticleMeshProps, trailMeshProps?: TrailMeshProps);
     start(): void;
     update(dt: number): void;
     render(renderer: Renderer): void;

package/dist/plugins/particle/particle-system.d.ts

@@ -141,7 +141,7 @@ export declare class ParticleSystem extends Component {
     textureSheetAnimation?: ParticleTextureSheetAnimation;
     interaction?: ParticleInteraction;
     emissionStopped: boolean;
-    destoryed: boolean;
+    destroyed: boolean;
     props: ParticleSystemProps;
     private generatedCount;
     private lastUpdate;

package/dist/plugins/particle/particle-vfx-item.d.ts

@@ -1,4 +1,5 @@
-import { Playable } from '../cal/playable-graph';
+import type { FrameContext, PlayableGraph } from '../cal/playable-graph';
+import { Playable, PlayableAsset } from '../cal/playable-graph';
 import { ParticleSystem } from './particle-system';
 /**
  * @since 2.0.0
@@ -6,7 +7,10 @@ import { ParticleSystem } from './particle-system';
  */
 export declare class ParticleBehaviourPlayable extends Playable {
     particleSystem: ParticleSystem;
-    onPlayablePlay(): void;
-    processFrame(dt: number): void;
+    start(context: FrameContext): void;
+    processFrame(context: FrameContext): void;
+}
+export declare class ParticleBehaviourPlayableAsset extends PlayableAsset {
+    createPlayable(graph: PlayableGraph): Playable;
 }
 export declare const particleUniformTypeMap: Record<string, string>;

package/dist/plugins/plugin.d.ts

@@ -21,21 +21,21 @@ export interface Plugin {
      * @param composition
      * @param item
      */
-    onCompositionItemLifeBegin: (composition: Composition, item: VFXItem<any>) => void;
+    onCompositionItemLifeBegin: (composition: Composition, item: VFXItem) => void;
     /**
      * 合成生命周期结束时触发（无论结束行为）
      * 合成播放阶段只触发一次此函数
      * @param composition
      * @param item
      */
-    onCompositionItemLifeEnd: (composition: Composition, item: VFXItem<any>) => void;
+    onCompositionItemLifeEnd: (composition: Composition, item: VFXItem) => void;
     /**
      * 合成销毁时触发（当合成的结束行为是冻结、循环或合成配置了 reusable 时不触发）
      * 元素销毁应该在合成销毁时调用。
      * @param composition
      * @param item
      */
-    onCompositionItemRemoved: (composition: Composition, item: VFXItem<any>) => void;
+    onCompositionItemRemoved: (composition: Composition, item: VFXItem) => void;
     /**
      * 合成重播时的回调
      * @param composition
@@ -112,9 +112,9 @@ export declare abstract class AbstractPlugin implements Plugin {
      */
     static precompile(compositions: spec.Composition[], renderer: Renderer): Promise<void>;
     onCompositionConstructed(composition: Composition, scene: Scene): void;
-    onCompositionItemLifeBegin(composition: Composition, item: VFXItem<any>): void;
-    onCompositionItemLifeEnd(composition: Composition, item: VFXItem<any>): void;
-    onCompositionItemRemoved(composition: Composition, item: VFXItem<any>): void;
+    onCompositionItemLifeBegin(composition: Composition, item: VFXItem): void;
+    onCompositionItemLifeEnd(composition: Composition, item: VFXItem): void;
+    onCompositionItemRemoved(composition: Composition, item: VFXItem): void;
     onCompositionReset(composition: Composition, frame: RenderFrame): void;
     onCompositionWillReset(composition: Composition, frame: RenderFrame): void;
     onCompositionDestroyed(composition: Composition): void;

package/dist/plugins/sprite/sprite-item.d.ts

@@ -10,7 +10,8 @@ import { Geometry } from '../../render';
 import type { GeometryFromShape } from '../../shape';
 import type { Texture } from '../../texture';
 import type { CalculateItemOptions } from '../cal/calculate-item';
-import { Playable } from '../cal/playable-graph';
+import type { FrameContext, PlayableGraph } from '../cal/playable-graph';
+import { Playable, PlayableAsset } from '../cal/playable-graph';
 import type { BoundingBoxTriangle, HitTestTriangleParams } from '../interact/click-handler';
 /**
  * 用于创建 spriteItem 的数据类型, 经过处理后的 spec.SpriteContent
@@ -68,12 +69,17 @@ export declare class SpriteColorPlayable extends Playable {
     startColor: spec.RGBAColorValue;
     renderColor: vec4;
     spriteMaterial: Material;
-    onPlayablePlay(): void;
-    processFrame(dt: number): void;
-    fromData(clipData: {
-        colorOverLifetime?: spec.ColorOverLifetime;
-        startColor?: spec.RGBAColorValue;
-    }): this;
+    processFrame(context: FrameContext): void;
+    create(clipData: SpriteColorPlayableAssetData): this;
+}
+export declare class SpriteColorPlayableAsset extends PlayableAsset {
+    data: SpriteColorPlayableAssetData;
+    createPlayable(graph: PlayableGraph): Playable;
+    fromData(data: SpriteColorPlayableAssetData): void;
+}
+export interface SpriteColorPlayableAssetData extends spec.EffectsObjectData {
+    colorOverLifetime?: spec.ColorOverLifetime;
+    startColor?: spec.RGBAColorValue;
 }
 export declare class SpriteComponent extends RendererComponent {
     renderer: SpriteItemRenderer;

package/dist/plugins/timeline/playables/activation-mixer-playable.d.ts

@@ -0,0 +1,8 @@
+import type { FrameContext } from '../../cal/playable-graph';
+import { Playable } from '../../cal/playable-graph';
+export declare class ActivationMixerPlayable extends Playable {
+    private bindingItem;
+    processFrame(context: FrameContext): void;
+    private hideRendererComponents;
+    private showRendererComponents;
+}