@galacean/effects-core 2.1.0-alpha.1 → 2.1.0-alpha.11

package/dist/plugins/shape/poly-star.d.ts

@@ -0,0 +1,42 @@
+import { ShapePrimitive } from './shape-primitive';
+export declare enum StarType {
+    Star = 0,
+    Polygon = 1
+}
+export declare class PolyStar extends ShapePrimitive {
+    pointCount: number;
+    outerRadius: number;
+    innerRadius: number;
+    outerRoundness: number;
+    innerRoundness: number;
+    starType: StarType;
+    /**
+     * bezier 顶点
+     */
+    private v;
+    /**
+     * bezier 缓入点
+     */
+    private in;
+    /**
+     * bezier 缓出点
+     */
+    private out;
+    /**
+     *
+     * @param pointCount - 多边形顶点数量
+     * @param outerRadius - 外半径大小
+     * @param innerRadius - 内半径大小
+     * @param outerRoundness - 外顶点圆滑度百分比
+     * @param innerRoundness - 内顶点圆滑度百分比
+     * @param starType - PolyStar 类型
+     */
+    constructor(pointCount?: number, outerRadius?: number, innerRadius?: number, outerRoundness?: number, innerRoundness?: number, starType?: StarType);
+    clone(): ShapePrimitive;
+    copyFrom(source: PolyStar): void;
+    copyTo(destination: PolyStar): void;
+    build(points: number[]): void;
+    triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
+    private buildStarPath;
+    private buildPolygonPath;
+}

package/dist/plugins/shape/polygon.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Based on:
+ * https://github.com/pixijs/pixijs/blob/dev/src/maths/shapes/Polygon.ts
+ */
+import { ShapePrimitive } from './shape-primitive';
+import type { PointData } from './point-data';
+/**
+ * A class to define a shape via user defined coordinates.
+ */
+export declare class Polygon extends ShapePrimitive {
+    /**
+     * An array of the points of this polygon.
+     */
+    points: number[];
+    /**
+     * `false` after moveTo, `true` after `closePath`. In all other cases it is `true`.
+     */
+    closePath: boolean;
+    constructor(points: PointData[] | number[]);
+    constructor(...points: PointData[] | number[]);
+    /**
+     * Creates a clone of this polygon.
+     * @returns - A copy of the polygon.
+     */
+    clone(): Polygon;
+    /**
+     * Checks whether the x and y coordinates passed to this function are contained within this polygon.
+     * @param x - The X coordinate of the point to test.
+     * @param y - The Y coordinate of the point to test.
+     * @returns - Whether the x/y coordinates are within this polygon.
+     */
+    contains(x: number, y: number): boolean;
+    /**
+     * Copies another polygon to this one.
+     * @param polygon - The polygon to copy from.
+     * @returns Returns itself.
+     */
+    copyFrom(polygon: Polygon): this;
+    /**
+     * Copies this polygon to another one.
+     * @param polygon - The polygon to copy to.
+     * @returns Returns given parameter.
+     */
+    copyTo(polygon: Polygon): Polygon;
+    /**
+     * Get the last X coordinate of the polygon
+     * @readonly
+     */
+    get lastX(): number;
+    /**
+     * Get the last Y coordinate of the polygon
+     * @readonly
+     */
+    get lastY(): number;
+    /**
+     * Get the first X coordinate of the polygon
+     * @readonly
+     */
+    getX(): number;
+    /**
+     * Get the first Y coordinate of the polygon
+     * @readonly
+     */
+    getY(): number;
+    build(points: number[]): void;
+    triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
+}

package/dist/plugins/shape/rectangle.d.ts

@@ -0,0 +1,129 @@
+import { ShapePrimitive } from './shape-primitive';
+/**
+ * The `Rectangle` object is an area defined by its position, as indicated by its top-left corner
+ * point (`x`, `y`) and by its `width` and its `height`.
+ */
+export declare class Rectangle extends ShapePrimitive {
+    /**
+     * The X coordinate of the upper-left corner of the rectangle
+     * @default 0
+     */
+    x: number;
+    /**
+     * The Y coordinate of the upper-left corner of the rectangle
+     * @default 0
+     */
+    y: number;
+    /**
+     * The overall width of this rectangle
+     *  @default 0
+     */
+    width: number;
+    /**
+     * The overall height of this rectangle
+     * @default 0
+     */
+    height: number;
+    /**
+     * @param x - The X coordinate of the upper-left corner of the rectangle
+     * @param y - The Y coordinate of the upper-left corner of the rectangle
+     * @param width - The overall width of the rectangle
+     * @param height - The overall height of the rectangle
+     */
+    constructor(x?: string | number, y?: string | number, width?: string | number, height?: string | number);
+    /** Returns the left edge of the rectangle. */
+    get left(): number;
+    /** Returns the right edge of the rectangle. */
+    get right(): number;
+    /** Returns the top edge of the rectangle. */
+    get top(): number;
+    /** Returns the bottom edge of the rectangle. */
+    get bottom(): number;
+    /** Determines whether the Rectangle is empty. */
+    isEmpty(): boolean;
+    /** A constant empty rectangle. This is a new object every time the property is accessed */
+    static get EMPTY(): Rectangle;
+    /**
+     * Creates a clone of this Rectangle
+     * @returns a copy of the rectangle
+     */
+    clone(): Rectangle;
+    /**
+     * Converts a Bounds object to a Rectangle object.
+     * @param bounds - The bounds to copy and convert to a rectangle.
+     * @returns Returns itself.
+     */
+    /**
+     * Copies another rectangle to this one.
+     * @param rectangle - The rectangle to copy from.
+     * @returns Returns itself.
+     */
+    copyFrom(rectangle: Rectangle): Rectangle;
+    /**
+     * Copies this rectangle to another one.
+     * @param rectangle - The rectangle to copy to.
+     * @returns Returns given parameter.
+     */
+    copyTo(rectangle: Rectangle): Rectangle;
+    /**
+     * Checks whether the x and y coordinates given are contained within this Rectangle
+     * @param x - The X coordinate of the point to test
+     * @param y - The Y coordinate of the point to test
+     * @returns Whether the x/y coordinates are within this Rectangle
+     */
+    contains(x: number, y: number): boolean;
+    /**
+     * Checks whether the x and y coordinates given are contained within this rectangle including the stroke.
+     * @param x - The X coordinate of the point to test
+     * @param y - The Y coordinate of the point to test
+     * @param strokeWidth - The width of the line to check
+     * @returns Whether the x/y coordinates are within this rectangle
+     */
+    strokeContains(x: number, y: number, strokeWidth: number): boolean;
+    /**
+     * Determines whether the `other` Rectangle transformed by `transform` intersects with `this` Rectangle object.
+     * Returns true only if the area of the intersection is >0, this means that Rectangles
+     * sharing a side are not overlapping. Another side effect is that an arealess rectangle
+     * (width or height equal to zero) can't intersect any other rectangle.
+     * @param {Rectangle} other - The Rectangle to intersect with `this`.
+     * @param {Matrix} transform - The transformation matrix of `other`.
+     * @returns {boolean} A value of `true` if the transformed `other` Rectangle intersects with `this`; otherwise `false`.
+     */
+    /**
+     * Pads the rectangle making it grow in all directions.
+     * If paddingY is omitted, both paddingX and paddingY will be set to paddingX.
+     * @param paddingX - The horizontal padding amount.
+     * @param paddingY - The vertical padding amount.
+     * @returns Returns itself.
+     */
+    pad(paddingX?: number, paddingY?: number): this;
+    /**
+     * Fits this rectangle around the passed one.
+     * @param rectangle - The rectangle to fit.
+     * @returns Returns itself.
+     */
+    fit(rectangle: Rectangle): this;
+    /**
+     * Enlarges rectangle that way its corners lie on grid
+     * @param resolution - resolution
+     * @param eps - precision
+     * @returns Returns itself.
+     */
+    ceil(resolution?: number, eps?: number): this;
+    /**
+     * Enlarges this rectangle to include the passed rectangle.
+     * @param rectangle - The rectangle to include.
+     * @returns Returns itself.
+     */
+    enlarge(rectangle: Rectangle): this;
+    /**
+     * Returns the framing rectangle of the rectangle as a Rectangle object
+     * @param out - optional rectangle to store the result
+     * @returns The framing rectangle
+     */
+    getBounds(out?: Rectangle): Rectangle;
+    getX(): number;
+    getY(): number;
+    build(points: number[]): number[];
+    triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
+}

package/dist/plugins/shape/shape-path.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Based on:
+ * https://github.com/pixijs/pixijs/blob/dev/src/scene/graphics/shared/path/ShapePath.ts
+ */
+import type { Matrix4 } from '@galacean/effects-math/es/core/matrix4';
+import { Polygon } from './polygon';
+import type { GraphicsPath } from './graphics-path';
+import type { ShapePrimitive } from './shape-primitive';
+import type { StarType } from './poly-star';
+export declare class ShapePath {
+    private graphicsPath;
+    currentPoly: Polygon | null;
+    shapePrimitives: {
+        shape: ShapePrimitive;
+        transform?: Matrix4;
+    }[];
+    constructor(graphicsPath: GraphicsPath);
+    /** Builds the path. */
+    buildPath(): void;
+    /**
+     * Adds a cubic Bezier curve to the path.
+     * It requires three points: the first two are control points and the third one is the end point.
+     * The starting point is the last point in the current path.
+     * @param cp1x - The x-coordinate of the first control point.
+     * @param cp1y - The y-coordinate of the first control point.
+     * @param cp2x - The x-coordinate of the second control point.
+     * @param cp2y - The y-coordinate of the second control point.
+     * @param x - The x-coordinate of the end point.
+     * @param y - The y-coordinate of the end point.
+     * @param smoothness - Optional parameter to adjust the smoothness of the curve.
+     * @returns The instance of the current object for chaining.
+     */
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, smoothness?: number): ShapePath;
+    moveTo(x: number, y: number): ShapePath;
+    /**
+     * Draws an ellipse at the specified location and with the given x and y radii.
+     * An optional transformation can be applied, allowing for rotation, scaling, and translation.
+     * @param x - The x-coordinate of the center of the ellipse.
+     * @param y - The y-coordinate of the center of the ellipse.
+     * @param radiusX - The horizontal radius of the ellipse.
+     * @param radiusY - The vertical radius of the ellipse.
+     * @param transform - An optional `Matrix` object to apply a transformation to the ellipse. This can include rotations.
+     * @returns The instance of the current object for chaining.
+     */
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, transform?: Matrix4): this;
+    polyStar(pointCount: number, outerRadius: number, innerRadius: number, outerRoundness: number, innerRoundness: number, starType: StarType, transform?: Matrix4): this;
+    /**
+     * Draws a given shape on the canvas.
+     * This is a generic method that can draw any type of shape specified by the `ShapePrimitive` parameter.
+     * An optional transformation matrix can be applied to the shape, allowing for complex transformations.
+     * @param shape - The shape to draw, defined as a `ShapePrimitive` object.
+     * @param matrix - An optional `Matrix` for transforming the shape. This can include rotations,
+     * scaling, and translations.
+     * @returns The instance of the current object for chaining.
+     */
+    drawShape(shape: ShapePrimitive, matrix?: Matrix4): this;
+    /**
+     * Starts a new polygon path from the specified starting point.
+     * This method initializes a new polygon or ends the current one if it exists.
+     * @param x - The x-coordinate of the starting point of the new polygon.
+     * @param y - The y-coordinate of the starting point of the new polygon.
+     * @returns The instance of the current object for chaining.
+     */
+    private startPoly;
+    /**
+     * Ends the current polygon path. If `closePath` is set to true,
+     * the path is closed by connecting the last point to the first one.
+     * This method finalizes the current polygon and prepares it for drawing or adding to the shape primitives.
+     * @param closePath - A boolean indicating whether to close the polygon by connecting the last point
+     *  back to the starting point. False by default.
+     * @returns The instance of the current object for chaining.
+     */
+    private endPoly;
+    private ensurePoly;
+}

package/dist/plugins/shape/shape-primitive.d.ts

@@ -0,0 +1,15 @@
+export declare abstract class ShapePrimitive {
+    /** Checks whether the x and y coordinates passed to this function are contained within this ShapePrimitive. */
+    /** Checks whether the x and y coordinates passed to this function are contained within the stroke of this shape */
+    /** Creates a clone of this ShapePrimitive instance. */
+    abstract clone(): ShapePrimitive;
+    /** Copies the properties from another ShapePrimitive to this ShapePrimitive. */
+    abstract copyFrom(source: ShapePrimitive): void;
+    /** Copies the properties from this ShapePrimitive to another ShapePrimitive. */
+    abstract copyTo(destination: ShapePrimitive): void;
+    /** Returns the framing rectangle of the ShapePrimitive as a Rectangle object. */
+    /** The X coordinate of the shape */
+    /** The Y coordinate of the shape */
+    abstract build(points: number[]): void;
+    abstract triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
+}

package/dist/plugins/shape/triangle.d.ts

@@ -0,0 +1,89 @@
+import { Rectangle } from './rectangle';
+import { ShapePrimitive } from './shape-primitive';
+/**
+ * A class to define a shape of a triangle via user defined coordinates.
+ *
+ * Create a `Triangle` object with the `x`, `y`, `x2`, `y2`, `x3`, `y3` properties.
+ */
+export declare class Triangle extends ShapePrimitive {
+    /**
+     * The X coord of the first point.
+     * @default 0
+     */
+    x: number;
+    /**
+     * The Y coord of the first point.
+     * @default 0
+     */
+    y: number;
+    /**
+     * The X coord of the second point.
+     * @default 0
+     */
+    x2: number;
+    /**
+     * The Y coord of the second point.
+     * @default 0
+     */
+    y2: number;
+    /**
+     * The X coord of the third point.
+     * @default 0
+     */
+    x3: number;
+    /**
+     * The Y coord of the third point.
+     * @default 0
+     */
+    y3: number;
+    /**
+     * @param x - The X coord of the first point.
+     * @param y - The Y coord of the first point.
+     * @param x2 - The X coord of the second point.
+     * @param y2 - The Y coord of the second point.
+     * @param x3 - The X coord of the third point.
+     * @param y3 - The Y coord of the third point.
+     */
+    constructor(x?: number, y?: number, x2?: number, y2?: number, x3?: number, y3?: number);
+    /**
+     * Checks whether the x and y coordinates given are contained within this triangle
+     * @param x - The X coordinate of the point to test
+     * @param y - The Y coordinate of the point to test
+     * @returns Whether the x/y coordinates are within this Triangle
+     */
+    contains(x: number, y: number): boolean;
+    /**
+     * Checks whether the x and y coordinates given are contained within this triangle including the stroke.
+     * @param pointX - The X coordinate of the point to test
+     * @param pointY - The Y coordinate of the point to test
+     * @param strokeWidth - The width of the line to check
+     * @returns Whether the x/y coordinates are within this triangle
+     */
+    /**
+     * Creates a clone of this Triangle
+     * @returns a copy of the triangle
+     */
+    clone(): ShapePrimitive;
+    /**
+     * Copies another triangle to this one.
+     * @param triangle - The triangle to copy from.
+     * @returns Returns itself.
+     */
+    copyFrom(triangle: Triangle): this;
+    /**
+     * Copies this triangle to another one.
+     * @param triangle - The triangle to copy to.
+     * @returns Returns given parameter.
+     */
+    copyTo(triangle: Triangle): Triangle;
+    /**
+     * Returns the framing rectangle of the triangle as a Rectangle object
+     * @param out - optional rectangle to store the result
+     * @returns The framing rectangle
+     */
+    getBounds(out?: Rectangle): Rectangle;
+    getX(): number;
+    getY(): number;
+    build(points: number[]): void;
+    triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
+}

package/dist/plugins/shape/triangulate.d.ts

@@ -0,0 +1 @@
+export declare function triangulate(contours: number[][]): number[];

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

@@ -1,17 +1,13 @@
-import { Matrix4 } from '@galacean/effects-math/es/core/index';
-import type { vec2, vec4 } from '@galacean/effects-specification';
 import * as spec from '@galacean/effects-specification';
-import { RendererComponent } from '../../components/renderer-component';
 import type { Engine } from '../../engine';
-import { Material } from '../../material';
-import type { ValueGetter } from '../../math';
-import type { Renderer } from '../../render';
+import type { GeometryDrawMode } from '../../render';
 import { Geometry } from '../../render';
 import type { GeometryFromShape } from '../../shape';
 import type { Texture } from '../../texture';
-import type { FrameContext, PlayableGraph } from '../cal/playable-graph';
-import { Playable, PlayableAsset } from '../cal/playable-graph';
-import type { BoundingBoxTriangle, HitTestTriangleParams } from '../interact/click-handler';
+import type { PlayableGraph, Playable } from '../cal/playable-graph';
+import { PlayableAsset } from '../cal/playable-graph';
+import type { ColorPlayableAssetData } from '../../animation';
+import { BaseRenderComponent } from '../../components/base-render-component';
 /**
  * 用于创建 spriteItem 的数据类型, 经过处理后的 spec.SpriteContent
  */
@@ -27,123 +23,26 @@ export interface SpriteItemProps extends Omit<spec.SpriteContent, 'renderer'> {
  * 图层元素基础属性, 经过处理后的 spec.SpriteContent.options
  */
 export type SpriteItemOptions = {
-    startColor: vec4;
+    startColor: spec.vec4;
     renderLevel?: spec.RenderLevel;
 };
-/**
- * 图层元素渲染属性, 经过处理后的 spec.SpriteContent.renderer
- */
-export interface SpriteItemRenderer extends Required<Omit<spec.RendererOptions, 'texture' | 'shape' | 'anchor' | 'particleOrigin'>> {
-    order: number;
-    mask: number;
-    texture: Texture;
-    shape?: GeometryFromShape;
-    anchor?: vec2;
-    particleOrigin?: spec.ParticleOrigin;
-}
-/**
- * 图层的渲染属性，用于 Mesh 的合并判断
- */
-export interface SpriteItemRenderInfo {
-    side: number;
-    occlusion: boolean;
-    blending: number;
-    cachePrefix: string;
-    mask: number;
-    maskMode: number;
-    cacheId: string;
-    wireframe?: boolean;
-}
 export type splitsDataType = [r: number, x: number, y: number, w: number, h: number | undefined][];
-export declare class SpriteColorPlayable extends Playable {
-    clipData: {
-        colorOverLifetime?: spec.ColorOverLifetime;
-        startColor?: spec.RGBAColorValue;
-    };
-    colorOverLifetime: {
-        stop: number;
-        color: any;
-    }[];
-    opacityOverLifetime: ValueGetter<number>;
-    startColor: spec.RGBAColorValue;
-    renderColor: vec4;
-    spriteMaterial: Material;
-    spriteComponent: SpriteComponent;
-    processFrame(context: FrameContext): void;
-    create(clipData: SpriteColorPlayableAssetData): this;
-}
 export declare class SpriteColorPlayableAsset extends PlayableAsset {
-    data: SpriteColorPlayableAssetData;
+    data: ColorPlayableAssetData;
     createPlayable(graph: PlayableGraph): Playable;
-    fromData(data: SpriteColorPlayableAssetData): void;
-}
-export interface SpriteColorPlayableAssetData extends spec.EffectsObjectData {
-    colorOverLifetime?: spec.ColorOverLifetime;
+    fromData(data: ColorPlayableAssetData): void;
 }
-export declare class SpriteComponent extends RendererComponent {
-    renderer: SpriteItemRenderer;
-    interaction?: {
-        behavior: spec.InteractBehavior;
-    };
-    cachePrefix: string;
-    geoData: {
-        atlasOffset: number[] | spec.TypedArray;
-        index: number[] | spec.TypedArray;
-    };
-    anchor?: vec2;
+export declare class SpriteComponent extends BaseRenderComponent {
     textureSheetAnimation?: spec.TextureSheetAnimation;
-    frameAnimationLoop: boolean;
     splits: splitsDataType;
-    emptyTexture: Texture;
-    color: vec4;
-    worldMatrix: Matrix4;
-    geometry: Geometry;
-    /***********************/
-    private renderInfo;
-    private readonly wireframe?;
-    private preMultiAlpha;
-    private visible;
-    private isManualTimeSet;
-    private frameAnimationTime;
+    frameAnimationLoop: boolean;
     constructor(engine: Engine, props?: SpriteItemProps);
-    /**
-     * 设置当前 Mesh 的可见性。
-     * @param visible - true：可见，false：不可见
-     */
-    setVisible(visible: boolean): void;
-    /**
-     * 获取当前 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;
-    onStart(): void;
     onUpdate(dt: number): void;
     onDestroy(): void;
-    private getItemInitData;
-    private setItem;
-    private createGeometry;
-    private createMaterial;
-    private getItemGeometryData;
-    getTextures(): Texture[];
-    /**
-     * 获取图层包围盒的类型和世界坐标
-     * @returns
-     */
-    getBoundingBox(): BoundingBoxTriangle | void;
-    getHitTestParams: (force?: boolean) => HitTestTriangleParams | void;
+    createGeometry(mode: GeometryDrawMode): Geometry;
+    getItemGeometryData(): {
+        index: number[];
+        atlasOffset: number[];
+    };
     fromData(data: SpriteItemProps): void;
-    toData(): void;
 }

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

@@ -1,7 +1,7 @@
 import type * as spec from '@galacean/effects-specification';
 import type { PrecompileOptions } from '../../plugin-system';
 import type { Renderer } from '../../render';
-import { AbstractPlugin } from '../index';
+import { AbstractPlugin } from '../plugin';
 export declare class SpriteLoader extends AbstractPlugin {
     name: string;
     static precompile(compositions: spec.Composition[], render: Renderer, options?: PrecompileOptions): Promise<any>;

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

@@ -2,7 +2,7 @@ import type { Vector3 } from '@galacean/effects-math/es/core/vector3';
 import type * as spec from '@galacean/effects-specification';
 import type { GPUCapabilityDetail, SharedShaderWithSource } from '../../render';
 import type { Transform } from '../../transform';
-import type { SpriteComponent, SpriteItemRenderInfo } from './sprite-item';
+import type { ItemRenderInfo } from '../../components';
 export type SpriteRenderData = {
     life: number;
     transform: Transform;
@@ -21,11 +21,10 @@ export type SpriteRegionData = {
 };
 export declare let maxSpriteMeshItemCount: number;
 export declare function setSpriteMeshMaxItemCountByGPU(gpuCapability: GPUCapabilityDetail): 16 | 32 | undefined;
-export declare function getImageItemRenderInfo(item: SpriteComponent): SpriteItemRenderInfo;
 export declare function spriteMeshShaderFromFilter(level: number, options?: {
     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 spriteMeshShaderIdFromRenderInfo(renderInfo: ItemRenderInfo, count: number): string;
+export declare function spriteMeshShaderFromRenderInfo(renderInfo: ItemRenderInfo, count: number, level: number, env?: string): SharedShaderWithSource;
 export declare function setMaxSpriteMeshItemCount(count: number): void;

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

@@ -1,26 +1,36 @@
 import * as spec from '@galacean/effects-specification';
 import type { Engine } from '../../engine';
-import type { SpriteItemProps } from '../sprite/sprite-item';
-import { SpriteComponent } from '../sprite/sprite-item';
+import { Texture } from '../../texture';
 import { TextLayout } from './text-layout';
 import { TextStyle } from './text-style';
 import type { Material } from '../../material';
 import type { VFXItem } from '../../vfx-item';
+import { BaseRenderComponent } from '../../components';
+/**
+ * 用于创建 textItem 的数据类型, 经过处理后的 spec.TextContentOptions
+ */
+export interface TextItemProps extends Omit<spec.TextContent, 'renderer'> {
+    listIndex?: number;
+    renderer: {
+        mask: number;
+        texture: Texture;
+    } & Omit<spec.RendererOptions, 'texture'>;
+}
 export declare const DEFAULT_FONTS: string[];
 export interface TextComponent extends TextComponentBase {
 }
 /**
  * @since 2.0.0
  */
-export declare class TextComponent extends SpriteComponent {
+export declare class TextComponent extends BaseRenderComponent {
     isDirty: boolean;
     /**
      * 文本行数
      */
     lineCount: number;
-    constructor(engine: Engine, props?: spec.TextContent);
+    constructor(engine: Engine, props?: TextItemProps);
     onUpdate(dt: number): void;
-    fromData(data: SpriteItemProps): void;
+    fromData(data: TextItemProps): void;
     updateWithOptions(options: spec.TextContentOptions): void;
     updateTexture(flipY?: boolean): void;
 }

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

@@ -0,0 +1,3 @@
+export * from './track';
+export * from './tracks';
+export * from './playable-assets';

package/dist/plugins/timeline/playable-assets/color-property-playable-asset.d.ts

@@ -0,0 +1,7 @@
+import type { Playable, PlayableGraph } from '../../cal/playable-graph';
+import { PlayableAsset } from '../../cal/playable-graph';
+import * as spec from '@galacean/effects-specification';
+export declare class ColorPropertyPlayableAsset extends PlayableAsset {
+    curveData: spec.ColorCurveData;
+    createPlayable(graph: PlayableGraph): Playable;
+}