@galacean/effects-core 2.1.0-alpha.6 → 2.1.0-alpha.7

package/dist/plugin-system.d.ts

@@ -3,8 +3,7 @@ import type { Composition } from './composition';
 import type { Plugin, PluginConstructor } from './plugins';
 import type { RenderFrame, Renderer } from './render';
 import type { Scene, SceneLoadOptions } from './scene';
-import type { VFXItemConstructor, VFXItemProps } from './vfx-item';
-import { VFXItem } from './vfx-item';
+import type { VFXItemConstructor } from './vfx-item';
 export declare const pluginLoaderMap: Record<string, PluginConstructor>;
 export declare const defaultPlugins: string[];
 export type PrecompileOptions = {
@@ -25,9 +24,12 @@ 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;
     processRawJSON(json: spec.JSONScene, options: SceneLoadOptions): Promise<void[]>;
+    processAssets(json: spec.JSONScene, options?: SceneLoadOptions): Promise<{
+        assets: spec.AssetBase[];
+        loadedAssets: unknown[];
+    }[]>;
+    precompile(compositions: spec.CompositionData[], renderer: Renderer, options?: PrecompileOptions): Promise<unknown[]>;
+    loadResources(scene: Scene, options: SceneLoadOptions): Promise<unknown[]>;
     private callStatic;
-    precompile(compositions: spec.CompositionData[], renderer: Renderer, options?: PrecompileOptions): Promise<void[]>;
-    loadResources(scene: Scene, options: SceneLoadOptions): Promise<void[]>;
 }

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

@@ -1,7 +1,8 @@
-import type { Euler, Vector3 } from '@galacean/effects-math/es/core/index';
+import type { Euler } from '@galacean/effects-math/es/core/euler';
+import type { Vector3 } from '@galacean/effects-math/es/core/vector3';
 import type { ValueGetter } from '../../math';
-import { TrackAsset } from '../timeline/track';
-import type { TimelineAsset } from './timeline-asset';
+import { TrackAsset } from '../timeline';
+import type { TimelineAsset } from '../timeline';
 /**
  * 基础位移属性数据
  */

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

@@ -1,3 +1,3 @@
-import { AbstractPlugin } from '../index';
+import { AbstractPlugin } from '../plugin';
 export declare class CalculateLoader extends AbstractPlugin {
 }

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

@@ -42,7 +42,7 @@ export declare class TransformAnimationPlayable extends AnimationPlayable {
     startSpeed: number;
     data: TransformPlayableAssetData;
     private velocity;
-    private binding;
+    private boundObject;
     start(): void;
     processFrame(context: FrameContext): void;
     /**

package/dist/plugins/camera/camera-vfx-item-loader.d.ts

@@ -1,3 +1,3 @@
-import { AbstractPlugin } from '../index';
+import { AbstractPlugin } from '../plugin';
 export declare class CameraVFXItemLoader extends AbstractPlugin {
 }

package/dist/plugins/index.d.ts

@@ -18,11 +18,5 @@ 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 './timeline/tracks/sub-composition-track';
-export * from './timeline/playables/sub-composition-playable-asset';
-export * from './cal/timeline-asset';
+export * from './timeline';
 export * from './text';

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

@@ -1,3 +1,3 @@
-import { AbstractPlugin } from '../index';
+import { AbstractPlugin } from '../plugin';
 export declare class InteractLoader extends AbstractPlugin {
 }

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

@@ -9,7 +9,6 @@ import type { Mesh } from '../../render';
 import type { ShapeGenerator, ShapeParticle } from '../../shape';
 import { Texture } from '../../texture';
 import { Transform } from '../../transform';
-import { type color } from '../../utils';
 import type { BoundingBoxSphere, HitTestCustomParams } from '../interact/click-handler';
 import { Burst } from './burst';
 import type { Point } from './particle-mesh';
@@ -24,7 +23,7 @@ type ParticleOptions = {
     startSpeed: ValueGetter<number>;
     startLifetime: ValueGetter<number>;
     startDelay: ValueGetter<number>;
-    startColor: ValueGetter<color>;
+    startColor: ValueGetter<spec.RGBAColorValue>;
     start3DRotation?: boolean;
     startRotationX?: ValueGetter<number>;
     startRotationY?: ValueGetter<number>;

package/dist/plugins/plugin.d.ts

@@ -6,7 +6,7 @@ import type { Composition } from '../composition';
 export interface Plugin {
     /**
      * plugin 的数组内排序，按照升序排列
-     * 默认为100
+     * @default 100
      */
     order: number;
     name: string;
@@ -88,7 +88,7 @@ export declare abstract class AbstractPlugin implements Plugin {
     order: number;
     name: string;
     /***
-     * player.loadScene 函数调用的时候会触发此函数，
+     * loadScene 函数调用的时候会触发此函数，
      * 此阶段可以对资源 JSON 进行处理，替换调 JSON 中的数据，或者直接终止加载流程
      * 一旦被 reject，加载过程将失败
      * @param json 动画资源
@@ -96,7 +96,18 @@ export declare abstract class AbstractPlugin implements Plugin {
      */
     static processRawJSON: (json: spec.JSONScene, options: SceneLoadOptions) => Promise<void>;
     /**
-     * player.loadScene 函数调用的时候会触发此函数，
+     * loadScene 函数调用的时候会触发此函数，
+     * 此阶段可以加载插件所需类型资源，并返回原始资源和加载后的资源。
+     * @param json
+     * @param options
+     * @returns
+     */
+    static processAssets: (json: spec.JSONScene, options?: SceneLoadOptions) => Promise<{
+        assets: spec.AssetBase[];
+        loadedAssets: unknown[];
+    }>;
+    /**
+     * loadScene 函数调用的时候会触发此函数，
      * 此阶段时，json 中的图片和二进制已经被加载完成，可以对加载好的资源做进一步处理，
      * 如果 promise 被 reject, loadScene 函数同样会被 reject，表示场景加载失败。
      * 请记住，整个 load 阶段都不要创建 GL 相关的对象，只创建 JS 对象

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

@@ -0,0 +1,79 @@
+import { ShapePrimitive } from './shape-primitive';
+/**
+ * The Ellipse object is used to help draw graphics and can also be used to specify a hit area for containers.
+ */
+export declare class Ellipse extends ShapePrimitive {
+    /**
+     * The X coordinate of the center of this ellipse
+     * @default 0
+     */
+    x: number;
+    /**
+     * The Y coordinate of the center of this ellipse
+     * @default 0
+     */
+    y: number;
+    /**
+     * The half width of this ellipse
+     * @default 0
+     */
+    halfWidth: number;
+    /**
+     * The half height of this ellipse
+     * @default 0
+     */
+    halfHeight: number;
+    /**
+     * The type of the object, mainly used to avoid `instanceof` checks
+     * @default 'ellipse'
+     */
+    readonly type = "ellipse";
+    /**
+     * @param x - The X coordinate of the center of this ellipse
+     * @param y - The Y coordinate of the center of this ellipse
+     * @param halfWidth - The half width of this ellipse
+     * @param halfHeight - The half height of this ellipse
+     */
+    constructor(x?: number, y?: number, halfWidth?: number, halfHeight?: number);
+    /**
+     * Creates a clone of this Ellipse instance
+     * @returns {Ellipse} A copy of the ellipse
+     */
+    clone(): Ellipse;
+    /**
+     * Checks whether the x and y coordinates given are contained within this ellipse
+     * @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 coords are within this ellipse
+     */
+    contains(x: number, y: number): boolean;
+    /**
+     * Checks whether the x and y coordinates given are contained within this ellipse including stroke
+     * @param x - The X coordinate of the point to test
+     * @param y - The Y coordinate of the point to test
+     * @param width
+     * @returns Whether the x/y coords are within this ellipse
+     */
+    strokeContains(x: number, y: number, width: number): boolean;
+    /**
+     * Returns the framing rectangle of the ellipse as a Rectangle object
+     * @param out
+     * @returns The framing rectangle
+     */
+    /**
+     * Copies another ellipse to this one.
+     * @param ellipse - The ellipse to copy from.
+     * @returns Returns itself.
+     */
+    copyFrom(ellipse: Ellipse): this;
+    /**
+     * Copies this ellipse to another one.
+     * @param ellipse - The ellipse to copy to.
+     * @returns Returns given parameter.
+     */
+    copyTo(ellipse: Ellipse): Ellipse;
+    getX(): number;
+    getY(): number;
+    build(points: number[]): number[];
+    triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
+}

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

@@ -2,6 +2,7 @@
  * Based on:
  * https://github.com/pixijs/pixijs/blob/dev/src/scene/graphics/shared/path/GraphicsPath.ts
  */
+import type { Matrix4 } from '@galacean/effects-math/es/core/matrix4';
 import { ShapePath } from './shape-path';
 export declare class GraphicsPath {
     instructions: PathInstruction[];
@@ -27,6 +28,7 @@ export declare class GraphicsPath {
      */
     bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, smoothness?: number): GraphicsPath;
     moveTo(x: number, y: number): GraphicsPath;
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, matrix?: Matrix4): this;
     clear(): GraphicsPath;
 }
 export interface PathInstruction {

package/dist/plugins/shape/point-like.d.ts

@@ -0,0 +1,31 @@
+import type { PointData } from './point-data';
+/**
+ * Common interface for points. Both Point and ObservablePoint implement it
+ */
+export interface PointLike extends PointData {
+    /**
+     * Copies x and y from the given point
+     * @param p - The point to copy from
+     * @returns Returns itself.
+     */
+    copyFrom: (p: PointData) => this;
+    /**
+     * Copies x and y into the given point
+     * @param p - The point to copy.fds
+     * @returns Given point with values updated
+     */
+    copyTo: <T extends PointLike>(p: T) => T;
+    /**
+     * Returns true if the given point is equal to this point
+     * @param p - The point to check
+     * @returns Whether the given point equal to this point
+     */
+    equals: (p: PointData) => boolean;
+    /**
+     * Sets the point to a new x and y position.
+     * If y is omitted, both x and y will be set to x.
+     * @param {number} [x=0] - position of the point on the x axis
+     * @param {number} [y=x] - position of the point on the y axis
+     */
+    set: (x?: number, y?: number) => void;
+}

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

@@ -0,0 +1,58 @@
+import type { PointData } from './point-data';
+import type { PointLike } from './point-like';
+/**
+ * The Point object represents a location in a two-dimensional coordinate system, where `x` represents
+ * the position on the horizontal axis and `y` represents the position on the vertical axis.
+ */
+export declare class Point implements PointLike {
+    /**
+     * Position of the point on the x axis
+     */
+    x: number;
+    /**
+     * Position of the point on the y axis
+     */
+    y: number;
+    /**
+     * Creates a new `Point`
+     * @param {number} [x=0] - position of the point on the x axis
+     * @param {number} [y=0] - position of the point on the y axis
+     */
+    constructor(x?: number, y?: number);
+    /**
+     * Creates a clone of this point
+     * @returns A clone of this point
+     */
+    clone(): Point;
+    /**
+     * Copies `x` and `y` from the given point into this point
+     * @param p - The point to copy from
+     * @returns The point instance itself
+     */
+    copyFrom(p: PointData): this;
+    /**
+     * Copies this point's x and y into the given point (`p`).
+     * @param p - The point to copy to. Can be any of type that is or extends `PointData`
+     * @returns The point (`p`) with values updated
+     */
+    copyTo<T extends PointLike>(p: T): T;
+    /**
+     * Accepts another point (`p`) and returns `true` if the given point is equal to this point
+     * @param p - The point to check
+     * @returns Returns `true` if both `x` and `y` are equal
+     */
+    equals(p: PointData): boolean;
+    /**
+     * Sets the point to a new `x` and `y` position.
+     * If `y` is omitted, both `x` and `y` will be set to `x`.
+     * @param {number} [x=0] - position of the point on the `x` axis
+     * @param {number} [y=x] - position of the point on the `y` axis
+     * @returns The point instance itself
+     */
+    set(x?: number, y?: number): this;
+    /**
+     * A static Point object with `x` and `y` values of `0`. Can be used to avoid creating new objects multiple times.
+     * @readonly
+     */
+    static get shared(): Point;
+}

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

@@ -2,14 +2,19 @@
  * 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 {
-    /** An array of the points of this polygon. */
+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`. */
+    /**
+     * `false` after moveTo, `true` after `closePath`. In all other cases it is `true`.
+     */
     closePath: boolean;
     constructor(points: PointData[] | number[]);
     constructor(...points: PointData[] | number[]);
@@ -51,10 +56,12 @@ export declare class Polygon {
      * Get the first X coordinate of the polygon
      * @readonly
      */
-    get x(): number;
+    getX(): number;
     /**
      * Get the first Y coordinate of the polygon
      * @readonly
      */
-    get y(): number;
+    getY(): number;
+    build(points: number[]): void;
+    triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
 }

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

@@ -2,15 +2,16 @@
  * Based on:
  * https://github.com/pixijs/pixijs/blob/dev/src/scene/graphics/shared/path/ShapePath.ts
  */
-import type { Matrix3 } from '@galacean/effects-math/es/core/matrix3';
+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';
 export declare class ShapePath {
     private graphicsPath;
     currentPoly: Polygon | null;
     shapePrimitives: {
-        shape: Polygon;
-        transform?: Matrix3;
+        shape: ShapePrimitive;
+        transform?: Matrix4;
     }[];
     constructor(graphicsPath: GraphicsPath);
     /** Builds the path. */
@@ -30,6 +31,27 @@ export declare class ShapePath {
      */
     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;
+    /**
+     * 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.

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

@@ -0,0 +1,18 @@
+export declare abstract class ShapePrimitive {
+    /** Checks whether the x and y coordinates passed to this function are contained within this ShapePrimitive. */
+    abstract contains(x: number, y: number): boolean;
+    /** 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 */
+    abstract getX(): number;
+    /** The Y coordinate of the shape */
+    abstract getY(): number;
+    abstract build(points: number[]): void;
+    abstract triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
+}

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

@@ -1,17 +1,14 @@
-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 type { ItemRenderer } from '../../components';
+import { BaseRenderComponent } from '../../components/base-render-component';
 /**
  * 用于创建 spriteItem 的数据类型, 经过处理后的 spec.SpriteContent
  */
@@ -27,123 +24,32 @@ 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;
+export interface SpriteItemRenderer extends ItemRenderer {
     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;