@galacean/effects-core 2.0.0-alpha.8 → 2.0.0-beta.0

package/README.md

@@ -1,12 +1,15 @@
 # Galacean Effects Core
 
 ## Basic Concepts
-In Galacean Effects, a Composition is the unit of animation playback. It is managed by the abstract class `Composition`, which is responsible for parsing data (JSON -> VFXItem / Texture -> mesh), creating and updating render frames (`renderFrame`) and render passes (renderPass).
+The **Composition** in Galacean Effects is the unit of animation playback. The abstract class `Composition` manages the process from data parsing (JSON -> VFXItem -> mesh) to the creation, updating, and destruction of rendered frames (`renderFrame`) and render passes (`renderPass`).
 
-Each composition uses animation data for different types of elements (`VFXItems`), including camera properties, multiple layers, particles, and interactive elements. When a composition is created, it completes the creation of elements (`VFXItems`), loading and creation of animation texture maps (`Textures`), and initialization of render frames (`renderFrame`) and render passes (`renderPass`).
-At the beginning of the composition's lifecycle, the corresponding mesh is added to the default render pass (`renderPass`).
-During the lifecycle, the `Geometry` and `Material` data contained in the mesh is updated.
-When post-processing is required, the mesh is split into the appropriate `renderPass`.At the end of the lifecycle, the corresponding mesh is removed from the `renderFrame`.
+Each composition utilizes animation data from various types of elements (`VFXItem`) and their corresponding components (`Component`), including camera properties, multiple layers, particles, and interactive elements.
+
+When a composition is created, it loads various data assets, creates elements (`VFXItem`) along with their corresponding components (`Component`), and initializes animation texture maps (`Texture`), `renderFrame`, and `renderPass`.
+
+At the beginning of the lifecycle, the corresponding mesh will be added to the default `renderPass` by the composition. During the course of the lifecycle, the data within the mesh, such as `Geometry` and `Material`, will be updated.
+
+When post-processing is needed, the mesh will be broken down into the appropriate `renderPass`. After the lifecycle ends, the corresponding mesh will be removed from the `renderFrame`.
 
 To play the animation, the engine retrieves the mesh from the `renderFrame` and adds it to the scene, continuously calls the update function of the `Composition` during the rendering loop to `update` the data.
 
@@ -16,23 +19,24 @@ To play the animation, the engine retrieves the mesh from the `renderFrame` and
   1. Selective downloading of resources based on rendering levels.
   2. After loading the image, image/text replacement is performed according to the configuration, and the modified image is saved as an `imageData` object by drawing on a Canvas.
   3. Enable the gl extension `KHR_parallel_shader_compile` to compile shaders after resource loading is completed.
-- Texture Creation [Texture](./src/texture/texture.ts): `Textures` are created based on the parameters obtained from the resource download process. The current texture object may be based on one of the creation types defined in the `TextureSourceType` enumeration.
+- Asset Creation [engine](./src/engine.ts)
+The scene data loaded from the network needs to be mounted onto the `engine` object (`addPackageDatas`) to create instances through the `engine` object.
+  1. Texture Creation [Texture](./src/texture/texture.ts): The static methods `create` and `createWithData` in the `Texture` abstract class are used to create real texture objects based on the parameters returned above. The current texture objects may be based on the creation types enumerated in `TextureSourceType`.
+  2. Element Creation [VFXItem](./src/vfx-item.ts): Call `engine.createVFXItems()` to create VFXItem instances.
 
 ### 2. Animation Playback
-- [Composition](./src/composition.ts): The composition manages the data processing and rendering setup for animation playback. The `initialize` function is called to initialize the `VFXItemManager` for JSON -> VFXItem processing. Additionally, the engine needs to retrieve the mesh when appropriate through `composition.renderFrame` and add the retrieved mesh to the scene.
-  1. Static `initialize` method:
-     - The engine needs to implement the creation of `VFXItemManager`, `Composition` instances, and converting texture parameters to `Texture` usable by the engine.
-  2. In the constructor, the following functions need to be called:
-     - Plugin system `pluginSystem.initializeComposition()`.
-     - `composition.resetRenderFrame()`: Create and initialize the `renderFrame`.
-     - `composition.reset()`: Parse the animation data and initialize the state of the render instance.
-     - `composition.play()`: Start playing the composition animation.
-  3. `update` method: Used to call the `renderFrame`'s methods to add/modify/delete meshes and drive the update and vertex data, uniform variable values, etc., of `VFXItems`. The following functions need to be implemented:
-     - `updateVideo`: Update video frames for video playback.
-     - `getRendererOptions`: Return a blank `Texture` created using the data.
-     - `reloadTexture/offloadTexture`: Reload/unload textures.
-  4. The mesh or rendering objects added to the scene can be retrieved through the `renderFrame`, and the interface can be freely designed in the `Composition` according to the engine's needs.
-  5. `dispose` method: When the composition's lifecycle comes to an end, this method is called based on the termination behavior. It executes the composition's disposal callback for `VFXItem` and also destroys associated objects such as meshes and textures.
+- [Composition](./src/composition.ts): The Composition manages the data processing and rendering settings for animation playback. The engine needs to obtain the mesh through `composition.renderFrame` and add the retrieved meshes to the scene.
+  1. The constructor will invoke the following functions, which do not need to be called manually when integrating:
+     - Plugin system `pluginSystem.initializeComposition()`
+     - `composition.createRenderFrame()`: Creation and initialization of `renderFrame`
+     - `composition.reset()`: Animation data parsing and initialization of the rendering instance state such as Mesh
+     - `composition.play()`: Start playback of the composition
+  2. `update` method: This method is used to call `renderFrame` to add/modify/delete meshes, driving the update of `VFXItem` and refreshing vertex data, uniform variable values, etc. The following functions will be called and need to be implemented:
+     - `updateVideo`: Update video frames for video playback
+     - `getRendererOptions`: Return an empty `Texture` created with the data
+     - `reloadTexture/offloadTexture`: Handle the `reload` and `offload` of textures
+  3. The meshes or rendering objects added to the scene are obtained through `renderFrame`. The interface can be freely designed in `Composition` according to the needs of the engine.
+  4. `dispose` method: At the end of the composition lifecycle, this method will be called based on the termination behavior, executing the composition destruction callback of `VFXItem`, and will also destroy objects such as meshes and textures.
 
 - [RenderFrame](./src/render/render-frame.ts): The `RenderFrame` can be understood as the rendering data object corresponding to each frame of the composition. In addition to managing the `renderPass`, it also stores the camera properties and common uniform variable table (semantics) associated with the composition. The meshes corresponding to different types of elements are added and removed using `addMeshToDefaultRenderPass` and `removeMeshFromDefaultRenderPass` methods of `renderFrame`. The mesh is added to the appropriate position in the `renderPass` based on its `priority` property.
   1. `addMeshToDefaultRenderPass/removeMeshFromDefaultRenderPass`:
@@ -49,7 +53,7 @@ To play the animation, the engine retrieves the mesh from the `renderFrame` and
 
 > Tips
 >
-> - Each `spriteVFXItem` does not necessarily correspond to a single mesh. Layer elements are compared using a diff algorithm during frame updates to determine whether adjacent meshes have the same material properties, and then the meshes are split or merged accordingly.
+> - To access methods on the element component, you can use `VFXItem.getComponent(XXXComponent)`.
 > - To obtain the mesh corresponding to the current `VFXItem`, you can use `VFXItem.content.mesh` to retrieve it.
 
 ### 3. [Geometry](./src/render/geometry.ts)

package/dist/__definations__/fbeffects-object-data.d.ts

@@ -0,0 +1,28 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class FBEffectsObjectData implements flatbuffers.IUnpackableObject<FBEffectsObjectDataT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): FBEffectsObjectData;
+    static getRootAsFBEffectsObjectData(bb: flatbuffers.ByteBuffer, obj?: FBEffectsObjectData): FBEffectsObjectData;
+    static getSizePrefixedRootAsFBEffectsObjectData(bb: flatbuffers.ByteBuffer, obj?: FBEffectsObjectData): FBEffectsObjectData;
+    dataType(): string | null;
+    dataType(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    data(index: number): number | null;
+    dataLength(): number;
+    dataArray(): Uint8Array | null;
+    static startFBEffectsObjectData(builder: flatbuffers.Builder): void;
+    static addDataType(builder: flatbuffers.Builder, dataTypeOffset: flatbuffers.Offset): void;
+    static addData(builder: flatbuffers.Builder, dataOffset: flatbuffers.Offset): void;
+    static createDataVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startDataVector(builder: flatbuffers.Builder, numElems: number): void;
+    static endFBEffectsObjectData(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createFBEffectsObjectData(builder: flatbuffers.Builder, dataTypeOffset: flatbuffers.Offset, dataOffset: flatbuffers.Offset): flatbuffers.Offset;
+    unpack(): FBEffectsObjectDataT;
+    unpackTo(_o: FBEffectsObjectDataT): void;
+}
+export declare class FBEffectsObjectDataT implements flatbuffers.IGeneratedObject {
+    dataType: string | Uint8Array | null;
+    data: (number)[];
+    constructor(dataType?: string | Uint8Array | null, data?: (number)[]);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/__definations__/fbeffects-package-data.d.ts

@@ -0,0 +1,26 @@
+import * as flatbuffers from 'flatbuffers';
+import { FBEffectsObjectData, FBEffectsObjectDataT } from './fbeffects-object-data.js';
+export declare class FBEffectsPackageData implements flatbuffers.IUnpackableObject<FBEffectsPackageDataT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): FBEffectsPackageData;
+    static getRootAsFBEffectsPackageData(bb: flatbuffers.ByteBuffer, obj?: FBEffectsPackageData): FBEffectsPackageData;
+    static getSizePrefixedRootAsFBEffectsPackageData(bb: flatbuffers.ByteBuffer, obj?: FBEffectsPackageData): FBEffectsPackageData;
+    exportObjects(index: number, obj?: FBEffectsObjectData): FBEffectsObjectData | null;
+    exportObjectsLength(): number;
+    static startFBEffectsPackageData(builder: flatbuffers.Builder): void;
+    static addExportObjects(builder: flatbuffers.Builder, exportObjectsOffset: flatbuffers.Offset): void;
+    static createExportObjectsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startExportObjectsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static endFBEffectsPackageData(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static finishFBEffectsPackageDataBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;
+    static finishSizePrefixedFBEffectsPackageDataBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;
+    static createFBEffectsPackageData(builder: flatbuffers.Builder, exportObjectsOffset: flatbuffers.Offset): flatbuffers.Offset;
+    unpack(): FBEffectsPackageDataT;
+    unpackTo(_o: FBEffectsPackageDataT): void;
+}
+export declare class FBEffectsPackageDataT implements flatbuffers.IGeneratedObject {
+    exportObjects: (FBEffectsObjectDataT)[];
+    constructor(exportObjects?: (FBEffectsObjectDataT)[]);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/__definations__/fbgeometry-data.d.ts

@@ -0,0 +1,77 @@
+import * as flatbuffers from 'flatbuffers';
+import { FBSubMesh, FBSubMeshT } from './fbsub-mesh.js';
+import { FBVertexData, FBVertexDataT } from './fbvertex-data.js';
+export declare class FBGeometryData implements flatbuffers.IUnpackableObject<FBGeometryDataT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): FBGeometryData;
+    static getRootAsFBGeometryData(bb: flatbuffers.ByteBuffer, obj?: FBGeometryData): FBGeometryData;
+    static getSizePrefixedRootAsFBGeometryData(bb: flatbuffers.ByteBuffer, obj?: FBGeometryData): FBGeometryData;
+    id(): string | null;
+    id(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    name(): string | null;
+    name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    vertexData(obj?: FBVertexData): FBVertexData | null;
+    indexFormat(): number;
+    indexOffset(): number;
+    subMeshes(index: number, obj?: FBSubMesh): FBSubMesh | null;
+    subMeshesLength(): number;
+    mode(): number;
+    buffer(): string | null;
+    buffer(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    binaryData(index: number): number | null;
+    binaryDataLength(): number;
+    binaryDataArray(): Uint8Array | null;
+    boneNames(index: number): string;
+    boneNames(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;
+    boneNamesLength(): number;
+    rootBoneName(): string | null;
+    rootBoneName(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    inverseBindMatrices(index: number): number | null;
+    inverseBindMatricesLength(): number;
+    inverseBindMatricesArray(): Float32Array | null;
+    static startFBGeometryData(builder: flatbuffers.Builder): void;
+    static addId(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset): void;
+    static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset): void;
+    static addVertexData(builder: flatbuffers.Builder, vertexDataOffset: flatbuffers.Offset): void;
+    static addIndexFormat(builder: flatbuffers.Builder, indexFormat: number): void;
+    static addIndexOffset(builder: flatbuffers.Builder, indexOffset: number): void;
+    static addSubMeshes(builder: flatbuffers.Builder, subMeshesOffset: flatbuffers.Offset): void;
+    static createSubMeshesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startSubMeshesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addMode(builder: flatbuffers.Builder, mode: number): void;
+    static addBuffer(builder: flatbuffers.Builder, bufferOffset: flatbuffers.Offset): void;
+    static addBinaryData(builder: flatbuffers.Builder, binaryDataOffset: flatbuffers.Offset): void;
+    static createBinaryDataVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startBinaryDataVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addBoneNames(builder: flatbuffers.Builder, boneNamesOffset: flatbuffers.Offset): void;
+    static createBoneNamesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startBoneNamesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addRootBoneName(builder: flatbuffers.Builder, rootBoneNameOffset: flatbuffers.Offset): void;
+    static addInverseBindMatrices(builder: flatbuffers.Builder, inverseBindMatricesOffset: flatbuffers.Offset): void;
+    static createInverseBindMatricesVector(builder: flatbuffers.Builder, data: number[] | Float32Array): flatbuffers.Offset;
+    /**
+     * @deprecated This Uint8Array overload will be removed in the future.
+     */
+    static createInverseBindMatricesVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startInverseBindMatricesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static endFBGeometryData(builder: flatbuffers.Builder): flatbuffers.Offset;
+    unpack(): FBGeometryDataT;
+    unpackTo(_o: FBGeometryDataT): void;
+}
+export declare class FBGeometryDataT implements flatbuffers.IGeneratedObject {
+    id: string | Uint8Array | null;
+    name: string | Uint8Array | null;
+    vertexData: FBVertexDataT | null;
+    indexFormat: number;
+    indexOffset: number;
+    subMeshes: (FBSubMeshT)[];
+    mode: number;
+    buffer: string | Uint8Array | null;
+    binaryData: (number)[];
+    boneNames: (string)[];
+    rootBoneName: string | Uint8Array | null;
+    inverseBindMatrices: (number)[];
+    constructor(id?: string | Uint8Array | null, name?: string | Uint8Array | null, vertexData?: FBVertexDataT | null, indexFormat?: number, indexOffset?: number, subMeshes?: (FBSubMeshT)[], mode?: number, buffer?: string | Uint8Array | null, binaryData?: (number)[], boneNames?: (string)[], rootBoneName?: string | Uint8Array | null, inverseBindMatrices?: (number)[]);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/__definations__/fbsub-mesh.d.ts

@@ -0,0 +1,26 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class FBSubMesh implements flatbuffers.IUnpackableObject<FBSubMeshT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): FBSubMesh;
+    static getRootAsFBSubMesh(bb: flatbuffers.ByteBuffer, obj?: FBSubMesh): FBSubMesh;
+    static getSizePrefixedRootAsFBSubMesh(bb: flatbuffers.ByteBuffer, obj?: FBSubMesh): FBSubMesh;
+    offset(): number;
+    indexCount(): number;
+    vertexCount(): number;
+    static startFBSubMesh(builder: flatbuffers.Builder): void;
+    static addOffset(builder: flatbuffers.Builder, offset: number): void;
+    static addIndexCount(builder: flatbuffers.Builder, indexCount: number): void;
+    static addVertexCount(builder: flatbuffers.Builder, vertexCount: number): void;
+    static endFBSubMesh(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createFBSubMesh(builder: flatbuffers.Builder, offset: number, indexCount: number, vertexCount: number): flatbuffers.Offset;
+    unpack(): FBSubMeshT;
+    unpackTo(_o: FBSubMeshT): void;
+}
+export declare class FBSubMeshT implements flatbuffers.IGeneratedObject {
+    offset: number;
+    indexCount: number;
+    vertexCount: number;
+    constructor(offset?: number, indexCount?: number, vertexCount?: number);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/__definations__/fbvertex-channel.d.ts

@@ -0,0 +1,33 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class FBVertexChannel implements flatbuffers.IUnpackableObject<FBVertexChannelT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): FBVertexChannel;
+    static getRootAsFBVertexChannel(bb: flatbuffers.ByteBuffer, obj?: FBVertexChannel): FBVertexChannel;
+    static getSizePrefixedRootAsFBVertexChannel(bb: flatbuffers.ByteBuffer, obj?: FBVertexChannel): FBVertexChannel;
+    semantic(): string | null;
+    semantic(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    offset(): number;
+    format(): number;
+    dimension(): number;
+    normalize(): boolean;
+    static startFBVertexChannel(builder: flatbuffers.Builder): void;
+    static addSemantic(builder: flatbuffers.Builder, semanticOffset: flatbuffers.Offset): void;
+    static addOffset(builder: flatbuffers.Builder, offset: number): void;
+    static addFormat(builder: flatbuffers.Builder, format: number): void;
+    static addDimension(builder: flatbuffers.Builder, dimension: number): void;
+    static addNormalize(builder: flatbuffers.Builder, normalize: boolean): void;
+    static endFBVertexChannel(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createFBVertexChannel(builder: flatbuffers.Builder, semanticOffset: flatbuffers.Offset, offset: number, format: number, dimension: number, normalize: boolean): flatbuffers.Offset;
+    unpack(): FBVertexChannelT;
+    unpackTo(_o: FBVertexChannelT): void;
+}
+export declare class FBVertexChannelT implements flatbuffers.IGeneratedObject {
+    semantic: string | Uint8Array | null;
+    offset: number;
+    format: number;
+    dimension: number;
+    normalize: boolean;
+    constructor(semantic?: string | Uint8Array | null, offset?: number, format?: number, dimension?: number, normalize?: boolean);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/__definations__/fbvertex-data.d.ts

@@ -0,0 +1,27 @@
+import * as flatbuffers from 'flatbuffers';
+import { FBVertexChannel, FBVertexChannelT } from './fbvertex-channel.js';
+export declare class FBVertexData implements flatbuffers.IUnpackableObject<FBVertexDataT> {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): FBVertexData;
+    static getRootAsFBVertexData(bb: flatbuffers.ByteBuffer, obj?: FBVertexData): FBVertexData;
+    static getSizePrefixedRootAsFBVertexData(bb: flatbuffers.ByteBuffer, obj?: FBVertexData): FBVertexData;
+    vertexCount(): number;
+    channels(index: number, obj?: FBVertexChannel): FBVertexChannel | null;
+    channelsLength(): number;
+    static startFBVertexData(builder: flatbuffers.Builder): void;
+    static addVertexCount(builder: flatbuffers.Builder, vertexCount: number): void;
+    static addChannels(builder: flatbuffers.Builder, channelsOffset: flatbuffers.Offset): void;
+    static createChannelsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startChannelsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static endFBVertexData(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createFBVertexData(builder: flatbuffers.Builder, vertexCount: number, channelsOffset: flatbuffers.Offset): flatbuffers.Offset;
+    unpack(): FBVertexDataT;
+    unpackTo(_o: FBVertexDataT): void;
+}
+export declare class FBVertexDataT implements flatbuffers.IGeneratedObject {
+    vertexCount: number;
+    channels: (FBVertexChannelT)[];
+    constructor(vertexCount?: number, channels?: (FBVertexChannelT)[]);
+    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/__definations__/index.d.ts

@@ -0,0 +1,6 @@
+export { FBEffectsObjectData, FBEffectsObjectDataT } from './fbeffects-object-data.js';
+export { FBEffectsPackageData, FBEffectsPackageDataT } from './fbeffects-package-data.js';
+export { FBGeometryData, FBGeometryDataT } from './fbgeometry-data.js';
+export { FBSubMesh, FBSubMeshT } from './fbsub-mesh.js';
+export { FBVertexChannel, FBVertexChannelT } from './fbvertex-channel.js';
+export { FBVertexData, FBVertexDataT } from './fbvertex-data.js';

package/dist/asset-loader.d.ts

@@ -1,7 +1,6 @@
 import * as spec from '@galacean/effects-specification';
 import type { EffectsObject } from './effects-object';
 import type { Engine } from './engine';
-import type { ShaderMarcos } from './render';
 import type { VFXItemProps } from './vfx-item';
 /**
  * @since 2.0.0
@@ -18,18 +17,6 @@ export declare class AssetLoader {
 export declare class Database {
     loadGUID(guid: string): Promise<EffectsObject | undefined>;
 }
-export interface MaterialData extends spec.MaterialData {
-    /**
-     * shader的宏定义
-     */
-    marcos?: ShaderMarcos;
-}
-export interface GeometryData extends spec.EffectsObjectData {
-    vertexData: spec.VertexData;
-    indexFormat: number;
-    indexOffset: number;
-    buffer: string;
-}
 export interface EffectComponentData extends spec.EffectsObjectData {
     _priority: number;
     item: spec.DataPath;

package/dist/asset-manager.d.ts

@@ -1,81 +1,7 @@
-import * as spec from '@galacean/effects-specification';
 import { Downloader } from './downloader';
-import type { Scene } from './scene';
+import type { Scene, SceneLoadOptions, SceneType } from './scene';
 import type { Disposable } from './utils';
 import type { Renderer } from './render';
-/**
- * 场景加载参数
- */
-export interface SceneLoadOptions {
-    /**
-     * 动态数据的参数
-     * key 是 JSON 中配置的字段名
-     * value 是要使用的值，图片使用 url 链接
-     * 图片链接可以使用数组传递，如果第一个加载失败，将尝试使用第二个地址
-     *
-     * @example
-     * ``` ts
-     * {
-     *   variables: {
-     *     bg: ['url','fallback_url'], // 如果两个图片都失败，将会触发加载失败
-     *     fg: 'url' // 如果图片加载失败，将会触发加载失败,
-     *     amount: 88.8,
-     *     name: 'abc'
-     *   }
-     * }
-     * ```
-     */
-    variables?: Record<string, number | string | string[]>;
-    /**
-     * 是否使用压缩纹理
-     */
-    useCompressedTexture?: boolean;
-    /**
-     * 渲染分级。
-     * 分级之后，只会加载当前渲染等级的资源。
-     * 当渲染等级被设置为 B 后，player 的 fps 会降到 30 帧
-     * @default 's'
-     */
-    renderLevel?: spec.RenderLevel;
-    /**
-     * 资源加载超时，时间单位秒
-     * @default 10s
-     */
-    timeout?: number;
-    /***
-     * 用于给 plugin 的加载数据
-     * key/value 的内容由 plugin 自己实现
-     */
-    pluginData?: Record<string, any>;
-    /**
-     * 场景加载时的环境（加载后把 env 结果写入 scene）
-     * @default '' - 编辑器中为 'editor'
-     */
-    env?: string;
-    /**
-     * 加载后是否自动播放
-     * @default true
-     */
-    autoplay?: boolean;
-    /**
-     * 合成播放完成后是否需要再使用，是的话生命周期结束后不会 `dispose`
-     * @default false
-     */
-    reusable?: boolean;
-    /**
-     * 播放速度，当速度为负数时，合成倒播
-     */
-    speed?: number;
-}
-/**
- * 接受用于加载的数据类型
- */
-export type SceneType = string | Scene | Record<string, unknown>;
-export type SceneWithOptionsType = {
-    scene: SceneType;
-    options: SceneLoadOptions;
-};
-export type SceneLoadType = SceneType | SceneWithOptionsType;
 /**
  * 资源管理器
  * 用于加载和动效中所有的资源文件，包括图片、插件、图层粒子数据等

package/dist/binary-asset.d.ts

@@ -0,0 +1,6 @@
+import type { EffectsObjectData } from '@galacean/effects-specification';
+import { EffectsObject } from './effects-object';
+export declare class BinaryAsset extends EffectsObject {
+    buffer: ArrayBuffer;
+    fromData(data: EffectsObjectData): void;
+}

package/dist/camera.d.ts

@@ -1,5 +1,8 @@
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
+import { Quaternion } from '@galacean/effects-math/es/core/quaternion';
+import { Matrix4 } from '@galacean/effects-math/es/core/matrix4';
+import { Euler } from '@galacean/effects-math/es/core/euler';
 import * as spec from '@galacean/effects-specification';
-import { Matrix4, Vector3, Euler, Quaternion } from '@galacean/effects-math/es/core/index';
 interface CameraOptionsBase {
     /**
      * 相机近平面
@@ -58,6 +61,10 @@ export interface CameraOptionsEx extends CameraOptionsBase {
  */
 export declare class Camera {
     name: string;
+    /**
+     * 编辑器用于缩放画布
+     */
+    private viewportMatrix;
     private options;
     private viewMatrix;
     private projectionMatrix;
@@ -114,6 +121,8 @@ export declare class Camera {
      */
     set rotation(value: Euler);
     get rotation(): Euler;
+    setViewportMatrix(matrix: Matrix4): void;
+    getViewportMatrix(): Matrix4;
     /**
      * 获取相机的视图变换矩阵
      * @return

package/dist/canvas-pool.d.ts

@@ -0,0 +1,9 @@
+declare class CanvasPool {
+    readonly elements: HTMLCanvasElement[];
+    constructor();
+    dispose(): void;
+    getCanvas(): HTMLCanvasElement;
+    saveCanvas(canvas: HTMLCanvasElement): void;
+}
+export declare const canvasPool: CanvasPool;
+export {};

package/dist/comp-vfx-item.d.ts

@@ -1,27 +1,41 @@
 import type { Ray } from '@galacean/effects-math/es/core/ray';
-import { ItemBehaviour } from './components';
+import * as spec from '@galacean/effects-specification';
+import { Behaviour } from './components';
 import type { CompositionHitTestOptions } from './composition';
-import type { Region } from './plugins';
-import { TimelineComponent } from './plugins';
-import type { VFXItemContent } from './vfx-item';
+import type { ContentOptions } from './composition-source-manager';
+import type { Region, TrackAsset } from './plugins';
 import { VFXItem } from './vfx-item';
+export interface SceneBinding {
+    key: TrackAsset;
+    value: VFXItem;
+}
+export interface SceneBindingData {
+    key: spec.DataPath;
+    value: spec.DataPath;
+}
 /**
  * @since 2.0.0
  * @internal
  */
-export declare class CompositionComponent extends ItemBehaviour {
+export declare class CompositionComponent extends Behaviour {
+    time: number;
     startTime: number;
     refId: string;
-    items: VFXItem<VFXItemContent>[];
-    timelineComponents: TimelineComponent[];
-    timelineComponent: TimelineComponent;
+    items: VFXItem[];
+    data: ContentOptions;
+    private reusable;
+    private sceneBindings;
+    private timelineAsset;
+    private timelinePlayable;
+    private graph;
     start(): void;
+    setReusable(value: boolean): void;
+    getReusable(): boolean;
     update(dt: number): void;
-    /**
-     * 重置元素状态属性
-     */
-    resetStatus(): void;
     createContent(): void;
     onDestroy(): void;
     hitTest(ray: Ray, x: number, y: number, regions: Region[], force?: boolean, options?: CompositionHitTestOptions): Region[];
+    fromData(data: unknown): void;
+    private resolveBindings;
+    private resolveTrackBindingsWithRoot;
 }

package/dist/components/component.d.ts

@@ -1,5 +1,5 @@
 import { EffectsObject } from '../effects-object';
-import type { VFXItem, VFXItemContent } from '../vfx-item';
+import type { VFXItem } from '../vfx-item';
 /**
  * @since 2.0.0
  * @internal
@@ -9,7 +9,7 @@ export declare abstract class Component extends EffectsObject {
     /**
      * 附加到的 VFXItem 对象
      */
-    item: VFXItem<VFXItemContent>;
+    item: VFXItem;
     /**
      * 附加到的 VFXItem 对象 Transform 组件
      */
@@ -24,23 +24,14 @@ export declare abstract class Component extends EffectsObject {
  * @internal
  */
 export declare abstract class Behaviour extends Component {
-    _enabled: boolean;
+    private _enabled;
     /**
      * 组件是否可以更新，true 更新，false 不更新
      */
     get isActiveAndEnabled(): boolean;
     get enabled(): boolean;
     set enabled(value: boolean);
-    protected onBehaviourEnable(): void;
-    fromData(data: any): void;
-    toData(): void;
-}
-/**
- * @since 2.0.0
- * @internal
- */
-export declare abstract class ItemBehaviour extends Behaviour {
-    started: boolean;
+    isStartCalled: boolean;
     /**
      * 在每次设置 enabled 为 true 时触发
      */
@@ -59,5 +50,4 @@ export declare abstract class ItemBehaviour extends Behaviour {
     lateUpdate(dt: number): void;
     onAttached(): void;
     dispose(): void;
-    protected onBehaviourEnable(): void;
 }

package/dist/components/effect-component.d.ts

@@ -1,5 +1,4 @@
 import { Matrix4 } from '@galacean/effects-math/es/core/matrix4';
-import type { TriangleLike } from '@galacean/effects-math/es/core/type';
 import type { Engine } from '../engine';
 import type { Material, MaterialDestroyOptions } from '../material';
 import type { BoundingBoxTriangle, HitTestTriangleParams } from '../plugins';
@@ -12,10 +11,6 @@ import { RendererComponent } from './renderer-component';
  * @internal
  */
 export declare class EffectComponent extends RendererComponent {
-    /**
-     * Mesh 的全局唯一 id
-     */
-    readonly id: string;
     /**
      * Mesh 的世界矩阵
      */
@@ -24,27 +19,12 @@ export declare class EffectComponent extends RendererComponent {
      * Mesh 的 Geometry
      */
     geometry: Geometry;
-    triangles: TriangleLike[];
-    protected destroyed: boolean;
-    private visible;
+    private triangles;
+    private destroyed;
     private hitTestGeometry;
     constructor(engine: Engine);
-    get isDestroyed(): boolean;
-    /**
-     * 设置当前 Mesh 的可见性。
-     * @param visible - true：可见，false：不可见
-     */
-    setVisible(visible: boolean): void;
     start(): void;
     render(renderer: Renderer): void;
-    /**
-     * 获取当前 Mesh 的可见性。
-     */
-    getVisible(): boolean;
-    /**
-     * 获取当前 Mesh 的第一个 geometry。
-     */
-    firstGeometry(): Geometry;
     /**
      * 设置当前 Mesh 的材质
      * @param material - 要设置的材质
@@ -53,7 +33,7 @@ export declare class EffectComponent extends RendererComponent {
     setMaterial(material: Material, destroy?: MaterialDestroyOptions | DestroyOptions.keep): void;
     getHitTestParams: (force?: boolean) => HitTestTriangleParams | void;
     getBoundingBox(): BoundingBoxTriangle | void;
-    fromData(data: any): void;
+    fromData(data: unknown): void;
     toData(): void;
     /**
      * 销毁当前资源

package/dist/components/index.d.ts

@@ -1,3 +1,4 @@
 export * from './renderer-component';
 export * from './component';
 export * from './effect-component';
+export * from './post-process-volume';

package/dist/components/post-process-volume.d.ts

@@ -0,0 +1,15 @@
+import { Behaviour } from './component';
+export declare class PostProcessVolume extends Behaviour {
+    useHDR: boolean;
+    useBloom: boolean;
+    threshold: number;
+    bloomIntensity: number;
+    brightness: number;
+    saturation: number;
+    contrast: number;
+    vignetteIntensity: number;
+    vignetteSmoothness: number;
+    vignetteRoundness: number;
+    useToneMapping: boolean;
+    start(): void;
+}