@galacean/effects-core 2.9.0-alpha.1 → 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/material/types.d.ts

@@ -2,6 +2,7 @@ import type * as spec from '@galacean/effects-specification';
 import type { Matrix3, Matrix4, Vector2, Vector3, Vector4 } from '@galacean/effects-math/es/core/index';
 import type { Texture } from '../texture';
 import type { DestroyOptions } from '../utils';
+import type { VFXItem } from '../vfx-item';
 export type UniformSemantic = 'VIEW' | 'MODEL' | 'MODELVIEW' | 'PROJECTION' | 'VIEWPROJECTION' | 'VIEWINVERSE' | 'EDITOR_TRANSFORM' | 'MODELVIEWPROJECTION';
 export interface MaterialBlendingStates {
     blending?: boolean;
@@ -63,6 +64,7 @@ export declare enum ShaderType {
  *
  */
 export interface Maskable {
+    item: VFXItem;
     drawStencilMask(maskRef: number): 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/math/shape/build-adaptive-bezier.d.ts

@@ -1 +1 @@
-export declare function buildAdaptiveBezier(points: number[], sX: number, sY: number, cp1x: number, cp1y: number, cp2x: number, cp2y: number, eX: number, eY: number, smoothness?: number): number[];
+export declare function buildAdaptiveBezier(points: number[], sX: number, sY: number, cp1x: number, cp1y: number, cp2x: number, cp2y: number, eX: number, eY: number, smoothness?: number, scale?: number): number[];

package/dist/math/shape/circle.d.ts

@@ -191,6 +191,6 @@ export declare class Circle extends ShapePrimitive {
      * @see {@link Circle.clone} For creating new circle copy
      */
     copyTo(circle: Circle): Circle;
-    build(points: number[]): void;
+    build(points: number[], screenScale?: number): void;
     triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
 }

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

@@ -74,6 +74,6 @@ export declare class Ellipse extends ShapePrimitive {
     copyTo(ellipse: Ellipse): Ellipse;
     getX(): number;
     getY(): number;
-    build(points: number[]): number[];
+    build(points: number[], screenScale?: number): number[];
     triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
 }

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

@@ -23,7 +23,7 @@ export declare class GraphicsPath {
      * @param smoothness - Optional parameter to adjust the smoothness of the curve.
      * @returns The instance of the current object for chaining.
      */
-    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, smoothness?: number): GraphicsPath;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, smoothness?: number, scale?: number): GraphicsPath;
     /**
      * Connects the current point to a new point with a straight line. This method updates the current path.
      * @param x - The x-coordinate of the new point to connect to.

package/dist/math/shape/poly-star.d.ts

@@ -35,7 +35,7 @@ export declare class PolyStar extends ShapePrimitive {
     clone(): ShapePrimitive;
     copyFrom(source: PolyStar): void;
     copyTo(destination: PolyStar): void;
-    build(points: number[]): void;
+    build(points: number[], screenScale?: number): void;
     triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
     private buildStarPath;
     private buildPolygonPath;

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

@@ -58,7 +58,7 @@ export declare class Polygon extends ShapePrimitive {
      * @readonly
      */
     getY(): number;
-    build(points: number[]): void;
+    build(points: number[], screenScale?: number): void;
     triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
     /**
      * 获取直线上最远的两个端点坐标组成的三角形

package/dist/math/shape/rectangle.d.ts

@@ -57,6 +57,6 @@ export declare class Rectangle extends ShapePrimitive {
      * @returns Returns given parameter.
      */
     copyTo(rectangle: Rectangle): Rectangle;
-    build(points: number[]): void;
+    build(points: number[], screenScale?: number): void;
     triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
 }

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

@@ -26,7 +26,7 @@ export declare class ShapePath {
      * @param smoothness - Optional parameter to adjust the smoothness of the curve.
      * @returns The instance of the current object for chaining.
      */
-    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, smoothness?: number): ShapePath;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, smoothness?: number, scale?: number): ShapePath;
     moveTo(x: number, y: number): ShapePath;
     /**
      * Connects the current point to a new point with a straight line. This method updates the current path.

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

@@ -10,6 +10,6 @@ export declare abstract class ShapePrimitive {
     /** Returns the framing rectangle of the ShapePrimitive as a Rectangle object. */
     /** The X coordinate of the shape */
     /** The Y coordinate of the shape */
-    abstract build(points: number[]): void;
+    abstract build(points: number[], screenScale?: number): void;
     abstract triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
 }

package/dist/math/shape/triangle.d.ts

@@ -84,6 +84,6 @@ export declare class Triangle extends ShapePrimitive {
     getBounds(out?: Rectangle): Rectangle;
     getX(): number;
     getY(): number;
-    build(points: number[]): void;
+    build(points: number[], screenScale?: number): void;
     triangulate(points: number[], vertices: number[], verticesOffset: number, indices: number[], indicesOffset: number): void;
 }

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 {};