@galacean/effects-core 0.0.0-experimental-downgrade624-20240904

package/LICENSE

@@ -0,0 +1,22 @@
+MIT LICENSE
+
+Copyright (c) 2019-present Ant Group Co., Ltd. https://www.antgroup.com/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,152 @@
+# 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).
+
+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`.
+
+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.
+
+## Process
+### 1. Resource Loading and Creation
+- Asset Download [AssetManager](./src/asset-manager.ts): Before playing the animation, JSON data along with binary resources (`processBins`) and image resources (`processImages`) are downloaded. Upon completion of image downloads, parameters for creating textures (`Texture`) are returned. In addition to basic resource downloading functionality, the following features are supported:
+  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.
+
+### 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.
+
+- [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`:
+     - For compositions without filter elements, the engine can manage all meshes through the `defRenderPass`, or it can directly place the passed-in mesh into its own scene. The engine can also organize and manage the meshes as required.
+     - For compositions with filter elements involving post-processing, the effects-core will call the `splitDefaultRenderPassByMesh` function to split the `renderPass` using the splitting parameters. In this case, the engine needs to iterate over `renderFrame._renderPasses` to retrieve meshes and add them to the scene.
+     - When adding a mesh, the common uniforms used by the material can be obtained through `mesh.material.uniformSemantics`, including matrices related to MVP transformations and the attachments used.
+  2. `setEditorTransformUniform`: This method is used to set the translation/scaling transformation of an element after model transformation. The engine may not necessarily understand this concept but can set the value to `semantics[EDITOR_TRANSFORM]`.
+- [RenderPass](./src/render/render-pass.ts): The meshes added to the scene can be obtained through `renderPass.meshes`. The render pass `renderPass` contains the meshes for the current pass, the operations for clearing the buffer before and after rendering, and attachments related to color, depth, and stencil. The `delegate` property is used to specify the callbacks before and after rendering for the `renderPass`, as defined in [filters](./src/filters). The engine needs to execute these callbacks before actually rendering the meshes to ensure the correct operation of the filters.
+- [Mesh](./src/render/mesh.ts): Each `VFXItem` calls the `Mesh.create()` function during initialization, passing in parameters such as geometry and material, and sets/retrieves the rendering order for the current mesh using `priority`.
+  1. The static `create` method is used to create a new `Mesh` object that the engine can render. The engine needs to add geometry, material, and other objects to the mesh here.
+     - The primitive type to be rendered can be obtained from `geometry.mode`.
+  2. The `setter` and `getter` functions for `priority` are used to set the rendering order of the current mesh. Meshes with lower `priority` values should be drawn before those with higher values.
+  3. `setVisible/getVisible` sets the visibility of the mesh.
+
+> 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 obtain the mesh corresponding to the current `VFXItem`, you can use `VFXItem.content.mesh` to retrieve it.
+
+### 3. [Geometry](./src/render/geometry.ts)
+Each `VFXItem` calls the `Geometry.create()` function during initialization, passing in the drawing type, vertex data, and index data of the element. During each frame update, new vertex data is passed to the attribute data.
+1. The static create method: It processes the passed attribute data. If the data contains the dataSource property, it indicates that the attribute shares a buffer with the data source.
+    - `size`, `offset`, and `stride` are also passed in. If the data length is 0 and the engine does not allow dynamic modification of the GPU cache length, an initialization array should be created using the `maxVertex` parameter.
+2. `setAttributeData/getAttributeData`: Sets/retrieves attribute data for the specified attribute name.
+3. `setAttributeSubData`: Sets partial attribute updates.
+4. `getIndexData/setIndexData`: Sets/retrieves index data.
+5. `setDrawCount/getDrawCount`: Sets/retrieves the draw count.
+
+Attributes involved:
+#### Sprite
+```
+1. aPoint: Float32Array - Vertex data
+2. aIndex: Float32Array - Shared buffer with aPoint
+3. Index data: Uint16Array
+```
+
+#### Particle
+```
+1. aPos: Float32Array
+2. aVel: Float32Array - Shared buffer with aPos
+3. aDirX: Float32Array - Shared buffer with aPos
+4. aDirY: Float32Array - Shared buffer with aPos
+5. aRot: Float32Array - Shared buffer with aPos
+6. aSeed: Float32Array - Shared buffer with aRot
+7. aColor: Float32Array - Shared buffer with aRot
+8. aOffset: Float32Array
+9. aSprite: Float32Array
+10. Index data: Uint16Array
+```
+
+#### Particle-trail
+```
+1. aColor: Float32Array
+2. aSeed: Float32Array - Shared buffer with aColor
+3. aInfo: Float32Array - Shared buffer with aColor
+4. aPos: Float32Array - Shared buffer with aColor
+5. aTime: Float32Array
+6. aDir: Float32Array
+7. aTrailStart: Float32Array
+8. aTrailStartIndex: Float32Array
+```
+
+### 4. [Material](./src/material/material.ts)
+Each `VFXItem` calls the `Material.create()` function during initialization, passing the shader and uniform semantics. The states and uniform data of the material are not passed in the constructor parameters but are set through functions after material creation.
+1. Static `create` method: It needs to handle the provided shader text and set the `uniformSemantics`.
+2. Implementation of `setter/getter` methods for states: The constant type passed is `glContext`, which may need to be converted to constants defined by the engine.
+3. `set[dataType]/get[dataType]` methods for uniforms: effects-core will invoke the corresponding methods based on the type of the uniform to set data.
+
+> ⚠️ Note:
+> **The related UBO calls are deprecated, and `material-data-block` does not need to be implemented.**
+
+Uniforms involved and their types:
+#### Sprite
+```
+1. uMainData: mat4
+2. uTexParams: vec4
+3. uTexOffset: vec4
+4. uSampler\[i]: sampler2D
+5. uSamplerPre: sampler2D
+6. uFeatherSampler: sampler2D
+```
+
+#### Particle
+```
+1. uSprite: vec4
+2. uParams: vec4
+3. uAcceleration: vec4
+4. uGravityModifierValue: vec4
+5. uOpacityOverLifetimeValue: vec4
+6. uRXByLifeTimeValue: vec4
+7. uRYByLifeTimeValue: vec4
+8. uRZByLifeTimeValue: vec4
+9. uLinearXByLifetimeValue: vec4
+10. uLinearYByLifetimeValue: vec4
+11. uLinearZByLifetimeValue: vec4
+12. uSpeedLifetimeValue: vec4
+13. uOrbXByLifetimeValue: vec4
+14. uOrbYByLifetimeValue: vec4
+15. uOrbZByLifetimeValue: vec4
+16. uSizeByLifetimeValue: vec4
+17. uSizeYByLifetimeValue:vec4
+18. uColorParams: vec4
+19. uFSprite: vec4
+20. uPreviewColor: vec4
+21. uVCurveValues: vec4Array
+22. uFCurveValues: vec4
+23. uFinalTarget: vec3
+24. uForceCurve: vec4
+25. uOrbCenter: vec3
+26. uTexOffset: vec2
+27. uPeriodValue: vec4
+28. uMovementValue: vec4
+29. uStrengthValue: vec4
+30. uWaveParams: vec4
+```
+
+## [API Documentation](https://galacean.antgroup.com/effects/#/api/modules_galacean_effects_core)

package/dist/asset-manager.d.ts

@@ -0,0 +1,142 @@
+import * as spec from '@galacean/effects-specification';
+import { Downloader } from './downloader';
+import type { Disposable } from './utils';
+import type { Scene } from './scene';
+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[]>;
+    /**
+     * 模板图片缩放倍数
+     * @default 1 如果图片比较糊，可以用 2（但会增大图片内存）
+     */
+    templateScale?: number;
+    /**
+     * 是否使用压缩纹理
+     */
+    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 declare class AssetManager implements Disposable {
+    private options;
+    private readonly downloader;
+    /**
+     * 相对url的基本路径
+     */
+    private baseUrl;
+    /**
+     * 图像资源，用于创建和释放GPU纹理资源
+     */
+    private assets;
+    /**
+     * 自定义文本缓存，随页面销毁而销毁
+     */
+    static fonts: Set<string>;
+    private id;
+    /**
+     * 加载超时时间
+     * @default 10
+     */
+    private timeout;
+    /**
+     * 场景加载的超时定时器
+     */
+    private timers;
+    /**
+     * 构造函数
+     * @param options - 场景加载参数
+     * @param downloader - 资源下载对象
+     */
+    constructor(options?: SceneLoadOptions, downloader?: Downloader);
+    updateOptions(options?: SceneLoadOptions): void;
+    /**
+     * 根据用户传入的参数修改场景数据
+     */
+    private updateSceneData;
+    /**
+     * 场景创建，通过 json 创建出场景对象，并进行提前编译等工作
+     * @param url - json 的 URL 链接或者 json 对象
+     * @param renderer - renderer 对象，用于获取管理、编译 shader 及 GPU 上下文的参数
+     * @param options - 扩展参数
+     * @returns
+     */
+    loadScene(url: SceneType, renderer?: Renderer, options?: {
+        env: string;
+    }): Promise<Scene>;
+    private precompile;
+    private processJSON;
+    private processBins;
+    private processFontURL;
+    private processImages;
+    private processTextures;
+    private loadJSON;
+    private loadBins;
+    private removeTimer;
+    /**
+     * 销毁方法
+     */
+    dispose(): void;
+}

package/dist/camera.d.ts

@@ -0,0 +1,183 @@
+import * as spec from '@galacean/effects-specification';
+import { Matrix4, Vector3, Euler, Quaternion } from '@galacean/effects-math/es/core/index';
+interface CameraOptionsBase {
+    /**
+     * 相机近平面
+     */
+    near: number;
+    /**
+     * 相机远平面
+     */
+    far: number;
+    /**
+     * 视锥体垂直视野角度
+     */
+    fov: number;
+    /**
+     * 视锥体的长宽比
+     */
+    aspect: number;
+    /**
+     * 相机的裁剪模式
+     */
+    clipMode: spec.CameraClipMode;
+}
+/**
+ *
+ */
+export interface CameraOptions extends CameraOptionsBase {
+    /**
+     * 相机的位置
+     */
+    position: spec.vec3;
+    /**
+     * 相机的旋转，欧拉角
+     */
+    rotation: spec.vec3;
+    /**
+     * 相机的旋转，四元数
+     */
+    quat?: spec.vec4;
+}
+export interface CameraOptionsEx extends CameraOptionsBase {
+    /**
+     * 相机的位置
+     */
+    position: Vector3;
+    /**
+     * 相机的旋转，欧拉角
+     */
+    rotation: Euler;
+    /**
+     * 相机的旋转，四元数
+     */
+    quat?: Quaternion;
+}
+/**
+ * 合成的相机对象，采用透视投影
+ */
+export declare class Camera {
+    name: string;
+    private options;
+    private viewMatrix;
+    private projectionMatrix;
+    private viewProjectionMatrix;
+    private inverseViewMatrix;
+    private inverseProjectionMatrix;
+    private inverseViewProjectionMatrix;
+    private dirty;
+    /**
+     *
+     * @param name - 相机名称
+     * @param options
+     */
+    constructor(name: string, options?: Partial<CameraOptions>);
+    /**
+     * 设置相机近平面
+     * @param near
+     */
+    set near(near: number);
+    get near(): number;
+    /**
+     * 设置相机远平面
+     * @param far
+     */
+    set far(far: number);
+    get far(): number;
+    /**
+     * 设置相机视锥体垂直视野角度
+     * @param fov
+     */
+    set fov(fov: number);
+    get fov(): number;
+    /**
+     * 设置相机视锥体的长宽比
+     * @param aspect
+     */
+    set aspect(aspect: number);
+    get aspect(): number;
+    /**
+     * 相机的裁剪模式
+     * @param clipMode
+     */
+    set clipMode(clipMode: spec.CameraClipMode | undefined);
+    get clipMode(): spec.CameraClipMode | undefined;
+    /**
+     * 设置相机的位置
+     * @param value
+     */
+    set position(value: Vector3);
+    get position(): Vector3;
+    /**
+     * 设置相机的旋转角度
+     * @param value
+     */
+    set rotation(value: Euler);
+    get rotation(): Euler;
+    /**
+     * 获取相机的视图变换矩阵
+     * @return
+     */
+    getViewMatrix(): Matrix4;
+    /**
+     * 获取视图变换的逆矩阵
+     */
+    getInverseViewMatrix(): Matrix4;
+    /**
+     * 获取相机的投影矩阵
+     * @return
+     */
+    getProjectionMatrix(): Matrix4;
+    /**
+     * 获取相机投影矩阵的逆矩阵
+     * @return
+     */
+    getInverseProjectionMatrix(): Matrix4;
+    /**
+     * 获取相机的 VP 矩阵
+     * @return
+     */
+    getViewProjectionMatrix(): Matrix4;
+    /**
+     * 获取相机 VP 矩阵的逆矩阵
+     * @return
+     */
+    getInverseViewProjectionMatrix(): Matrix4;
+    /**
+     * 根据相机的视图投影矩阵对指定模型矩阵做变换
+     * @param out - 结果矩阵
+     * @param model - 模型变换矩阵
+     */
+    getModelViewProjection(out: Matrix4, model: Matrix4): Matrix4;
+    /**
+     * 获取归一化坐标和 3D 世界坐标的换算比例
+     * @param z - 当前的位置 z
+     */
+    getInverseVPRatio(z: number): Vector3;
+    /**
+     * 设置相机的旋转四元数
+     * @param value - 旋转四元数
+     */
+    setQuat(value: Quaternion): void;
+    /**
+     * 获取相机旋转对应的四元数
+     * @returns
+     */
+    getQuat(): Quaternion;
+    /**
+     * 获取相机内部的 options
+     * @returns 相机 options
+     */
+    getOptions(): CameraOptionsEx;
+    /**
+     * 复制指定相机元素的属性到当前相机
+     * @param camera
+     */
+    copy(camera: Camera): void;
+    /**
+     * 更新相机相关的矩阵，获取矩阵前会自动调用
+     */
+    updateMatrix(): void;
+    private setRotationByQuat;
+}
+export {};

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

@@ -0,0 +1,73 @@
+import type { Ray } from '@galacean/effects-math/es';
+import * as spec from '@galacean/effects-specification';
+import { CalculateItem } from './plugins';
+import type { Region } from './plugins';
+import type { VFXItemContent, VFXItemProps } from './vfx-item';
+import { VFXItem } from './vfx-item';
+import type { Composition, CompositionHitTestOptions } from './composition';
+export interface ItemNode {
+    id: string;
+    item: VFXItem<VFXItemContent>;
+    children: ItemNode[];
+    parentId?: string;
+}
+export declare class CompVFXItem extends VFXItem<void | CalculateItem> {
+    /**
+     * 创建好的元素数组
+     */
+    items: VFXItem<VFXItemContent>[];
+    /**
+     * 根据父子关系构建的元素树
+     */
+    itemTree: ItemNode[];
+    startTime: number;
+    contentProps: any;
+    timeInms: number;
+    /**
+     * id和元素的映射关系Map，方便查找
+     */
+    readonly itemCacheMap: Map<string, ItemNode>;
+    private itemProps;
+    private freezeOnEnd;
+    private startTimeInms;
+    private itemsToRemove;
+    private tempQueue;
+    private extraCamera;
+    private refId;
+    get type(): spec.ItemType;
+    onConstructed(props: VFXItemProps): void;
+    createContent(): void;
+    protected doCreateContent(): CalculateItem;
+    onLifetimeBegin(): void;
+    doStop(): void;
+    onItemUpdate(dt: number, lifetime: number): void;
+    onItemRemoved(composition: Composition): void;
+    reset(): void;
+    handleVisibleChanged(visible: boolean): void;
+    setScale(x: number, y: number, z: number): void;
+    scale(x: number, y: number, z: number): void;
+    getUpdateTime(t: number): number;
+    removeItem(item: VFXItem<VFXItemContent>): boolean;
+    /**
+     * 设置指定元素的父元素
+     * @param item
+     * @param parentItem - 为 undefined 时表示设置父变换为合成的变换
+     */
+    setItemParent(item: VFXItem<VFXItemContent>, parentItem?: VFXItem<VFXItemContent>): void;
+    /**
+     * 获取指定元素当前时刻真正起作用的父元素, 需要在元素生命周期内获取
+     * @internal
+     * @param item - 指定元素
+     * @return 当父元素生命周期结束时，返回空
+     */
+    getItemCurrentParent(item: VFXItem<VFXItemContent>): VFXItem<VFXItemContent> | void;
+    getItemByName(name: string): VFXItem<VFXItemContent>[];
+    hitTest(ray: Ray, x: number, y: number, regions: Region[], force?: boolean, options?: CompositionHitTestOptions): Region[];
+    protected isEnded(now: number): boolean;
+    /**
+     * 构建父子树，同时保存到 itemCacheMap 中便于查找
+     */
+    private buildItemTree;
+    private getParentIdWithoutSuffix;
+    private restart;
+}

package/dist/composition-source-manager.d.ts

@@ -0,0 +1,45 @@
+import * as spec from '@galacean/effects-specification';
+import { Texture } from './texture';
+import type { Disposable } from './utils';
+import type { Scene } from './scene';
+import type { PluginSystem } from './plugin-system';
+import type { Engine } from './engine';
+import type { GlobalVolume } from './render';
+import type { VFXItemProps } from './vfx-item';
+export interface ContentOptions {
+    id: string;
+    duration: number;
+    name: string;
+    endBehavior: spec.CompositionEndBehavior;
+    items: any[];
+    camera: spec.CameraOptions;
+    startTime: number;
+    globalVolume: GlobalVolume;
+}
+/**
+ * 合成资源管理
+ */
+export declare class CompositionSourceManager implements Disposable {
+    composition?: spec.Composition;
+    refCompositions: Map<string, spec.Composition>;
+    sourceContent?: ContentOptions;
+    refCompositionProps: Map<string, VFXItemProps>;
+    renderLevel?: spec.RenderLevel;
+    pluginSystem?: PluginSystem;
+    totalTime: number;
+    imgUsage: Record<string, number[]>;
+    textures: Texture[];
+    jsonScene?: spec.JSONScene;
+    mask: number;
+    textureOptions: Record<string, any>[];
+    constructor(scene: Scene, engine: Engine);
+    private getContent;
+    private assembleItems;
+    private changeTex;
+    private addTextureUsage;
+    /**
+     * 处理蒙版和遮挡关系写入 stencil 的 ref 值
+     */
+    private processMask;
+    dispose(): void;
+}