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

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,17 +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 enum PlayableTraversalMode {
+    Mix = 0,
+    Passthrough = 1
 }

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

@@ -0,0 +1,27 @@
+import type { DataPath, EffectsObjectData } from '@galacean/effects-specification';
+import type { RuntimeClip, TrackAsset } from '../timeline/track';
+import type { FrameContext, PlayableGraph } from './playable-graph';
+import { Playable, PlayableAsset } from './playable-graph';
+import type { Constructor } from '../../utils';
+export interface TimelineAssetData extends EffectsObjectData {
+    tracks: DataPath[];
+}
+export declare class TimelineAsset extends PlayableAsset {
+    tracks: TrackAsset[];
+    createPlayable(graph: PlayableGraph): Playable;
+    createTrack<T extends TrackAsset>(classConstructor: Constructor<T>, parent: TrackAsset, name?: string): T;
+    fromData(data: TimelineAssetData): void;
+}
+export declare class TimelinePlayable extends Playable {
+    clips: RuntimeClip[];
+    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 type * as spec from '@galacean/effects-specification';
+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,11 @@ export * from './particle/particle-system-renderer';
 export * from './cal/calculate-loader';
 export * from './cal/calculate-vfx-item';
 export * from './cal/calculate-item';
-export * from './text/text-item';
-export * from './text/text-loader';
-export * from './cal/track';
+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 './timeline/tracks/sub-composition-track';
+export * from './timeline/playables/sub-composition-playable-asset';
+export * from './cal/timeline-asset';
+export * from './text';

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,13 +46,13 @@ export interface HitTestCustomParams {
     behavior?: spec.InteractBehavior;
 }
 export type Region = {
-    compContent: VFXItem<VFXItemContent>;
+    compContent: VFXItem;
     name: string;
     id: string;
     position: Vector3;
     behavior?: spec.InteractBehavior;
     parentId?: string;
-    hitPositions?: Vector3[];
+    hitPositions: Vector3[];
 };
 export type HitTestParams = {
     camera: {

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/interact/interact-item.d.ts

@@ -15,6 +15,18 @@ export declare class InteractComponent extends RendererComponent {
     bouncingArg: TouchEventType | null;
     previewContent: InteractMesh | null;
     interactData: spec.InteractContent;
+    /**
+     * 拖拽的惯性衰减系数，范围[0, 1], 越大惯性越强
+     */
+    downgrade: number;
+    /**
+     * 拖拽的距离映射系数，越大越容易拖动
+     */
+    dragRatio: number[];
+    /** 是否响应点击和拖拽交互事件 */
+    private _interactive;
+    set interactive(enable: boolean);
+    get interactive(): boolean;
     start(): void;
     update(dt: number): void;
     render(renderer: Renderer): void;
@@ -24,5 +36,6 @@ export declare class InteractComponent extends RendererComponent {
     beginDragTarget(options: spec.DragInteractOption, eventSystem: EventSystem): void;
     getHitTestParams: (force?: boolean) => HitTestTriangleParams | void;
     getBoundingBox(): BoundingBoxTriangle | void;
-    fromData(data: any): void;
+    fromData(data: spec.InteractContent): void;
+    canInteract(): boolean;
 }

package/dist/plugins/interact/interact-mesh.d.ts

@@ -1,8 +1,8 @@
 import type * as spec from '@galacean/effects-specification';
+import type { Engine } from '../../engine';
 import type { MeshRendererOptions } from '../../render';
 import { Mesh } from '../../render';
 import type { Transform } from '../../transform';
-import type { Engine } from '../../engine';
 export declare class InteractMesh {
     private readonly transform;
     private readonly engine;

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

@@ -1,4 +1,4 @@
-import * as spec from '@galacean/effects-specification';
+import type * as spec from '@galacean/effects-specification';
 import type { Engine } from '../../engine';
 import type { Renderer } from '../../render';
 import { AbstractPlugin } from '../index';

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

@@ -1,12 +1,13 @@
 import type * as spec from '@galacean/effects-specification';
-import type { Matrix4 } from '@galacean/effects-math/es/core/index';
-import { Vector2, Vector3 } from '@galacean/effects-math/es/core/index';
-import type { ValueGetter } from '../../math';
-import type { SharedShaderWithSource, GPUCapability } from '../../render';
+import type { Matrix4 } from '@galacean/effects-math/es/core/matrix4';
+import { Vector2 } from '@galacean/effects-math/es/core/vector2';
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
+import type { Engine } from '../../engine';
+import { ValueGetter } from '../../math';
+import type { GPUCapability, SharedShaderWithSource } from '../../render';
 import { Geometry, Mesh } from '../../render';
 import { Texture } from '../../texture';
 import { Transform } from '../../transform';
-import type { Engine } from '../../engine';
 export type Point = {
     vel: Vector3;
     lifetime: number;
@@ -66,7 +67,6 @@ export interface ParticleMeshProps extends ParticleMeshData {
     mask: number;
     maskMode: number;
     side: number;
-    filter?: spec.FilterParams;
     transparentOcclusion?: boolean;
     matrix?: Matrix4;
     sprite?: {
@@ -151,7 +151,7 @@ export declare class ParticleMesh implements ParticleMeshData {
     removePoint(index: number): void;
     setPoint(index: number, point: Point): void;
 }
-export declare function getParticleMeshShader(item: spec.ParticleItem, env: string | undefined, gpuCapability: GPUCapability): {
+export declare function getParticleMeshShader(item: spec.ParticleItem, gpuCapability: GPUCapability, env?: string): {
     shader: SharedShaderWithSource;
     vertex: number;
     fragment: 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

@@ -48,7 +48,7 @@ type ParticleOptions = {
     maxCount: number;
     gravity: vec3;
     gravityModifier: ValueGetter<number>;
-    renderLevel?: string;
+    renderLevel?: spec.RenderLevel;
     particleFollowParent?: boolean;
     forceTarget?: {
         curve: ValueGetter<number>;
@@ -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;
@@ -192,6 +192,6 @@ export declare class ParticleSystem extends Component {
     resumeParticleEmission(): void;
     getBoundingBox(): void | BoundingBoxSphere;
     getHitTestParams: (force?: boolean) => void | HitTestCustomParams;
-    fromData(data: any): void;
+    fromData(data: unknown): void;
 }
 export {};

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,6 +7,11 @@ import { ParticleSystem } from './particle-system';
  */
 export declare class ParticleBehaviourPlayable extends Playable {
     particleSystem: ParticleSystem;
-    onPlayablePlay(): void;
-    processFrame(dt: number): void;
+    lastTime: number;
+    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/particle/trail-mesh.d.ts

@@ -1,12 +1,12 @@
-import type * as spec from '@galacean/effects-specification';
-import type { vec4, GradientStop } from '@galacean/effects-specification';
-import { Vector3 } from '@galacean/effects-math/es/core/index';
 import type { Matrix4 } from '@galacean/effects-math/es/core/index';
-import type { ShaderWithSource, GPUCapability } from '../../render';
+import { Vector3 } from '@galacean/effects-math/es/core/index';
+import type * as spec from '@galacean/effects-specification';
+import type { GradientStop, vec4 } from '@galacean/effects-specification';
+import type { Engine } from '../../engine';
+import { ValueGetter } from '../../math';
+import type { GPUCapability, ShaderWithSource } from '../../render';
 import { Geometry, Mesh } from '../../render';
 import { Texture } from '../../texture';
-import type { Engine } from '../../engine';
-import type { ValueGetter } from '../../math';
 export type TrailMeshProps = {
     maxTrailCount: number;
     pointCountPerTrail: number;
@@ -56,4 +56,4 @@ export declare class TrailMesh {
     setPointStartPos(index: number, pos: Vector3): void;
     onUpdate(escapeTime: number): any;
 }
-export declare function getTrailMeshShader(trails: spec.ParticleTrail, particleMaxCount: number, name: string, env: string | undefined, gpuCapability: GPUCapability): ShaderWithSource;
+export declare function getTrailMeshShader(trails: spec.ParticleTrail, particleMaxCount: number, name: string, gpuCapability: GPUCapability, env?: string): ShaderWithSource;

package/dist/plugins/plugin.d.ts

@@ -1,6 +1,5 @@
 import type * as spec from '@galacean/effects-specification';
-import type { SceneLoadOptions } from '../asset-manager';
-import type { Scene } from '../scene';
+import type { Scene, SceneLoadOptions } from '../scene';
 import type { VFXItem } from '../vfx-item';
 import type { RenderFrame, Renderer } from '../render';
 import type { Composition } from '../composition';
@@ -22,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
@@ -113,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

@@ -9,9 +9,8 @@ import type { Renderer } from '../../render';
 import { Geometry } from '../../render';
 import type { GeometryFromShape } from '../../shape';
 import type { Texture } from '../../texture';
-import type { CalculateItemOptions } from '../cal/calculate-item';
-import { TimelineComponent } 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
@@ -23,17 +22,14 @@ export interface SpriteItemProps extends Omit<spec.SpriteContent, 'renderer'> {
         shape: GeometryFromShape;
         texture: Texture;
     } & Omit<spec.RendererOptions, 'texture'>;
-    filter?: {
-        feather: number | spec.FunctionExpression;
-    } & Omit<spec.FilterParams, 'feather'>;
 }
 /**
  * 图层元素基础属性, 经过处理后的 spec.SpriteContent.options
  */
 export type SpriteItemOptions = {
     startColor: vec4;
-    renderLevel?: string;
-} & CalculateItemOptions;
+    renderLevel?: spec.RenderLevel;
+};
 /**
  * 图层元素渲染属性, 经过处理后的 spec.SpriteContent.renderer
  */
@@ -72,12 +68,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;
@@ -90,8 +91,8 @@ export declare class SpriteComponent extends RendererComponent {
         index: number[] | spec.TypedArray;
     };
     anchor?: vec2;
-    timelineComponent: TimelineComponent;
     textureSheetAnimation?: spec.TextureSheetAnimation;
+    frameAnimationTime: number;
     splits: splitsDataType;
     emptyTexture: Texture;
     color: vec4;
@@ -112,6 +113,19 @@ export declare class SpriteComponent extends RendererComponent {
      * 获取当前 Mesh 的可见性。
      */
     getVisible(): boolean;
+    /**
+     * 设置当前图层的颜色
+     * > Tips: 透明度也属于颜色的一部分，当有透明度/颜色 K 帧变化时，该 API 会失效
+     * @since 2.0.0
+     * @param color - 颜色值
+     */
+    setColor(color: vec4): void;
+    /**
+     * 设置当前 Mesh 的纹理
+     * @since 2.0.0
+     * @param texture - 纹理对象
+     */
+    setTexture(texture: Texture): void;
     render(renderer: Renderer): void;
     start(): void;
     update(dt: number): void;

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

@@ -20,16 +20,12 @@ export type SpriteRegionData = {
     size: spec.vec2;
 };
 export declare let maxSpriteMeshItemCount: number;
-export declare let maxSpriteTextureCount: number;
 export declare function setSpriteMeshMaxItemCountByGPU(gpuCapability: GPUCapabilityDetail): 16 | 32 | undefined;
 export declare function getImageItemRenderInfo(item: SpriteComponent): SpriteItemRenderInfo;
 export declare function spriteMeshShaderFromFilter(level: number, options?: {
-    count?: number;
-    ignoreBlend?: boolean;
     wireframe?: boolean;
     env?: string;
 }): SharedShaderWithSource;
 export declare function spriteMeshShaderIdFromRenderInfo(renderInfo: SpriteItemRenderInfo, count: number): string;
 export declare function spriteMeshShaderFromRenderInfo(renderInfo: SpriteItemRenderInfo, count: number, level: number, env?: string): SharedShaderWithSource;
 export declare function setMaxSpriteMeshItemCount(count: number): void;
-export declare function setSpriteMeshMaxFragmentTextures(count: number): void;

package/dist/plugins/text/index.d.ts

@@ -0,0 +1,4 @@
+export * from './text-item';
+export * from './text-layout';
+export * from './text-style';
+export * from './text-loader';

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

@@ -4,19 +4,41 @@ import type { SpriteItemProps } from '../sprite/sprite-item';
 import { SpriteComponent } from '../sprite/sprite-item';
 import { TextLayout } from './text-layout';
 import { TextStyle } from './text-style';
+import type { Material } from '../../material';
+export declare const DEFAULT_FONTS: string[];
+export interface TextComponent extends TextComponentBase {
+}
 /**
  * @since 2.0.0
  * @internal
  */
 export declare class TextComponent extends SpriteComponent {
-    textStyle: TextStyle;
     isDirty: boolean;
+    /**
+     * 文本行数
+     */
+    lineCount: number;
+    constructor(engine: Engine, props?: spec.TextContent);
+    update(dt: number): void;
+    fromData(data: SpriteItemProps): void;
+    updateWithOptions(options: spec.TextContentOptions): void;
+    updateTexture(flipY?: boolean): void;
+}
+export declare class TextComponentBase {
+    textStyle: TextStyle;
     canvas: HTMLCanvasElement;
     context: CanvasRenderingContext2D | null;
     textLayout: TextLayout;
     text: string;
+    /***** mix 类型兼容用 *****/
+    isDirty: boolean;
+    engine: Engine;
+    material: Material;
+    lineCount: number;
+    /***** mix 类型兼容用 *****/
     private char;
-    constructor(engine: Engine, props?: spec.TextContent);
+    updateWithOptions(options: spec.TextContentOptions): void;
+    private getLineCount;
     /**
      * 设置字号大小
      * @param value - 字号
@@ -107,13 +129,11 @@ export declare class TextComponent extends SpriteComponent {
      * @returns
      */
     setFontScale(value: number): void;
-    update(dt: number): void;
     /**
      * 更新文本
      * @returns
      */
-    updateTexture(): void;
-    fromData(data: SpriteItemProps): void;
+    updateTexture(flipY?: boolean): void;
     private getFontDesc;
     private setupOutline;
     private setupShadow;

package/dist/plugins/text/text-layout.d.ts

@@ -17,7 +17,15 @@ export declare class TextLayout {
      */
     lineHeight: number;
     constructor(options: spec.TextContentOptions);
-    getOffsetY(style: TextStyle): number;
+    /**
+     * 获取初始的行高偏移值
+     * @param style - 字体基础数据
+     * @param lineCount - 渲染行数
+     * @param lineHeight - 渲染时的字体行高
+     * @param fontSize - 渲染时的字体大小
+     * @returns - 行高偏移值
+     */
+    getOffsetY(style: TextStyle, lineCount: number, lineHeight: number, fontSize: number): number;
     getOffsetX(style: TextStyle, maxWidth: number): number;
     /**
      * 设置文本框的宽度和高度

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

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

package/dist/plugins/timeline/playables/sub-composition-clip-playable.d.ts

@@ -0,0 +1,5 @@
+import type { FrameContext } from '../../cal/playable-graph';
+import { Playable } from '../../cal/playable-graph';
+export declare class SubCompositionClipPlayable extends Playable {
+    processFrame(context: FrameContext): void;
+}

package/dist/plugins/timeline/playables/sub-composition-playable-asset.d.ts

@@ -0,0 +1,5 @@
+import type { Playable, PlayableGraph } from '../../cal/playable-graph';
+import { PlayableAsset } from '../../cal/playable-graph';
+export declare class SubCompositionPlayableAsset extends PlayableAsset {
+    createPlayable(graph: PlayableGraph): Playable;
+}