@galacean/effects-core 2.9.0-alpha.2 → 2.9.0

package/dist/material/index.d.ts

@@ -2,4 +2,5 @@ export * from './types';
 export * from './utils';
 export * from './material-data-block';
 export * from './material';
+export * from './material-state';
 export * from './mask-ref-manager';

package/dist/material/material-state.d.ts

@@ -0,0 +1,50 @@
+import type { Engine } from '../engine';
+export declare class MaterialState {
+    blending: boolean;
+    blendFunctionParameters: [blendSrc: number, blendDst: number, blendSrcAlpha: number, blendDstAlpha: number];
+    blendEquationParameters: [blendEquationRGB: number, blendEquationAlpha: number];
+    blendColor: [r: number, g: number, b: number, a: number];
+    depthTest: boolean;
+    depthMask: boolean;
+    depthRange: [zNear: number, zFar: number];
+    depthFunc: number;
+    polygonOffset: [factor: number, units: number];
+    polygonOffsetFill: boolean;
+    sampleAlphaToCoverage: boolean;
+    colorMask: [r: boolean, g: boolean, b: boolean, a: boolean];
+    stencilTest: boolean;
+    stencilMask: [front: number, back: number];
+    stencilRef: [front: number, back: number];
+    stencilFunc: [front: number, back: number];
+    stencilOpFail: [front: number, back: number];
+    stencilOpZFail: [front: number, back: number];
+    stencilOpZPass: [front: number, back: number];
+    culling: boolean;
+    frontFace: number;
+    cullFace: number;
+    constructor();
+    setBlendColor(color: [r: number, g: number, b: number, a: number]): void;
+    setBlending(value: boolean): void;
+    setBlendFunctionParameters(value: [blendSrc: number, blendDst: number, blendSrcAlpha: number, blendDstAlpha: number]): void;
+    setBlendEquationParameters(value: [rgb: number, alpha: number]): void;
+    setDepthTest(value: boolean): void;
+    setDepthMask(value: boolean): void;
+    setDepthRange(value: [zNear: number, zFar: number]): void;
+    setDepthFunc(value: number): void;
+    setPolygonOffsetFill(value: boolean): void;
+    setPolygonOffset(value: [factor: number, units: number]): void;
+    setSampleAlphaToCoverage(value: boolean): void;
+    setColorMask(colorMask: boolean): void;
+    setStencilTest(value: boolean): void;
+    setStencilMask(value: [front: number, back: number]): void;
+    setStencilRef(value: [front: number, back: number]): void;
+    setStencilFunc(value: [front: number, back: number]): void;
+    setStencilOpFail(value: [front: number, back: number]): void;
+    setStencilOpZFail(value: [front: number, back: number]): void;
+    setStencilOpZPass(value: [front: number, back: number]): void;
+    setCulling(value: boolean): void;
+    setFrontFace(value: number): void;
+    setCullFace(value: number): void;
+    reset(): void;
+    apply(engine: Engine): void;
+}

package/dist/material/material.d.ts

@@ -1,10 +1,14 @@
-import type { Matrix3, Matrix4, Quaternion, Vector2, Vector3, Vector4, Color } from '@galacean/effects-math/es/core/index';
-import type { GlobalUniforms, Renderer, Shader, ShaderVariant, ShaderWithSource } from '../render';
+import * as spec from '@galacean/effects-specification';
+import type { Color, Matrix3, Quaternion, Vector2, Vector3 } from '@galacean/effects-math/es/core/index';
+import { Vector4, Matrix4 } from '@galacean/effects-math/es/core/index';
+import type { GlobalUniforms, Renderer, ShaderVariant, ShaderWithSource } from '../render';
+import { Shader } from '../render/shader';
 import type { Texture } from '../texture';
 import type { DestroyOptions, Disposable } from '../utils';
 import type { UniformValue } from './types';
 import type { Engine } from '../engine';
 import { EffectsObject } from '../effects-object';
+import { MaterialState } from './material-state';
 /**
  * 材质销毁设置
  */
@@ -44,9 +48,9 @@ export interface MaterialProps {
     uniformValues?: Record<string, UniformValue>;
 }
 /**
- * Material 抽象类
+ * Material 类
  */
-export declare abstract class Material extends EffectsObject implements Disposable {
+export declare class Material extends EffectsObject implements Disposable {
     shaderVariant: ShaderVariant;
     shaderSource: ShaderWithSource;
     stringTags: Record<string, string>;
@@ -58,10 +62,24 @@ export declare abstract class Material extends EffectsObject implements Disposab
     protected initialized: boolean;
     protected shaderDirty: boolean;
     private _shader;
-    /**
-     *
-     * @param props - 材质属性
-     */
+    protected floats: Record<string, number>;
+    protected ints: Record<string, number>;
+    protected vector2s: Record<string, Vector2>;
+    protected vector3s: Record<string, Vector3>;
+    protected vector4s: Record<string, Vector4>;
+    protected colors: Record<string, Color>;
+    protected quaternions: Record<string, Quaternion>;
+    protected matrices: Record<string, Matrix4>;
+    protected matrice3s: Record<string, Matrix3>;
+    protected textures: Record<string, Texture>;
+    protected floatArrays: Record<string, number[]>;
+    protected vector4Arrays: Record<string, number[]>;
+    protected matrixArrays: Record<string, number[]>;
+    protected samplers: string[];
+    protected uniforms: string[];
+    protected uniformDirty: boolean;
+    protected macrosDirty: boolean;
+    protected materialState: MaterialState;
     constructor(engine: Engine, props?: MaterialProps);
     get shader(): Shader;
     set shader(value: Shader);
@@ -75,294 +93,100 @@ export declare abstract class Material extends EffectsObject implements Disposab
      */
     get color(): Color;
     set color(value: Color);
-    /******** effects-core 中会调用 引擎必须实现 ***********************/
-    /**
-     * 设置 Material 的颜色融合开关
-     * @param blending - 是否开启混合效果
-     */
+    /*** 渲染状态 getter/setter ***/
+    get blending(): UndefinedAble<boolean>;
     set blending(blending: UndefinedAble<boolean>);
-    /**
-     * 分别指定 Material 的颜色混合函数乘数
-     * @param func - 混合函数参数
-     */
+    get blendColor(): UndefinedAble<[r: number, g: number, b: number, a: number]>;
+    set blendColor(color: UndefinedAble<[r: number, g: number, b: number, a: number]>);
+    get blendFunction(): UndefinedAble<[blendSrc: number, blendDst: number, blendSrcAlpha: number, blendDstAlpha: number]>;
     set blendFunction(func: UndefinedAble<[blendSrc: number, blendDst: number, blendSrcAlpha: number, blendDstAlpha: number]>);
-    /**
-     * 分别指定 Material 的颜色混合方式
-     * @param equation - 混合方程参数
-     */
+    get blendEquation(): UndefinedAble<[rgb: number, alpha: number]>;
     set blendEquation(equation: UndefinedAble<[rgb: number, alpha: number]>);
-    /**
-     * 设置 Material 的深度测试开关
-     * @param value - 是否开启深度测试
-     */
+    get depthTest(): UndefinedAble<boolean>;
     set depthTest(value: UndefinedAble<boolean>);
-    /**
-     * 设置 Material 的写入深度缓冲开关
-     * @param value - 是否开启深度写入
-     */
+    get depthMask(): UndefinedAble<boolean>;
     set depthMask(value: UndefinedAble<boolean>);
-    /**
-     * 设置 Material 的模板测试开关
-     * @param value - 是否开启模板测试
-     */
+    get depthRange(): UndefinedAble<[number, number]>;
+    set depthRange(value: UndefinedAble<[number, number]>);
+    get depthFunc(): UndefinedAble<number>;
+    set depthFunc(value: UndefinedAble<number>);
+    get polygonOffsetFill(): UndefinedAble<boolean>;
+    set polygonOffsetFill(value: UndefinedAble<boolean>);
+    get polygonOffset(): UndefinedAble<[number, number]>;
+    set polygonOffset(value: UndefinedAble<[number, number]>);
+    get sampleAlphaToCoverage(): UndefinedAble<boolean>;
+    set sampleAlphaToCoverage(value: UndefinedAble<boolean>);
+    get colorMask(): boolean;
+    set colorMask(value: boolean);
+    get stencilTest(): UndefinedAble<boolean>;
     set stencilTest(value: UndefinedAble<boolean>);
-    /**
-     * 分别指定 Material 的模板测试参考值
-     * @param value  - 模板测试参考值参数
-     */
-    set stencilRef(value: UndefinedAble<[front: number, back: number]>);
-    /**
-     * 分别指定 Material 的模板测试函数
-     * @param value - 模板测试函数参数
-     */
-    set stencilFunc(value: UndefinedAble<[front: number, back: number]>);
-    /**
-     * 分别指定 Material 的模板测试和深度测试都通过时使用的函数
-     * @param value - 模板测试深度测试通过时的操作参数
-     */
-    set stencilOpZPass(value: UndefinedAble<[front: number, back: number]>);
-    /**
-     * 设置 Material 的正反面剔除开关
-     * @param value - 是否开启剔除
-     */
+    get stencilMask(): UndefinedAble<[number, number]>;
+    set stencilMask(value: UndefinedAble<[number, number]>);
+    get stencilRef(): UndefinedAble<[number, number]>;
+    set stencilRef(value: UndefinedAble<[number, number]>);
+    get stencilFunc(): UndefinedAble<[number, number]>;
+    set stencilFunc(value: UndefinedAble<[number, number]>);
+    get stencilOpFail(): UndefinedAble<[number, number]>;
+    set stencilOpFail(value: UndefinedAble<[number, number]>);
+    get stencilOpZFail(): UndefinedAble<[number, number]>;
+    set stencilOpZFail(value: UndefinedAble<[number, number]>);
+    get stencilOpZPass(): UndefinedAble<[number, number]>;
+    set stencilOpZPass(value: UndefinedAble<[number, number]>);
+    get culling(): UndefinedAble<boolean>;
     set culling(value: UndefinedAble<boolean>);
-    /**
-     * 设置 Material 的正反面计算方向
-     * @param value
-     */
+    get frontFace(): UndefinedAble<number>;
     set frontFace(value: UndefinedAble<number>);
-    /**
-     * 设置 Material 要剔除的面
-     * @param value - 剔除面参数
-     */
+    get cullFace(): UndefinedAble<number>;
     set cullFace(value: UndefinedAble<number>);
-    /***************************************************/
-    /******** effects-core 中暂无调用 引擎可以先不实现 ***********************/
-    /**
-     * 设置 Material 的源和目标混合因子
-     * @param color
-     */
-    set blendColor(color: UndefinedAble<[r: number, g: number, b: number, a: number]>);
-    /**
-     * 设置 Material 的深度映射范围
-     * @param value
-     */
-    set depthRange(value: UndefinedAble<[zNear: number, zFar: number]>);
-    /**
-     * 设置 Material 的深度比较函数
-     * @param value - 深度测试函数参数
-     */
-    set depthFunc(value: UndefinedAble<number>);
-    /**
-     * 设置 Material 的多边形偏移（实现类似深度偏移的效果）
-     * @param value - 多边形偏移参数
-     */
-    set polygonOffsetFill(value: UndefinedAble<boolean>);
-    /**
-     * 指定 Material 计算深度值的比例因子 factor 和单位 units
-     * @param value
-     */
-    set polygonOffset(value: UndefinedAble<[factor: number, units: number]>);
-    /**
-     * 设置 Material 的通过 alpha 值决定临时覆盖值计算的开关
-     * @param value - 是否开启 alpha 抖动
-     */
-    set sampleAlphaToCoverage(value: UndefinedAble<boolean>);
-    /**
-     * 设置 Material 颜色缓冲区的写入开关
-     * @param value
-     */
-    abstract set colorMask(value: boolean);
-    /**
-     * 获取 Material 颜色缓冲区的写入开关
-     * @param value
-     */
-    abstract get colorMask(): boolean;
-    /**
-     * 分别指定 Material 的模板测试掩码
-     * @param value - 模板测试写入掩码参数
-     */
-    set stencilMask(value: UndefinedAble<[front: number, back: number]>);
-    /**
-     * 分别指定 Material 模板测试失败时要使用的函数
-     * @param value - 模板测试失败时的操作参数
-     */
-    set stencilOpFail(value: UndefinedAble<[front: number, back: number]>);
-    /**
-     * 分别指定 Material 模板测试通过但深度测试失败时要使用的函数
-     * @param value - 模板测试深度测试失败时的操作参数
-     */
-    set stencilOpZFail(value: UndefinedAble<[front: number, back: number]>);
-    /***************************************************/
-    /**
-     * 获取 Material 的 float 类型的 uniform 数据
-     * @param name
-     */
-    abstract getFloat(name: string): number | null;
-    /**
-     * 设置 float 类型的 uniform 数据
-     * @param name - uniform 名称
-     * @param value - 要设置的 uniform 数据
-     */
-    abstract setFloat(name: string, value: number): void;
-    /**
-     * 获取 Material 的 float 类型的 uniform 数据
-     * @param name
-     */
-    abstract getInt(name: string): number | null;
-    /**
-     * 设置 int 类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param value - 要设置的 uniform 数据
-     */
-    abstract setInt(name: string, value: number): void;
-    /**
-     * 获取 Material 的 float 数组类型的 uniform 数据
-     * @param name
-     */
-    abstract getFloats(name: string): number[] | null;
-    /**
-     * 设置 float 数组类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param value - 要设置的 uniform 数据
-     */
-    abstract setFloats(name: string, value: number[]): void;
-    /**
-     * 获取 Material 的 vec2 类型的 uniform 数据
-     * @param name
-     */
-    abstract getVector2(name: string): Vector2 | null;
-    /**
-     * 设置 vec2 类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param value - 要设置的 uniform 数据
-     */
-    abstract setVector2(name: string, value: Vector2): void;
-    /**
-     * 获取 Material 的 vec3 类型的 uniform 数据
-     * @param name
-     */
-    abstract getVector3(name: string): Vector3 | null;
-    /**
-     * 设置 vec3 类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param value - 要设置的 uniform 数据
-     */
-    abstract setVector3(name: string, value: Vector3): void;
-    /**
-     * 获取 Material 的 vec4 类型的 uniform 数据
-     * @param name
-     */
-    abstract getVector4(name: string): Vector4 | null;
-    /**
-     * 设置 vec4 类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param value - 要设置的 uniform 数据
-     */
-    abstract setVector4(name: string, value: Vector4): void;
-    /**
-     * 获取 Material 的 Color 类型的 uniform 数据
-     * @param name
-     */
-    abstract getColor(name: string): Color | null;
-    /**
-     * 设置 Color 类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param value - 要设置的 uniform 数据
-     */
-    abstract setColor(name: string, value: Color): void;
-    /**
-     * 获取 Material 的 Quaternion 类型的 uniform 数据
-     * @param name
-     */
-    abstract getQuaternion(name: string): Quaternion | null;
-    /**
-     * 设置 Quaternion 类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param value - 要设置的 uniform 数据
-     */
-    abstract setQuaternion(name: string, value: Quaternion): void;
-    /**
-     * 获取 Material 的 vec4 数组类型的 uniform 数据
-     * @param name
-     */
-    abstract getVector4Array(name: string): number[];
-    /**
-     * 设置 vec4 数组类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param value - 要设置的 uniform 数据
-     */
-    abstract setVector4Array(name: string, value: Vector4[]): void;
-    /**
-     * 获取 Material 的 mat4 类型的 uniform 数据
-     * @param name
-     */
-    abstract getMatrix(name: string): Matrix4 | null;
-    /**
-     * 设置 mat4 类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param value - 要设置的 uniform 数据
-     */
-    abstract setMatrix(name: string, value: Matrix4): void;
-    /**
-     * 设置 mat3 类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param value - 要设置的 uniform 数据
-     */
-    abstract setMatrix3(name: string, value: Matrix3): void;
-    /**
-     * 获取 Material 的 mat4 数组类型的 uniform 数据
-     * @param name
-     */
-    abstract getMatrixArray(name: string): number[] | null;
-    /**
-     * 设置 mat 数组类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param array - 要设置的 uniform 数据
-     */
-    abstract setMatrixArray(name: string, array: Matrix4[]): void;
-    /**
-     * 设置 mat 数组类型的 uniform 的数据，传入 number 数组
-     * @param name - uniform 名称
-     * @param array - 要设置的 uniform 数据，number 类型数组
-     */
-    abstract setMatrixNumberArray(name: string, array: number[]): void;
-    /**
-     * 获取 Material 的 sampler2D 类型的 uniform 数据
-     * @param name
-     */
-    abstract getTexture(name: string): Texture | null;
-    /**
-     * 设置 sampler2D 类型的 uniform 的数据
-     * @param name - uniform 名称
-     * @param texture - 要设置的 uniform 数据
-     */
-    abstract setTexture(name: string, texture: Texture): void;
-    /**
-     * 获取 Material 的 float 类型的 uniform 数据
-     * @param name
-     */
-    abstract hasUniform(name: string): boolean;
-    /******** 预留接口，暂时不用实现 ***********************/
-    abstract enableMacro(keyword: string, value?: boolean | number): void;
-    abstract disableMacro(keyword: string): void;
-    abstract isMacroEnabled(keyword: string): boolean;
-    /***************************************************/
-    /**
-     * Material 的克隆方法（不接入滤镜，本方法可以不做实现）
-     * @param props 新的材质属性
-     */
-    abstract clone(props?: MaterialProps): Material;
-    abstract cloneUniforms(sourceMaterial: Material): void;
+    /*** Macro 管理 ***/
+    enableMacro(keyword: string, value?: boolean | number): void;
+    disableMacro(keyword: string): void;
+    isMacroEnabled(keyword: string): boolean;
+    get isDestroyed(): boolean;
+    /*** GPU 资源初始化 ***/
+    initialize(): void;
+    createShaderVariant(): void;
+    setupStates(engine: Engine): void;
+    use(renderer: Renderer, globalUniforms?: GlobalUniforms): void;
+    /*** Uniform get/set 方法 ***/
+    getFloat(name: string): number | null;
+    setFloat(name: string, value: number): void;
+    getInt(name: string): number | null;
+    setInt(name: string, value: number): void;
+    getFloats(name: string): number[] | null;
+    setFloats(name: string, value: number[]): void;
+    getVector2(name: string): Vector2 | null;
+    setVector2(name: string, value: Vector2): void;
+    getVector3(name: string): Vector3 | null;
+    setVector3(name: string, value: Vector3): void;
+    getVector4(name: string): Vector4 | null;
+    setVector4(name: string, value: Vector4): void;
+    getColor(name: string): Color | null;
+    setColor(name: string, value: Color): void;
+    getQuaternion(name: string): Quaternion | null;
+    setQuaternion(name: string, value: Quaternion): void;
+    getMatrix(name: string): Matrix4 | null;
+    setMatrix(name: string, value: Matrix4): void;
+    setMatrix3(name: string, value: Matrix3): void;
+    getVector4Array(name: string): number[];
+    setVector4Array(name: string, array: Vector4[]): void;
+    getMatrixArray(name: string): number[] | null;
+    setMatrixArray(name: string, array: Matrix4[]): void;
+    setMatrixNumberArray(name: string, array: number[]): void;
+    getTexture(name: string): Texture | null;
+    setTexture(name: string, texture: Texture): void;
+    hasUniform(name: string): boolean;
+    /*** 克隆 ***/
+    clone(props?: MaterialProps): Material;
+    cloneUniforms(sourceMaterial: Material): void;
+    /*** 序列化 ***/
+    fromData(data: spec.MaterialData): void;
+    toData(): spec.MaterialData;
     /**
      * 创建 Material
      */
     static create: (engine: Engine, props?: MaterialProps) => Material;
-    /**
-     * 初始化 GPU 资源
-     * @override
-     */
-    initialize(): void;
-    createShaderVariant(): void;
-    use(render: Renderer, globalUniforms: GlobalUniforms): void;
+    /*** 内部方法 ***/
+    private checkUniform;
+    dispose(): void;
 }

package/dist/math/index.d.ts

@@ -8,3 +8,4 @@ export * from './shape/ellipse';
 export * from './shape/poly-star';
 export * from './shape/polygon';
 export * from './shape/shape-path';
+export * from './bezier';

package/dist/plugin-system.d.ts

@@ -17,7 +17,7 @@ export declare function registerPlugin(name: string, pluginClass: PluginConstruc
 export declare function unregisterPlugin(name: string): void;
 export declare class PluginSystem {
     static getPlugins(): Plugin[];
-    static initializeComposition(composition: Composition, scene: Scene): void;
+    static initializeComposition(composition: Composition, scene?: Scene): void;
     static destroyComposition(comp: Composition): void;
     static onAssetsLoadStart(scene: Scene, options?: SceneLoadOptions): Promise<void[]>;
     static onAssetsLoadFinish(scene: Scene, options: SceneLoadOptions, engine: Engine): void;

package/dist/plugins/camera/camera-controller-node.d.ts

@@ -1,9 +1,12 @@
 import * as spec from '@galacean/effects-specification';
 import { Component } from '../../components';
 import type { Engine } from '../../engine';
+interface CameraControllerData extends spec.ComponentData, spec.CameraContent {
+}
 export declare class CameraController extends Component {
     private options;
-    constructor(engine: Engine, props?: spec.CameraContent);
+    constructor(engine: Engine, props?: CameraControllerData);
     onUpdate(): void;
-    fromData(data: spec.CameraContent): void;
+    fromData(data: CameraControllerData): void;
 }
+export {};

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

@@ -88,7 +88,7 @@ export declare class InteractComponent extends RendererComponent {
     beginDragTarget(options: spec.DragInteractOption, eventSystem: EventSystem): void;
     getHitTestParams: (force?: boolean) => HitTestTriangleParams | void;
     getBoundingBox(): BoundingBoxTriangle | void;
-    fromData(data: spec.InteractContent): void;
+    fromData(data: spec.InteractComponentData): void;
     /**
      * 是否可以交互
      * @returns

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

@@ -28,7 +28,6 @@ export interface ParticleMeshData {
         y?: ValueGetter<number>;
         separateAxes?: boolean;
     };
-    meshSlots?: number[];
     forceTarget?: {
         curve: ValueGetter<number>;
         target: spec.vec3;

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

@@ -1,8 +1,8 @@
 import type { Matrix4 } from '@galacean/effects-math/es/core/matrix4';
 import type { Vector3 } from '@galacean/effects-math/es/core/vector3';
 import type { Texture } from '../../texture';
-import type { TrailMeshProps, TrailPointOptions } from './trail-mesh';
-import type { ParticleMeshProps, Point } from './particle-mesh';
+import type { TrailPointOptions } from './trail-mesh';
+import type { Point } from './particle-mesh';
 import { ParticleMesh } from './particle-mesh';
 import type { Mesh, Renderer } from '../../render';
 import type { Engine } from '../../engine';
@@ -14,7 +14,7 @@ export declare class ParticleSystemRenderer extends RendererComponent {
     meshes: Mesh[];
     particleMesh: ParticleMesh;
     private trailMesh?;
-    constructor(engine: Engine, particleMeshProps?: ParticleMeshProps, trailMeshProps?: TrailMeshProps);
+    constructor(engine: Engine);
     onStart(): void;
     onUpdate(dt: number): void;
     render(renderer: Renderer): void;

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

@@ -1,6 +1,6 @@
 import type { Ray } from '@galacean/effects-math/es/core/index';
 import { Vector3 } from '@galacean/effects-math/es/core/index';
-import type { vec2, vec3, vec4 } from '@galacean/effects-specification';
+import type { vec3 } from '@galacean/effects-specification';
 import * as spec from '@galacean/effects-specification';
 import { Component } from '../../components';
 import type { Engine } from '../../engine';
@@ -94,7 +94,6 @@ type TrailOptions = {
     blending: number;
     occlusion: boolean;
     transparentOcclusion: boolean;
-    textureMap?: vec4;
 };
 interface ParticleTextureSheetAnimation {
     col: number;
@@ -112,24 +111,7 @@ type ParticleInteraction = {
     multiple?: boolean;
     radius: number;
 };
-export interface ParticleSystemOptions extends spec.ParticleOptions {
-    meshSlots?: number[];
-}
-export interface ParticleSystemProps extends Omit<spec.ParticleContent, 'options' | 'renderer' | 'trails' | 'mask'> {
-    options: ParticleSystemOptions;
-    renderer: ParticleSystemRendererOptions;
-    trails?: ParticleTrailProps;
-    mask?: spec.MaskOptions;
-}
-export interface ParticleSystemRendererOptions extends Required<Omit<spec.RendererOptions, 'texture' | 'anchor' | 'particleOrigin'>> {
-    texture: Texture;
-    anchor?: vec2;
-    particleOrigin?: spec.ParticleOrigin;
-}
-export interface ParticleTrailProps extends Omit<spec.ParticleTrail, 'texture' | 'mask'> {
-    texture: Texture;
-    textureMap: vec4;
-    mask?: spec.MaskOptions;
+export interface ParticleSystemProps extends spec.ParticleContent {
 }
 export type ParticleContent = [number, number, number, Point];
 export declare class ParticleSystem extends Component implements Maskable {
@@ -142,7 +124,6 @@ export declare class ParticleSystem extends Component implements Maskable {
     textureSheetAnimation?: ParticleTextureSheetAnimation;
     interaction?: ParticleInteraction;
     emissionStopped: boolean;
-    destroyed: boolean;
     props: ParticleSystemProps;
     time: number;
     readonly maskManager: MaskProcessor;
@@ -157,7 +138,9 @@ export declare class ParticleSystem extends Component implements Maskable {
     private uvs;
     private basicTransform;
     private clickedPoint;
-    constructor(engine: Engine, props?: ParticleSystemProps);
+    private particleMeshProps;
+    private trailMeshProps;
+    constructor(engine: Engine, props?: spec.ParticleSystemData);
     get timePassed(): number;
     get lifetime(): number;
     get particleCount(): number;
@@ -212,6 +195,6 @@ export declare class ParticleSystem extends Component implements Maskable {
     resumeParticleEmission(): void;
     getBoundingBox(): void | BoundingBoxSphere;
     getHitTestParams: (force?: boolean) => void | HitTestCustomParams;
-    fromData(data: unknown): void;
+    fromData(data: spec.ParticleSystemData): void;
 }
 export {};

package/dist/plugins/particle/trail-mesh.d.ts

@@ -1,7 +1,7 @@
 import type { Matrix4 } from '@galacean/effects-math/es/core/index';
 import { Vector3 } from '@galacean/effects-math/es/core/index';
 import type * as spec from '@galacean/effects-specification';
-import type { GradientStop, vec4 } from '@galacean/effects-specification';
+import type { GradientStop } from '@galacean/effects-specification';
 import type { Engine } from '../../engine';
 import { ValueGetter } from '../../math';
 import type { GPUCapability, ShaderWithSource } from '../../render';
@@ -24,7 +24,6 @@ export type TrailMeshProps = {
     mask: number;
     shaderCachePrefix: string;
     maskMode: number;
-    textureMap: vec4;
     name: string;
 };
 export type TrailPointOptions = {

package/dist/plugins/plugin.d.ts

@@ -32,7 +32,7 @@ export declare abstract class Plugin {
      * @param composition - 合成对象
      * @param scene - 场景对象
      */
-    onCompositionCreated(composition: Composition, scene: Scene): void;
+    onCompositionCreated(composition: Composition, scene?: Scene): void;
     /**
      * 合成销毁时触发。
      * @param composition - 合成对象