@galacean/effects-core 1.2.0 → 2.0.0-alpha.0

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

@@ -0,0 +1,36 @@
+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 { ParticleMesh } from './particle-mesh';
+import type { Mesh, Renderer } from '../../render';
+import type { Engine } from '../../engine';
+import { RendererComponent } from '../../components';
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class ParticleSystemRenderer extends RendererComponent {
+    meshes: Mesh[];
+    particleMesh: ParticleMesh;
+    private trailMesh?;
+    constructor(engine: Engine, particleMeshProps: ParticleMeshProps, trailMeshProps?: TrailMeshProps);
+    start(): void;
+    update(dt: number): void;
+    render(renderer: Renderer): void;
+    reset(): void;
+    updateTime(now: number, delta: number): void;
+    minusTimeForLoop(duration: number): void;
+    updateWorldMatrix(worldMatrix: Matrix4): void;
+    setVisible(visible: boolean): void;
+    getTextures(): Texture[];
+    setParticlePoint(index: number, point: Point): void;
+    removeParticlePoint(index: number): void;
+    getParticlePointColor(index: number): number[];
+    hasTrail(): boolean;
+    clearTrail(pointIndex: number): void;
+    addTrailPoint(index: number, position: Vector3, options: TrailPointOptions): void;
+    setTrailStartPosition(index: number, position: Vector3): void;
+    getTrailStartPosition(index: number): Vector3;
+}

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

@@ -1,18 +1,19 @@
-import * as spec from '@galacean/effects-specification';
-import type { vec2, vec3, vec4 } from '@galacean/effects-specification';
 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 * as spec from '@galacean/effects-specification';
+import { Component } from '../../components';
+import type { Engine } from '../../engine';
 import type { ValueGetter } from '../../math';
+import type { Mesh } from '../../render';
 import type { ShapeGenerator } from '../../shape';
 import { Texture } from '../../texture';
 import { Transform } from '../../transform';
-import type { color } from '../../utils';
+import { type color } from '../../utils';
+import type { BoundingBoxSphere, HitTestCustomParams } from '../interact/click-handler';
 import { Burst } from './burst';
-import type { ParticleVFXItem } from './particle-vfx-item';
-import { TrailMesh } from './trail-mesh';
 import type { Point } from './particle-mesh';
-import { ParticleMesh } from './particle-mesh';
-import type { Mesh } from '../../render';
+import { ParticleSystemRenderer } from './particle-system-renderer';
 type ParticleSystemRayCastOptions = {
     ray: Ray;
     radius: number;
@@ -43,12 +44,10 @@ type ParticleOptions = {
         turbulenceY: ValueGetter<number>,
         turbulenceZ: ValueGetter<number>
     ];
-    duration: number;
     looping: boolean;
     maxCount: number;
     gravity: vec3;
     gravityModifier: ValueGetter<number>;
-    endBehavior: number;
     renderLevel?: string;
     particleFollowParent?: boolean;
     forceTarget?: {
@@ -118,10 +117,10 @@ interface ParticleSystemOptions extends spec.ParticleOptions {
 }
 export interface ParticleSystemProps extends Omit<spec.ParticleContent, 'options' | 'renderer' | 'trails'> {
     options: ParticleSystemOptions;
-    renderer: ParticleSystemRenderer;
+    renderer: ParticleSystemRendererOptions;
     trails?: ParticleTrailProps;
 }
-export interface ParticleSystemRenderer extends Required<Omit<spec.RendererOptions, 'texture' | 'anchor' | 'particleOrigin'>> {
+export interface ParticleSystemRendererOptions extends Required<Omit<spec.RendererOptions, 'texture' | 'anchor' | 'particleOrigin'>> {
     mask: number;
     texture: Texture;
     anchor?: vec2;
@@ -132,10 +131,8 @@ export interface ParticleTrailProps extends Omit<spec.ParticleTrail, 'texture'>
     textureMap: vec4;
 }
 export type ParticleContent = [number, number, number, Point];
-export declare class ParticleSystem {
-    reusable: boolean;
-    particleMesh: ParticleMesh;
-    trailMesh?: TrailMesh;
+export declare class ParticleSystem extends Component {
+    renderer: ParticleSystemRenderer;
     options: ParticleOptions;
     shape: ShapeGenerator;
     emission: ParticleEmissionOptions;
@@ -144,7 +141,8 @@ export declare class ParticleSystem {
     textureSheetAnimation?: ParticleTextureSheetAnimation;
     interaction?: ParticleInteraction;
     emissionStopped: boolean;
-    name: string;
+    destoryed: boolean;
+    props: ParticleSystemProps;
     private generatedCount;
     private lastUpdate;
     private loopStartTime;
@@ -155,14 +153,12 @@ export declare class ParticleSystem {
     private frozen;
     private upDirectionWorld;
     private uvs;
-    private readonly basicTransform;
-    private readonly transform;
-    constructor(props: ParticleSystemProps, rendererOptions: {
-        cachePrefix: string;
-    }, vfxItem: ParticleVFXItem);
+    private basicTransform;
+    constructor(engine: Engine, props?: ParticleSystemProps);
     get timePassed(): number;
     get lifetime(): number;
     get particleCount(): number;
+    initEmitterTransform(): void;
     private updateEmitterTransform;
     private addParticle;
     setVisible(visible: boolean): void;
@@ -192,5 +188,10 @@ export declare class ParticleSystem {
     addBurst(burst: Burst, offsets: vec3[]): number;
     removeBurst(index: number): void;
     createPoint(lifetime: number): Point;
+    stopParticleEmission(): void;
+    resumeParticleEmission(): void;
+    getBoundingBox(): void | BoundingBoxSphere;
+    getHitTestParams: (force?: boolean) => void | HitTestCustomParams;
+    fromData(data: any): void;
 }
 export {};

package/dist/plugins/particle/particle-vfx-item.d.ts

@@ -1,27 +1,11 @@
-import * as spec from '@galacean/effects-specification';
-import type { Composition } from '../../composition';
-import { VFXItem } from '../../vfx-item';
-import type { BoundingBoxSphere, HitTestCustomParams } from '../interact/click-handler';
-import type { ParticleSystemProps } from './particle-system';
+import { Playable } from '../cal/playable-graph';
 import { ParticleSystem } from './particle-system';
-export declare class ParticleVFXItem extends VFXItem<ParticleSystem> {
-    name: string;
-    particle: ParticleSystemProps;
-    private destroyed;
-    get type(): spec.ItemType;
-    onConstructed(props: spec.ParticleItem): void;
-    onLifetimeBegin(composition: Composition, particleSystem: ParticleSystem): ParticleSystem;
-    onItemUpdate(dt: number, lifetime: number): void;
-    onItemRemoved(composition: Composition, content: ParticleSystem): void;
-    /**
-     * @internal
-     */
-    setColor(r: number, g: number, b: number, a: number): void;
-    setOpacity(opacity: number): void;
-    stopParticleEmission(): void;
-    resumeParticleEmission(): void;
-    protected doCreateContent(composition: Composition): ParticleSystem;
-    isEnded(now: number): boolean;
-    getBoundingBox(): void | BoundingBoxSphere;
-    getHitTestParams(force?: boolean): void | HitTestCustomParams;
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class ParticleBehaviourPlayable extends Playable {
+    particleSystem: ParticleSystem;
+    onPlayablePlay(): void;
+    processFrame(dt: number): void;
 }

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

@@ -7,7 +7,7 @@ import { Geometry, Mesh } from '../../render';
 import { Texture } from '../../texture';
 import type { Engine } from '../../engine';
 import type { ValueGetter } from '../../math';
-export type TrailMeshConstructor = {
+export type TrailMeshProps = {
     maxTrailCount: number;
     pointCountPerTrail: number;
     colorOverLifetime?: Array<GradientStop>;
@@ -16,7 +16,6 @@ export type TrailMeshConstructor = {
     blending: number;
     widthOverTrail: ValueGetter<number>;
     colorOverTrail?: Array<GradientStop>;
-    order: number;
     matrix?: Matrix4;
     opacityOverLifetime: ValueGetter<number>;
     occlusion: boolean;
@@ -28,7 +27,7 @@ export type TrailMeshConstructor = {
     textureMap: vec4;
     name: string;
 };
-type TrailPointOptions = {
+export type TrailPointOptions = {
     lifetime: number;
     color: number[];
     size: number;
@@ -45,7 +44,7 @@ export declare class TrailMesh {
     checkVertexDistance: boolean;
     private pointStart;
     private trailCursors;
-    constructor(props: TrailMeshConstructor, engine: Engine);
+    constructor(engine: Engine, props: TrailMeshProps);
     get time(): number;
     set time(t: number);
     addPoint(trailIndex: number, position: Vector3, opt: TrailPointOptions): void;
@@ -58,4 +57,3 @@ export declare class TrailMesh {
     onUpdate(escapeTime: number): any;
 }
 export declare function getTrailMeshShader(trails: spec.ParticleTrail, particleMaxCount: number, name: string, env: string | undefined, gpuCapability: GPUCapability): ShaderWithSource;
-export {};

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

@@ -1,14 +1,18 @@
-import type { Vector3 } from '@galacean/effects-math/es/core/index';
+import { Matrix4 } from '@galacean/effects-math/es/core/index';
+import type { vec2, vec4 } from '@galacean/effects-specification';
 import * as spec from '@galacean/effects-specification';
-import type { vec2, vec4, TypedArray, TextureSheetAnimation } from '@galacean/effects-specification';
-import type { FilterDefine } from '../../filter';
+import { RendererComponent } from '../../components/renderer-component';
+import type { Engine } from '../../engine';
+import { Material } from '../../material';
 import type { ValueGetter } from '../../math';
+import type { Renderer } from '../../render';
+import { Geometry } from '../../render';
 import type { GeometryFromShape } from '../../shape';
 import type { Texture } from '../../texture';
 import type { CalculateItemOptions } from '../cal/calculate-item';
-import { CalculateItem } from '../cal/calculate-item';
-import type { SpriteMesh, SpriteRenderData } from './sprite-mesh';
-import type { SpriteVFXItem } from './sprite-vfx-item';
+import { TimelineComponent } from '../cal/calculate-item';
+import { Playable } from '../cal/playable-graph';
+import type { BoundingBoxTriangle, HitTestTriangleParams } from '../interact/click-handler';
 /**
  * 用于创建 spriteItem 的数据类型, 经过处理后的 spec.SpriteContent
  */
@@ -52,55 +56,78 @@ export interface SpriteItemRenderInfo {
     mask: number;
     maskMode: number;
     cacheId: string;
-    filter?: FilterDefine;
     wireframe?: boolean;
 }
 export type splitsDataType = [r: number, x: number, y: number, w: number, h: number | undefined][];
-export declare class SpriteItem extends CalculateItem {
-    options: SpriteItemOptions;
+export declare class SpriteColorPlayable extends Playable {
+    clipData: {
+        colorOverLifetime?: spec.ColorOverLifetime;
+        startColor?: spec.RGBAColorValue;
+    };
+    colorOverLifetime: {
+        stop: number;
+        color: any;
+    }[];
+    opacityOverLifetime: ValueGetter<number>;
+    startColor: spec.RGBAColorValue;
+    renderColor: vec4;
+    spriteMaterial: Material;
+    onPlayablePlay(): void;
+    processFrame(dt: number): void;
+    fromData(clipData: {
+        colorOverLifetime?: spec.ColorOverLifetime;
+        startColor?: spec.RGBAColorValue;
+    }): this;
+}
+export declare class SpriteComponent extends RendererComponent {
     renderer: SpriteItemRenderer;
     interaction?: {
         behavior: spec.InteractBehavior;
-    } | undefined;
-    listIndex: number;
-    parentId?: string;
-    reusable: boolean;
+    };
     cachePrefix: string;
     geoData: {
-        aPoint: number[] | TypedArray;
-        index: number[] | TypedArray;
+        atlasOffset: number[] | spec.TypedArray;
+        index: number[] | spec.TypedArray;
     };
-    mesh?: SpriteMesh;
     anchor?: vec2;
-    readonly feather?: ValueGetter<number>;
-    readonly textureSheetAnimation?: TextureSheetAnimation;
-    readonly splits: splitsDataType;
-    readonly startColor: vec4;
-    readonly emptyTexture: Texture;
-    private customColor;
-    private customOpacity;
-    private _filter?;
+    timelineComponent: TimelineComponent;
+    textureSheetAnimation?: spec.TextureSheetAnimation;
+    splits: splitsDataType;
+    emptyTexture: Texture;
+    color: vec4;
+    worldMatrix: Matrix4;
+    geometry: Geometry;
     /***********************/
-    private readonly colorOverLifetime;
-    private readonly opacityOverLifetime;
-    private readonly _renderInfo;
-    constructor(props: SpriteItemProps, opts: {
-        emptyTexture: Texture;
-    }, vfxItem: SpriteVFXItem);
-    get filter(): FilterDefine | undefined;
-    set filter(f: FilterDefine | undefined);
-    get renderInfo(): SpriteItemRenderInfo;
-    initTexture(texture: Texture, emptyTexture: Texture): Texture;
-    getTextures(): Texture[];
+    private renderInfo;
+    private readonly wireframe?;
+    private preMultiAlpha;
+    private visible;
+    constructor(engine: Engine, props?: SpriteItemProps);
     /**
-     * @internal
+     * 设置当前 Mesh 的可见性。
+     * @param visible - true：可见，false：不可见
      */
-    setColor(r: number, g: number, b: number, a: number): void;
-    setOpacity(opacity: number): void;
+    setVisible(visible: boolean): void;
+    /**
+     * 获取当前 Mesh 的可见性。
+     */
+    getVisible(): boolean;
+    render(renderer: Renderer): void;
+    start(): void;
+    update(dt: number): void;
+    onDestroy(): void;
+    private getItemInitData;
+    private setItem;
+    private createGeometry;
+    private createMaterial;
+    private getItemGeometryData;
+    getTextures(): Texture[];
     /**
-     * @internal
+     * 获取图层包围盒的类型和世界坐标
+     * @returns
      */
-    getCustomOpacity(): number;
-    getRenderData(_time: number, init?: boolean): SpriteRenderData;
-    protected calculateScaling(sizeChanged: boolean, sizeInc: Vector3, init?: boolean): void;
+    getBoundingBox(): BoundingBoxTriangle | void;
+    getHitTestParams: (force?: boolean) => HitTestTriangleParams | void;
+    fromData(data: SpriteItemProps): void;
+    toData(): void;
 }

package/dist/plugins/sprite/sprite-loader.d.ts

@@ -1,20 +1,8 @@
-import * as spec from '@galacean/effects-specification';
-import type { Composition } from '../../composition';
-import type { SpriteItem } from '../index';
-import { AbstractPlugin } from '../index';
-import { type VFXItem } from '../../vfx-item';
-import type { LayerInfo } from './sprite-group';
-import type { RenderFrame, Renderer } from '../../render';
+import type * as spec from '@galacean/effects-specification';
 import type { PrecompileOptions } from '../../plugin-system';
+import type { Renderer } from '../../render';
+import { AbstractPlugin } from '../index';
 export declare class SpriteLoader extends AbstractPlugin {
-    layerInfo?: LayerInfo;
     name: string;
     static precompile(compositions: spec.Composition[], render: Renderer, options?: PrecompileOptions): Promise<any>;
-    onCompositionDestroyed(composition: Composition): void;
-    onCompositionReset(composition: Composition, pipeline: RenderFrame): void;
-    onCompositionItemLifeBegin(composition: Composition, item: VFXItem<SpriteItem>): void;
-    onCompositionItemRemoved(composition: Composition, item: VFXItem<SpriteItem>): void;
-    onCompositionUpdate(composition: Composition, dt: number): void;
-    prepareRenderFrame(composition: Composition, renderFrame: RenderFrame): boolean;
-    postProcessFrame(composition: Composition, pipeline: RenderFrame): void;
 }

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

@@ -1,12 +1,8 @@
+import type { Vector3 } from '@galacean/effects-math/es/core/vector3';
 import type * as spec from '@galacean/effects-specification';
-import { Vector3 } from '@galacean/effects-math/es/core/index';
-import type { Composition } from '../../composition';
-import type { FilterShaderDefine } from '../../filter';
 import type { GPUCapabilityDetail, SharedShaderWithSource } from '../../render';
-import { Mesh } from '../../render';
 import type { Transform } from '../../transform';
-import type { SpriteItem, SpriteItemRenderInfo } from './sprite-item';
-import type { Engine } from '../../engine';
+import type { SpriteComponent, SpriteItemRenderInfo } from './sprite-item';
 export type SpriteRenderData = {
     life: number;
     transform: Transform;
@@ -25,37 +21,9 @@ export type SpriteRegionData = {
 };
 export declare let maxSpriteMeshItemCount: number;
 export declare let maxSpriteTextureCount: number;
-export declare class SpriteMesh {
-    engine: Engine;
-    private readonly composition;
-    items: SpriteItem[];
-    splitLayer: boolean;
-    readonly mesh: Mesh;
-    protected readonly lineMode: boolean;
-    private readonly wireframe?;
-    private dirty;
-    private preMultiAlpha;
-    private mtlSlotCount;
-    constructor(engine: Engine, renderInfo: SpriteItemRenderInfo, composition: Composition);
-    setItems(items: SpriteItem[]): true | undefined;
-    updateItem(item: SpriteItem, init?: boolean): void;
-    applyChange(): void;
-    getItemInitData(item: SpriteItem, idx: number, pointStartIndex: number, textureIndex: number): {
-        aPoint: spec.TypedArray | number[];
-        index: number[];
-    };
-    getItemRegionData(item: SpriteItem): SpriteRegionData | void;
-    invalidMaterial(): void;
-    private createGeometry;
-    private createMaterial;
-    getItemGeometryData(item: SpriteItem, aIndex: number): {
-        index: Uint16Array | number[];
-        aPoint: number[];
-    };
-}
 export declare function setSpriteMeshMaxItemCountByGPU(gpuCapability: GPUCapabilityDetail): 16 | 32 | undefined;
-export declare function getImageItemRenderInfo(item: SpriteItem): SpriteItemRenderInfo;
-export declare function spriteMeshShaderFromFilter(level: number, filter?: FilterShaderDefine, options?: {
+export declare function getImageItemRenderInfo(item: SpriteComponent): SpriteItemRenderInfo;
+export declare function spriteMeshShaderFromFilter(level: number, options?: {
     count?: number;
     ignoreBlend?: boolean;
     wireframe?: boolean;

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

@@ -1,21 +1,22 @@
 import * as spec from '@galacean/effects-specification';
-import { Texture } from '../../texture';
-import type { TextVFXItem } from './text-vfx-item';
-import { SpriteItem } from '../sprite/sprite-item';
-import { TextStyle } from './text-style';
+import type { Engine } from '../../engine';
+import type { SpriteItemProps } from '../sprite/sprite-item';
+import { SpriteComponent } from '../sprite/sprite-item';
 import { TextLayout } from './text-layout';
-export declare class TextItem extends SpriteItem {
+import { TextStyle } from './text-style';
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class TextComponent extends SpriteComponent {
     textStyle: TextStyle;
     isDirty: boolean;
     canvas: HTMLCanvasElement;
     context: CanvasRenderingContext2D | null;
     textLayout: TextLayout;
     text: string;
-    private engine;
     private char;
-    constructor(props: spec.TextContent, opts: {
-        emptyTexture: Texture;
-    }, vfxItem: TextVFXItem);
+    constructor(engine: Engine, props?: spec.TextContent);
     /**
      * 设置字号大小
      * @param value - 字号
@@ -106,11 +107,13 @@ export declare class TextItem extends SpriteItem {
      * @returns
      */
     setFontScale(value: number): void;
+    update(dt: number): void;
     /**
      * 更新文本
      * @returns
      */
     updateTexture(): void;
+    fromData(data: SpriteItemProps): void;
     private getFontDesc;
     private setupOutline;
     private setupShadow;

package/dist/plugins/text/text-loader.d.ts

@@ -1,18 +1,3 @@
-import type { Composition } from '../../composition';
 import { AbstractPlugin } from '../index';
-import type { VFXItem } from '../../vfx-item';
-import type { Mesh, RenderFrame } from '../../render';
-import type { TextItem } from './text-item';
-import { TextVFXItem } from './text-vfx-item';
 export declare class TextLoader extends AbstractPlugin {
-    name: string;
-    addItems: TextVFXItem[];
-    removeItems: TextVFXItem[];
-    readonly meshes: Mesh[];
-    onCompositionDestroyed(composition: Composition): void;
-    onCompositionUpdate(composition: Composition, dt: number): void;
-    onCompositionItemLifeBegin(composition: Composition, item: VFXItem<TextItem>): void;
-    onCompositionReset(composition: Composition, pipeline: RenderFrame): void;
-    onCompositionItemRemoved(composition: Composition, item: VFXItem<TextItem>): void;
-    prepareRenderFrame(composition: Composition, renderFrame: RenderFrame): boolean;
 }

package/dist/render/geometry.d.ts

@@ -1,6 +1,6 @@
 import type * as spec from '@galacean/effects-specification';
-import type { Disposable } from '../utils';
 import type { Engine } from '../engine';
+import { EffectsObject } from '../effects-object';
 export declare const BYTES_TYPE_MAP: Record<string, number>;
 /**
  * Geometry 的绘制模式
@@ -27,20 +27,15 @@ export interface GeometryProps {
 /**
  * Geometry 抽象类
  */
-export declare abstract class Geometry implements Disposable {
+export declare abstract class Geometry extends EffectsObject {
     /**
      * Geometry 的名称
      */
-    readonly name: string;
+    name: string;
     /**
      * Geometry 创建函数
-     * @param name - 名称
      */
-    constructor(name: string);
-    /**
-     * Geometry 创建函数
-     */
-    static create: (engine: Engine, opts: GeometryProps) => Geometry;
+    static create: (engine: Engine, opts?: GeometryProps) => Geometry;
     /**
      * 获取 Geometry 的 attribute 数据。
      * @param name - attribute 名称
@@ -76,7 +71,7 @@ export declare abstract class Geometry implements Disposable {
      * 设置 Geometry 的 indices 数据。
      * @param data - 要设置的 indices 数据
      */
-    abstract setIndexData(data?: spec.TypedArray): void;
+    abstract setIndexData(data: spec.TypedArray): void;
     /**
      * 设置 indices 的部分数据，当 indices 数据只有部分更新时，可调用此函数。
      * @param offset - 更新数据在 indices 数组的起始位置 index
@@ -101,10 +96,6 @@ export declare abstract class Geometry implements Disposable {
      * 获取当前 Geometry 的 drawcount
      */
     abstract getDrawCount(): number;
-    /**
-     * 销毁当前资源
-     */
-    abstract dispose(): void;
     /**
      * 初始化 GPU 资源
      * @override

package/dist/render/mesh.d.ts

@@ -4,6 +4,7 @@ import type { Material, MaterialDestroyOptions } from '../material';
 import type { Geometry, Renderer } from '../render';
 import type { Disposable } from '../utils';
 import { DestroyOptions } from '../utils';
+import { RendererComponent } from '../components/renderer-component';
 export interface MeshOptionsBase {
     material: Material;
     name?: string;
@@ -20,49 +21,37 @@ export interface MeshDestroyOptions {
 /**
  * Mesh 抽象类
  */
-export declare class Mesh implements Disposable {
-    private engine;
+export declare class Mesh extends RendererComponent implements Disposable {
     /**
      * Mesh 的全局唯一 id
      */
     readonly id: string;
-    /**
-     * Mesh 名称，缺省是 \<unnamed>
-     */
-    readonly name: string;
     /**
      * Mesh 的世界矩阵
      */
     worldMatrix: Matrix4;
-    /**
-     * Mesh 的材质
-     */
-    material: Material;
     /**
      * Mesh 的 Geometry
      */
     geometry: Geometry;
     protected destroyed: boolean;
-    private _priority;
     private visible;
     /**
      * 创建一个新的 Mesh 对象。
      */
-    static create: (engine: Engine, props: GeometryMeshProps) => Mesh;
-    constructor(engine: Engine, props: GeometryMeshProps);
-    get priority(): number;
-    set priority(value: number);
+    static create: (engine: Engine, props?: GeometryMeshProps) => Mesh;
+    constructor(engine: Engine, props?: GeometryMeshProps);
     get isDestroyed(): boolean;
     /**
      * 设置当前 Mesh 的可见性。
      * @param visible - true：可见，false：不可见
      */
     setVisible(visible: boolean): void;
-    render(renderer: Renderer): void;
     /**
      * 获取当前 Mesh 的可见性。
      */
     getVisible(): boolean;
+    render(renderer: Renderer): void;
     /**
      * 获取当前 Mesh 的第一个 geometry。
      */

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

@@ -14,6 +14,7 @@ import type { RenderPassClearAction, RenderPassColorAttachmentOptions, RenderPas
 import { RenderPass } from './render-pass';
 import type { Renderer } from './renderer';
 import type { GlobalVolume } from './global-volume';
+import type { RendererComponent } from '../components';
 /**
  * 渲染数据，保存了当前渲染使用到的数据。
  */
@@ -169,6 +170,7 @@ export declare class RenderFrame implements Disposable {
     resource: RenderFrameResource;
     keepColorBuffer?: boolean;
     editorTransform: Vector4;
+    renderQueue: RendererComponent[];
     /**
      * 名称
      */
@@ -195,19 +197,13 @@ export declare class RenderFrame implements Disposable {
      * 根据 Mesh 优先级添加到 RenderPass
      * @param mesh - 要添加的 Mesh 对象
      */
-    addMeshToDefaultRenderPass(mesh: Mesh): void;
+    addMeshToDefaultRenderPass(mesh?: RendererComponent): void;
     /**
      * 把 Mesh 从 RenderPass 中移除，
      * 如果 renderPass 中没有 mesh，此 renderPass 会被删除
      * @param mesh - 要删除的 Mesh 对象
      */
     removeMeshFromDefaultRenderPass(mesh: Mesh): void;
-    /**
-     * 将 Mesh 所有在 RenderPass 进行切分
-     * @param mesh - 目标 Mesh 对象
-     * @param options - 切分选项，包含 RenderPass 相关的 Attachment 等数据
-     */
-    splitDefaultRenderPassByMesh(mesh: Mesh, options: RenderPassSplitOptions): RenderPass;
     /**
      * 销毁 RenderFrame
      * @param options - 可以有选择销毁一些对象
@@ -227,7 +223,6 @@ export declare class RenderFrame implements Disposable {
     protected addToRenderPass(renderPass: RenderPass, mesh: Mesh): void;
     protected getRPAttachments(attachments: RenderPassColorAttachmentOptions[], preRP?: RenderPass): RenderPassColorAttachmentOptions[];
     protected resetClearActions(): void;
-    protected updateRenderInfo(renderPass: RenderPass): RenderPassInfo;
     /**
      * 设置 RenderPass 数组，直接修改内部的 RenderPass 数组
      * @param passes - RenderPass 数组