@galacean/effects-core 1.2.3 → 2.0.0-alpha.1

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

@@ -1,7 +1,9 @@
 import type * as spec from '@galacean/effects-specification';
 import type { vec4 } from '@galacean/effects-specification';
 import type { Camera } from '../camera';
-import type { Mesh, MeshDestroyOptions, Renderer } from '../render';
+import type { RendererComponent } from '../components';
+import type { Engine } from '../engine';
+import type { MeshDestroyOptions, Renderer } from '../render';
 import { FrameBuffer } from '../render';
 import type { SemanticGetter } from '../semantic-map';
 import { SemanticMap } from '../semantic-map';
@@ -11,7 +13,6 @@ import type { Disposable, Sortable } from '../utils';
 import { DestroyOptions, OrderType } from '../utils';
 import type { RenderBuffer } from './render-buffer';
 import type { RenderingData } from './render-frame';
-import type { Engine } from '../engine';
 export declare const RenderPassPriorityPrepare = 0;
 export declare const RenderPassPriorityNormal = 1000;
 export declare const RenderPassPriorityPostprocess = 3000;
@@ -157,13 +158,13 @@ export interface RenderPassDelegate {
      * @param mesh - 当前 Mesh
      * @param state - 当前渲染状态
      */
-    willRenderMesh?: (mesh: Mesh, state: RenderingData) => void;
+    willRenderMesh?: (mesh: RendererComponent, state: RenderingData) => void;
     /**
      * Mesh 渲染后回调
      * @param mesh - 当前 Mesh
      * @param state - 当前渲染状态
      */
-    didRenderMesh?: (mesh: Mesh, state: RenderingData) => void;
+    didRenderMesh?: (mesh: RendererComponent, state: RenderingData) => void;
 }
 /**
  * RenderPass Attachment 选项
@@ -184,7 +185,7 @@ export interface RenderPassAttachmentOptions {
 }
 export interface RenderPassOptions extends RenderPassAttachmentOptions {
     name?: string;
-    meshes?: Mesh[];
+    meshes?: RendererComponent[];
     priority?: number;
     meshOrder?: OrderType;
     clearAction?: RenderPassClearAction;
@@ -216,7 +217,7 @@ export declare class RenderPass implements Disposable, Sortable {
     /**
      * 包含的 Mesh 列表
      */
-    readonly meshes: Mesh[];
+    readonly meshes: RendererComponent[];
     /**
      * Mesh 渲染顺序，按照优先级升序或降序
      */
@@ -255,13 +256,13 @@ export declare class RenderPass implements Disposable, Sortable {
     get viewport(): spec.vec4;
     get stencilAttachment(): RenderPassDepthStencilAttachment | undefined;
     get depthAttachment(): RenderPassDepthStencilAttachment | undefined;
-    addMesh(mesh: Mesh): void;
-    removeMesh(mesh: Mesh): void;
-    setMeshes(meshes: Mesh[]): Mesh[];
+    addMesh(mesh: RendererComponent): void;
+    removeMesh(mesh: RendererComponent): void;
+    setMeshes(meshes: RendererComponent[]): RendererComponent[];
     /**
      * 获取当前 Attachment 数组，注意 RenderPass 可能没有创建完成
      */
-    getInitAttachments(): RenderTargetHandle[] | RenderPassColorAttachmentOptions[] | undefined;
+    getInitAttachments(): RenderPassColorAttachmentOptions[] | RenderTargetHandle[] | undefined;
     /**
      * 配置当前pass的RT，在每帧渲染前调用
      */

package/dist/render/renderer.d.ts

@@ -1,13 +1,13 @@
 import type { Matrix4 } from '@galacean/effects-math/es/core/index';
+import type { RendererComponent } from '../components/renderer-component';
+import type { Engine } from '../engine';
+import type { Material } from '../material';
 import type { LostHandler, RestoreHandler } from '../utils';
 import type { FilterMode, FrameBuffer, RenderTextureFormat } from './frame-buffer';
-import type { Mesh } from './mesh';
+import type { Geometry } from './geometry';
 import type { RenderFrame, RenderingData } from './render-frame';
 import type { RenderPassClearAction, RenderPassStoreAction } from './render-pass';
 import type { ShaderLibrary } from './shader';
-import type { Geometry } from './geometry';
-import type { Material } from '../material';
-import type { Engine } from '../engine';
 export declare class Renderer implements LostHandler, RestoreHandler {
     static create: (canvas: HTMLCanvasElement | OffscreenCanvas, framework: 'webgl' | 'webgl2', renderOptions?: WebGLContextAttributes) => Renderer;
     engine: Engine;
@@ -55,7 +55,7 @@ export declare class Renderer implements LostHandler, RestoreHandler {
      */
     getShaderLibrary(): ShaderLibrary | undefined;
     renderRenderFrame(renderFrame: RenderFrame): void;
-    renderMeshes(meshes: Mesh[]): void;
+    renderMeshes(meshes: RendererComponent[]): void;
     drawGeometry(geometry: Geometry, material: Material): void;
     getTemporaryRT(name: string, width: number, height: number, depthBuffer: number, filter: FilterMode, format: RenderTextureFormat): FrameBuffer | null;
     dispose(haltGL?: boolean): void;

package/dist/render/shader.d.ts

@@ -1,3 +1,5 @@
+import { EffectsObject } from '../effects-object';
+import type { Engine } from '../engine';
 export type ShaderMarcos = [key: string, value: string | number | boolean][];
 export declare enum ShaderCompileResultStatus {
     noShader = 0,
@@ -40,7 +42,7 @@ export interface InstancedShaderWithSource {
     /**
      * shader是否共享
      */
-    shared?: false;
+    shared?: boolean;
 }
 export interface SharedShaderWithSource {
     /**
@@ -69,22 +71,23 @@ export interface SharedShaderWithSource {
      * 如果提供了cacheId，cacheId相同的shader会共用一个GLProgram
      * 如果没有提供cacheId，会根据字符串hash计算出cacheId，字符串相同的shader将会使用同一个GLProgram
      */
-    shared?: true;
+    shared?: boolean;
     /**
      * 相同cacheId的shader会使用同一个GLProgram
      */
     cacheId?: string;
 }
 export type ShaderWithSource = InstancedShaderWithSource | SharedShaderWithSource;
-export declare abstract class Shader {
+export declare abstract class Shader extends EffectsObject {
     readonly source: ShaderWithSource;
-    constructor(source: ShaderWithSource);
+    constructor(engine: Engine, source: ShaderWithSource);
 }
 export interface ShaderLibrary {
     readonly shaderResults: {
         [cacheId: string]: ShaderCompileResult;
     };
     addShader(shader: ShaderWithSource): void;
+    createShader(shaderSource: ShaderWithSource): Shader;
     /**
      * @param cacheId
      */

package/dist/semantic-map.d.ts

@@ -8,7 +8,7 @@ export declare class SemanticMap implements Disposable {
     constructor(semantics?: Record<string, SemanticGetter>);
     toObject(): Record<string, SemanticGetter>;
     setSemantic(name: string, value?: SemanticGetter): void;
-    getSemanticValue(name: string, state: RenderingData): number | Float32Array | Int32Array | Float64Array | Uint8Array | Uint32Array | Uint16Array | Int8Array | Int16Array | number[] | number[][] | import("@galacean/effects-math/es").Matrix4 | import("@galacean/effects-math/es").Vector3 | import("@galacean/effects-math/es").Matrix3 | import("./texture").Texture | import("@galacean/effects-math/es").Vector2 | import("@galacean/effects-math/es").Vector4 | import("./texture").Texture[] | import("./material").UniformStruct | import("./material").UniformStruct[] | SemanticFunc | undefined;
+    getSemanticValue(name: string, state: RenderingData): number | Float32Array | Int32Array | Float64Array | Uint8Array | Uint32Array | Uint16Array | Int8Array | Int16Array | number[] | number[][] | import("@galacean/effects-math/es/core").Vector3 | import("./texture").Texture | import("@galacean/effects-math/es/core").Vector2 | import("@galacean/effects-math/es/core").Vector4 | import("@galacean/effects-math/es/core").Matrix3 | import("@galacean/effects-math/es/core").Matrix4 | import("./texture").Texture[] | import("./material").UniformStruct | import("./material").UniformStruct[] | SemanticFunc | undefined;
     hasSemanticValue(name: string): boolean;
     dispose(): void;
 }

package/dist/serialization-helper.d.ts

@@ -0,0 +1,15 @@
+import { EffectsObject } from './effects-object';
+export declare class SerializationHelper {
+    static collectSerializableObject(effectsObject: EffectsObject, res: Record<string, EffectsObject>): void;
+    static serializeEffectObject(effectsObject: EffectsObject): Record<string, any>;
+    static serializeTaggedProperties(effectsObject: EffectsObject, serializedData?: Record<string, any>): Record<string, any>;
+    static deserializeTaggedProperties(serializedData: Record<string, any>, effectsObject: EffectsObject): void;
+    static deserializeTaggedPropertiesAsync(serializedData: Record<string, any>, effectsObject: EffectsObject): Promise<void>;
+    static checkTypedArray(obj: any): boolean;
+    static checkDataPath(value: any): boolean;
+    static checkGLTFNode(value: any): boolean;
+    private static deserializeProperty;
+    private static deserializePropertyAsync;
+    private static serializeObjectProperty;
+    private static serializeArrayProperty;
+}

package/dist/texture/texture.d.ts

@@ -1,10 +1,11 @@
 import { TextureSourceType } from './types';
 import type { TextureFactorySourceFrom, TextureSourceOptions, TextureDataType } from './types';
 import type { Engine } from '../engine';
+import { EffectsObject } from '../effects-object';
 /**
  * Texture 抽象类
  */
-export declare abstract class Texture {
+export declare abstract class Texture extends EffectsObject {
     /**
      * Texture 名称
      */
@@ -12,7 +13,6 @@ export declare abstract class Texture {
     sourceFrom?: TextureFactorySourceFrom;
     sourceType?: TextureSourceType;
     source: TextureSourceOptions;
-    engine: Engine;
     /**
      * Texture 高度
      */
@@ -30,14 +30,14 @@ export declare abstract class Texture {
     /**
      * 创建一个新的 Texture 对象。
      */
-    static create: (engine: Engine, options: TextureSourceOptions) => Texture;
+    static create: (engine: Engine, options?: TextureSourceOptions) => Texture;
     /**
      * 通过数据创建 Texture 对象。
      * @param data - 要创建的 Texture 数据
      * @param options - 可选的 Texture 选项
      */
     static createWithData: (engine: Engine, data?: TextureDataType, options?: Record<string, any>) => Texture;
-    constructor();
+    constructor(engine: Engine);
     get isDestroyed(): boolean;
     /**
      * 获取 Texture 的宽度。

package/dist/ticker.d.ts

@@ -9,7 +9,12 @@ export declare class Ticker {
     private interval;
     private intervalId;
     private resetTickers;
+    private _deltaTime;
     constructor(fps?: number);
+    /**
+     * 获取定时器当前帧更新的时间
+     */
+    get deltaTime(): number;
     /**
      * FPS 帧率设置
      */

package/dist/transform.d.ts

@@ -1,13 +1,15 @@
+import { Euler, Matrix4, Quaternion, Vector2, Vector3 } from '@galacean/effects-math/es/core/index';
 import type * as spec from '@galacean/effects-specification';
-import { Vector3, Matrix4, Quaternion, Euler } from '@galacean/effects-math/es/core/index';
 import type { Disposable } from './utils';
+import type { Engine } from './engine';
 export interface TransformProps {
     position?: spec.vec3 | Vector3;
     rotation?: spec.vec3 | Euler;
     quat?: spec.vec4 | Quaternion;
     scale?: spec.vec3 | Vector3;
+    size?: Vector2;
     name?: string;
-    anchor?: spec.vec2 | spec.vec3 | Vector3;
+    anchor?: spec.vec2 | Vector2;
     valid?: boolean;
 }
 export declare class Transform implements Disposable {
@@ -18,7 +20,9 @@ export declare class Transform implements Disposable {
      * @returns
      */
     static getRotation(quat: Quaternion, out: Euler): Euler;
+    engine: Engine;
     name: string;
+    taggedProperties: Record<string, any>;
     /**
      * 自身位移
      */
@@ -39,6 +43,10 @@ export declare class Transform implements Disposable {
      * 自身锚点
      */
     readonly anchor: Vector3;
+    /**
+     * 元素矩形宽高
+     */
+    readonly size: Vector2;
     /**
      * 子变换，可以有多个
      */
@@ -113,6 +121,7 @@ export declare class Transform implements Disposable {
      * @param z
      */
     setScale(x: number, y: number, z: number): void;
+    setSize(x: number, y: number): void;
     /**
      * 在当前旋转的基础上使用四元素添加旋转
      * @param quat
@@ -129,9 +138,8 @@ export declare class Transform implements Disposable {
      * 设置锚点
      * @param x
      * @param y
-     * @param z
      */
-    setAnchor(x: number, y: number, z: number): void;
+    setAnchor(x: number, y: number): void;
     /**
      * 批量设置 transform 属性
      * @param props - 要设置的属性
@@ -195,9 +203,9 @@ export declare class Transform implements Disposable {
     getWorldRotation(): Euler;
     /**
      * 根据世界变换矩阵计算位移、旋转、缩放向量
-     * @param  position
-     * @param  quat
-     * @param  scale
+     * @param position
+     * @param quat
+     * @param scale
      */
     assignWorldTRS(position?: Vector3, quat?: Quaternion, scale?: Vector3): void;
     /**
@@ -215,6 +223,8 @@ export declare class Transform implements Disposable {
      * 获取 Transform 是否生效
      */
     getValid(): boolean;
+    toData(): Record<string, any>;
+    fromData(data: any): void;
     dispose(): void;
     private updateTRSCache;
     private dispatchValueChange;

package/dist/utils/asserts.d.ts

@@ -1,2 +1,2 @@
-export declare function assertExist<T>(item: T | void | undefined | null, msg?: string): asserts item is T;
+export declare function assertExist<T>(item?: T | void | null, msg?: string): asserts item is T;
 export declare function asserts(condition: any, msg?: string): asserts condition;

package/dist/utils/index.d.ts

@@ -66,3 +66,4 @@ export declare function isObject(obj: any): boolean;
 export declare function deepClone(obj: any): any;
 export declare function random(min: number, max: number): number;
 export declare function throwDestroyedError(): void;
+export declare function generateGUID(): string;

package/dist/utils/timeline-component.d.ts

@@ -1,39 +1,6 @@
-import * as spec from '@galacean/effects-specification';
-import type { ValueGetter } from '../math';
-import type { Transform } from '../transform';
-import type { VFXItem } from '../vfx-item';
-import type { SpriteItemOptions, ItemBasicTransform, ItemLinearVelOverLifetime, SpriteRenderData } from '../plugins';
+import type * as spec from '@galacean/effects-specification';
 export interface TimelineComponentOptions {
     sizeOverLifetime?: spec.SizeOverLifetime;
     rotationOverLifetime?: spec.RotationOverLifetime;
     positionOverLifetime?: spec.PositionOverLifetime;
 }
-export declare class TimelineComponent {
-    options: Omit<SpriteItemOptions, 'delay'>;
-    sizeSeparateAxes: boolean;
-    speedOverLifetime?: ValueGetter<number>;
-    basicTransform: ItemBasicTransform;
-    gravityModifier: ValueGetter<number>;
-    readonly transform: Transform;
-    readonly linearVelOverLifetime: ItemLinearVelOverLifetime;
-    readonly orbitalVelOverLifetime: {
-        x?: ValueGetter<number>;
-        y?: ValueGetter<number>;
-        z?: ValueGetter<number>;
-        center: [x: number, y: number, z: number];
-        asRotation?: boolean;
-        enabled?: boolean;
-    };
-    private velocity;
-    private readonly rotationOverLifetime;
-    private readonly sizeXOverLifetime;
-    private readonly sizeYOverLifetime;
-    private readonly sizeZOverLifetime;
-    private readonly positionOverLifetime;
-    constructor(options: TimelineComponentOptions, ownerItem: VFXItem<any>);
-    private getVelocity;
-    private willTranslate;
-    updatePosition(x: number, y: number, z: number): void;
-    updateRotation(x: number, y: number, z: number): void;
-    getRenderData(_time: number, init?: boolean): SpriteRenderData;
-}

package/dist/vfx-item.d.ts

@@ -1,14 +1,20 @@
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
 import * as spec from '@galacean/effects-specification';
-import { Vector3 } from '@galacean/effects-math/es/core/index';
-import type { Disposable } from './utils';
-import { Transform } from './transform';
-import type { HitTestBoxParams, HitTestCustomParams, HitTestSphereParams, HitTestTriangleParams, ParticleSystem, SpriteItem, CalculateItem, CameraController, InteractItem, BoundingBoxData, SpriteRenderData, ParticleVFXItem, FilterSpriteVFXItem, SpriteVFXItem, CameraVFXItem } from './plugins';
+import { RendererComponent } from './components';
+import type { Component } from './components/component';
+import { ItemBehaviour } from './components/component';
 import type { Composition } from './composition';
-import type { CompVFXItem } from './comp-vfx-item';
-export type VFXItemContent = ParticleSystem | SpriteItem | CalculateItem | CameraController | InteractItem | void;
-export type VFXItemConstructor = new (props: VFXItemProps, composition: Composition) => VFXItem<VFXItemContent>;
+import { type VFXItemData } from './asset-loader';
+import { EffectsObject } from './effects-object';
+import type { Engine } from './engine';
+import type { BoundingBoxData, CameraController, HitTestBoxParams, HitTestCustomParams, HitTestSphereParams, HitTestTriangleParams, InteractComponent, ParticleSystem, SpriteComponent } from './plugins';
+import { TimelineComponent } from './plugins';
+import { Transform } from './transform';
+import { type Disposable } from './utils';
+export type VFXItemContent = ParticleSystem | SpriteComponent | TimelineComponent | CameraController | InteractComponent | void | {};
+export type VFXItemConstructor = new (enigne: Engine, props: VFXItemProps, composition: Composition) => VFXItem<VFXItemContent>;
 export type VFXItemProps = spec.Item & {
-    items: any;
+    items: VFXItemProps[];
     startTime: number;
     relative?: boolean;
     listIndex?: number;
@@ -17,7 +23,7 @@ export type VFXItemProps = spec.Item & {
 /**
  * 所有元素的继承的抽象类
  */
-export declare abstract class VFXItem<T extends VFXItemContent> implements Disposable {
+export declare class VFXItem<T extends VFXItemContent> extends EffectsObject implements Disposable {
     /**
      * 元素绑定的父元素，
      * 1. 当元素没有绑定任何父元素时，parent为空，transform.parentTransform 为 composition.transform
@@ -26,6 +32,7 @@ export declare abstract class VFXItem<T extends VFXItemContent> implements Dispo
      * 4. 当元素绑定 TreeItem 本身时，行为表现和绑定 nullItem 相同
      */
     parent?: VFXItem<VFXItemContent>;
+    children: VFXItem<VFXItemContent>[];
     /**
      * 元素的变换包含位置、旋转、缩放。
      */
@@ -49,7 +56,7 @@ export declare abstract class VFXItem<T extends VFXItemContent> implements Dispo
     /**
      * 元素动画的开始时间
      */
-    delay?: number;
+    start: number;
     /**
      * 元素动画结束时行为（如何处理元素）
      */
@@ -61,27 +68,33 @@ export declare abstract class VFXItem<T extends VFXItemContent> implements Dispo
     /**
      * 元素在合成中的索引
      */
-    readonly listIndex: number;
+    listIndex: number;
     /**
      * 元素名称
      */
-    readonly name: string;
+    name: string;
     /**
      * 元素 id 唯一
      */
-    readonly id: string;
+    id: string;
+    oldId: number;
     /**
-     * 元素动画是否开始
+     * 元素创建的数据图层/粒子/模型等
      */
-    started: boolean;
+    _content?: T;
     /**
-     * 元素优先级
+     * 元素动画是否延迟播放
      */
-    _v_priority: number;
+    delaying: boolean;
     /**
-     * 元素创建的数据图层/粒子/模型等
+     * 元素动画的速度
      */
-    protected _content?: T;
+    type: spec.ItemType;
+    stopped: boolean;
+    props: VFXItemProps;
+    components: Component[];
+    itemBehaviours: ItemBehaviour[];
+    rendererComponents: RendererComponent[];
     /**
      * 元素可见性，该值的改变会触发 `handleVisibleChanged` 回调
      * @protected
@@ -92,77 +105,23 @@ export declare abstract class VFXItem<T extends VFXItemContent> implements Dispo
      * @protected
      */
     protected _contentVisible: boolean;
-    /**
-     * 合成元素当前的时间，单位毫秒
-     * @protected
-     */
-    protected timeInms: number;
-    /**
-     * 合成元素当前的时间，单位秒，兼容旧 player 使用秒的时间更新数据
-     * @protected
-     */
-    protected time: number;
-    /**
-     * 元素动画持续时间，单位毫秒
-     */
-    protected readonly durInms: number;
-    /**
-    * 元素动画延迟/开始播放时间，单位毫秒
-    */
-    protected readonly delayInms: number;
-    /**
-     * 元素动画是否延迟播放
-     */
-    protected delaying: boolean;
-    /**
-     * 元素冻结属性，冻结后停止计算/更新数据
-     */
-    private _frozen;
-    /**
-     * 元素动画结束回调是否被调用
-     */
-    private callEnd;
-    /**
-     * 元素动画的速度
-     */
     private speed;
-    static isComposition(item: VFXItem<VFXItemContent>): item is CompVFXItem;
-    static isSprite(item: VFXItem<VFXItemContent>): item is SpriteVFXItem;
-    static isParticle(item: VFXItem<VFXItemContent>): item is ParticleVFXItem;
-    static isFilterSprite(item: VFXItem<VFXItemContent>): item is FilterSpriteVFXItem;
+    static isComposition(item: VFXItem<VFXItemContent>): item is VFXItem<void>;
+    static isSprite(item: VFXItem<VFXItemContent>): item is VFXItem<SpriteComponent>;
+    static isParticle(item: VFXItem<VFXItemContent>): item is VFXItem<ParticleSystem>;
     static isNull(item: VFXItem<VFXItemContent>): item is VFXItem<void>;
     static isTree(item: VFXItem<VFXItemContent>): item is VFXItem<void>;
     static isCamera(item: VFXItem<VFXItemContent>): item is VFXItem<void>;
-    static isExtraCamera(item: VFXItem<VFXItemContent>): item is CameraVFXItem;
-    constructor(props: VFXItemProps, composition: Composition);
-    /**
-     * 元素内容可见性
-     */
-    get contentVisible(): boolean;
+    static isExtraCamera(item: VFXItem<VFXItemContent>): item is VFXItem<CameraController>;
+    constructor(engine: Engine, props?: VFXItemProps);
     /**
      * 返回元素创建的数据
      */
     get content(): T;
-    /**
-     * 设置元素数据
-     */
-    set content(t: T);
     /**
      * 播放完成后是否需要再使用，是的话生命周期结束后不会 dispose
      */
     get reusable(): boolean;
-    /**
-     * 获取元素类型
-     */
-    get type(): spec.ItemType | string;
-    /**
-     * 获取元素冻结属性
-     */
-    get frozen(): boolean;
-    /**
-     * 设置元素冻结属性
-     */
-    set frozen(v: boolean);
     /**
      * 获取元素生命周期是否开始
      */
@@ -178,59 +137,27 @@ export declare abstract class VFXItem<T extends VFXItemContent> implements Dispo
      */
     getSpeed(): number;
     /**
-     * 重置元素状态属性
+     * 添加组件
+     * @param classConstructor - 要添加的组件类型
      */
-    start(): void;
+    addComponent<T extends Component>(classConstructor: new (engine: Engine) => T): T;
     /**
-     * 停止播放元素动画
+     * 获取某一类型的组件。如果当前元素绑定了多个同类型的组件只返回第一个
+     * @param classConstructor - 要获取的组件类型
+     * @returns 查询结果中符合类型的第一个组件
      */
-    stop(): void;
-    doStop(): void;
+    getComponent<T extends Component>(classConstructor: new (engine: Engine) => T): T | undefined;
     /**
-     * 创建元素内容，此函数可以在任何时间被调用
-     * 第一帧渲染前会被调用
-     * @returns
+     * 获取某一类型的所有组件
+     * @param classConstructor - 要获取的组件
+     * @returns 一个组件列表，包含所有符合类型的组件
      */
-    createContent(): T;
+    getComponents<T extends Component>(classConstructor: new (engine: Engine) => T): T[];
+    setParent(vfxItem: VFXItem<VFXItemContent>): void;
     /**
-     * 创建元素的内容
-     * @override
-     * @param composition
-     * @returns
-     */
-    protected doCreateContent(composition: Composition | null): T;
-    /**
-     * 元素构造函数调用时将调用该函数
-     * @param options
-     * @override
-     */
-    onConstructed(options: spec.Item): void;
-    /**
-     * 内部使用的更新回调，请不要重写此方法，重写 `onItemUpdate` 方法
-     * @param deltaTime
-     */
-    onUpdate(deltaTime: number): void;
-    /**
-     * 元素结束时的回调
-     * @override
-     * @param composition
-     * @param content
-     */
-    protected onItemRemoved(composition: Composition, content?: T): void;
-    /**
-     * 元素更新函数，在 Composition 对象的 tick 函数中被调用
-     * @override
-     * @param dt
-     * @param lifetime
-     */
-    onItemUpdate(dt: number, lifetime: number): void;
-    /**
-     * 元素 doCreateContent 函数调用后会立即调用该函数用于初始化数据
-     * @override
-     * @param composition
-     * @param content
+     * 停止播放元素动画
      */
-    onLifetimeBegin(composition: Composition, content: T): void;
+    stop(): void;
     /**
      * 元素动画结束播放时回调函数
      * @override
@@ -258,18 +185,6 @@ export declare abstract class VFXItem<T extends VFXItemContent> implements Dispo
      * 设置元素显隐属性 会触发 `handleVisibleChanged` 回调
      */
     setVisible(visible: boolean): void;
-    /**
-     * 元素显隐属性改变时调用的函数，当 visible 为 true 时，务必显示元素
-     * @param visible
-     * @override
-     */
-    protected handleVisibleChanged(visible: boolean): void;
-    /**
-     * 元素冻结属性改变时调用的函数
-     * @param frozen
-     * @override
-     */
-    protected handleFrozenChanged(frozen: boolean): void;
     /**
      * 获取元素变换包括位置、旋转、缩放
      * @param transform 将元素变换拷贝到该对象，并将其作为返回值
@@ -321,11 +236,6 @@ export declare abstract class VFXItem<T extends VFXItemContent> implements Dispo
      * @param force 元素没有开启交互也返回参数
      */
     getHitTestParams(force?: boolean): void | HitTestBoxParams | HitTestTriangleParams | HitTestSphereParams | HitTestCustomParams;
-    /**
-     * 获取元素的 transform、当前生命周期、可见性，当子元素需要时可继承
-     * @override
-     */
-    getRenderData(): SpriteRenderData;
     /**
      * 获取元素当前世界坐标
      */
@@ -335,16 +245,16 @@ export declare abstract class VFXItem<T extends VFXItemContent> implements Dispo
      * @param now
      * @returns
      */
-    protected isEnded(now: number): boolean;
-    /**
-     * 重置元素，元素创建的内容将会被销毁
-     */
-    reset(): void;
+    isEnded(now: number): boolean;
+    find(name: string): VFXItem<VFXItemContent> | undefined;
+    fromData(data: VFXItemData): void;
+    toData(): void;
     translateByPixel(x: number, y: number): void;
     /**
      * 销毁元素
      */
     dispose(): void;
+    private resetChildrenParent;
 }
 export declare namespace Item {
     function is<T extends spec.Item>(item: spec.Item, type: spec.ItemType): item is T;
@@ -354,7 +264,7 @@ export declare namespace Item {
     function isNull(item: spec.Item): item is spec.NullItem;
 }
 /**
- * 根据元素的类型创建对应的 `VFXItem` 实例
+ * (待废弃) 根据元素的类型创建对应的 `VFXItem` 实例
  * @param props
  * @param composition
  */