@galacean/effects-core 2.8.0-alpha.1 → 2.8.0-alpha.3

package/dist/plugin-system.d.ts

@@ -1,12 +1,8 @@
-import type * as spec from '@galacean/effects-specification';
 import type { Composition } from './composition';
-import type { Plugin, PluginConstructor } from './plugins';
-import type { RenderFrame, Renderer } from './render';
+import type { AbstractPlugin, PluginConstructor } from './plugins';
 import type { Scene, SceneLoadOptions } from './scene';
-import type { Constructor } from './utils';
-import type { VFXItem } from './vfx-item';
+import type { Engine } from './engine';
 export declare const pluginLoaderMap: Record<string, PluginConstructor>;
-export declare const defaultPlugins: string[];
 /**
  * 注册 plugin
  * @param name
@@ -14,20 +10,16 @@ export declare const defaultPlugins: string[];
  * @param itemClass class of item
  * @param isDefault load
  */
-export declare function registerPlugin(name: string, pluginClass: PluginConstructor, itemClass: Constructor<VFXItem>): void;
+export declare function registerPlugin(name: string, pluginClass: PluginConstructor): void;
+/**
+ * 注销 plugin
+ */
 export declare function unregisterPlugin(name: string): void;
 export declare class PluginSystem {
-    readonly plugins: Plugin[];
-    constructor(pluginNames: string[]);
-    initializeComposition(composition: Composition, scene: Scene): void;
-    destroyComposition(comp: Composition): void;
-    resetComposition(comp: Composition, renderFrame: RenderFrame): void;
-    processRawJSON(json: spec.JSONScene, options: SceneLoadOptions): Promise<void[]>;
-    processAssets(json: spec.JSONScene, options?: SceneLoadOptions): Promise<{
-        assets: spec.AssetBase[];
-        loadedAssets: unknown[];
-    }[]>;
-    precompile(compositions: spec.CompositionData[], renderer: Renderer): void;
-    loadResources(scene: Scene, options: SceneLoadOptions): Promise<unknown[]>;
-    private callStatic;
+    static getPlugins(): AbstractPlugin[];
+    static initializeComposition(composition: Composition, scene: Scene): void;
+    static destroyComposition(comp: Composition): void;
+    static processAssets(scene: Scene, options?: SceneLoadOptions): Promise<void[]>;
+    static loadResources(scene: Scene, options: SceneLoadOptions, engine: Engine): void;
 }
+export declare function getPluginUsageInfo(name: string): string;

package/dist/plugins/plugin.d.ts

@@ -1,92 +1,36 @@
-import type * as spec from '@galacean/effects-specification';
 import type { Scene, SceneLoadOptions } from '../scene';
-import type { RenderFrame, Renderer } from '../render';
 import type { Composition } from '../composition';
-export interface Plugin {
-    /**
-     * plugin 的数组内排序，按照升序排列
-     * @default 100
-     */
-    order: number;
-    name: string;
-    /**
-     * 在加载到 JSON 后，就可以进行提前编译
-     * @param json
-     * @param player
-     */
-    precompile: (compositions: spec.CompositionData[], renderer: Renderer) => void;
-    /**
-     * 合成创建时调用，用于触发元素在合成创建时的回调
-     * @param composition
-     * @param scene
-     */
-    onCompositionConstructed: (composition: Composition, scene: Scene) => void;
-    /**
-     * 合成重播时的回调
-     * @param composition
-     * @param frame
-     */
-    onCompositionReset: (composition: Composition, frame: RenderFrame) => void;
-    /**
-     * 合成销毁时的会调，需要销毁 composition 中对应的资源
-     * @param composition
-     */
-    onCompositionDestroyed: (composition: Composition) => void;
-    /**
-     * 合成更新时的回调，每帧都会进行调用，在每个元素调用 onUpdate 之前被触发
-     * @param composition
-     * @param dt 更新的毫秒
-     */
-    onCompositionUpdate: (composition: Composition, dt: number) => void;
-}
+import type { Engine } from '../engine';
 export interface PluginConstructor {
-    new (): Plugin;
+    new (): AbstractPlugin;
     [key: string]: any;
 }
 /**
  * 抽象插件类
  * 注册合成不同生命周期的回调函数
  */
-export declare abstract class AbstractPlugin implements Plugin {
+export declare abstract class AbstractPlugin {
     order: number;
     name: string;
-    /***
-     * loadScene 函数调用的时候会触发此函数，
-     * 此阶段可以对资源 JSON 进行处理，替换调 JSON 中的数据，或者直接终止加载流程
-     * 一旦被 reject，加载过程将失败
-     * @param json 动画资源
-     * @param options 加载参数
-     */
-    static processRawJSON: (json: spec.JSONScene, options: SceneLoadOptions) => Promise<void>;
+    initialize(): void;
     /**
      * loadScene 函数调用的时候会触发此函数，
      * 此阶段可以加载插件所需类型资源，并返回原始资源和加载后的资源。
-     * @param json
+     * @param scene
      * @param options
      * @returns
      */
-    static processAssets: (json: spec.JSONScene, options?: SceneLoadOptions) => Promise<{
-        assets: spec.AssetBase[];
-        loadedAssets: unknown[];
-    }>;
+    processAssets(scene: Scene, options?: SceneLoadOptions): Promise<void>;
     /**
      * loadScene 函数调用的时候会触发此函数，
      * 此阶段时，json 中的图片和二进制已经被加载完成，可以对加载好的资源做进一步处理，
      * 如果 promise 被 reject, loadScene 函数同样会被 reject，表示场景加载失败。
      * 请记住，整个 load 阶段都不要创建 GL 相关的对象，只创建 JS 对象
-     * 此阶段晚于 processRawJSON
+     * 此阶段晚于 processAssets
      * @param {Scene} scene
      * @param {SceneLoadOptions} options
      */
-    static prepareResource: (scene: Scene, options: SceneLoadOptions) => Promise<void>;
-    /**
-     * 在加载到 JSON 后，就可以进行提前编译
-     * @param json
-     * @param player
-     */
-    precompile(compositions: spec.CompositionData[], renderer: Renderer): void;
+    prepareResource(scene: Scene, options: SceneLoadOptions, engine: Engine): void;
     onCompositionConstructed(composition: Composition, scene: Scene): void;
-    onCompositionReset(composition: Composition, frame: RenderFrame): void;
     onCompositionDestroyed(composition: Composition): void;
-    onCompositionUpdate(composition: Composition, dt: number): void;
 }

package/dist/render/create-copy-shader.d.ts

@@ -1,6 +1,4 @@
-import type { SharedShaderWithSource } from './shader';
 export declare const EFFECTS_COPY_MESH_NAME = "effects-internal-copy";
 export declare const COPY_MESH_SHADER_ID = "effects-internal-copy-mesh";
 export declare const COPY_VERTEX_SHADER = "\nprecision highp float;\nattribute vec2 aPos;\nvarying vec2 vTex;\nvoid main(){\n    gl_Position = vec4(aPos,0.,1.0);\n    vTex = (aPos + vec2(1.0))/2.;\n}";
 export declare const COPY_FRAGMENT_SHADER = "precision mediump float;\nvarying vec2 vTex;\n\n#ifdef DEPTH_TEXTURE\nuniform sampler2D uDepth;\n#extension GL_EXT_frag_depth : enable\n#endif\nvoid main(){\n    #ifdef DEPTH_TEXTURE\n    gl_FragDepthEXT = texture2D(uDepth,vTex).r;\n    #endif\n}\n";
-export declare function createCopyShader(level: number, writeDepth?: boolean): SharedShaderWithSource;

package/dist/render/draw-object-pass.d.ts

@@ -1,9 +1,10 @@
-import type { RenderPassDestroyOptions, RenderPassOptions } from './render-pass';
 import { RenderPass } from './render-pass';
 import type { Renderer } from './renderer';
 export declare class DrawObjectPass extends RenderPass {
-    constructor(renderer: Renderer, options: RenderPassOptions);
+    private useRenderTarget;
+    constructor(renderer: Renderer);
+    setup(useRenderTarget: boolean): void;
+    configure(renderer: Renderer): void;
     execute(renderer: Renderer): void;
-    onResize(): void;
-    dispose(options?: RenderPassDestroyOptions): void;
+    onCameraCleanup(renderer: Renderer): void;
 }

package/dist/render/index.d.ts

@@ -2,6 +2,7 @@ export * from './create-copy-shader';
 export * from './render-frame';
 export * from './renderbuffer';
 export * from './render-pass';
+export * from './render-target-pool';
 export * from './shader';
 export * from './gpu-capability';
 export * from './mesh';

package/dist/render/post-process-pass.d.ts

@@ -1,39 +1,20 @@
-import type { RenderPassDestroyOptions, RenderPassOptions } from './render-pass';
+import type { RenderPassDestroyOptions } from './render-pass';
 import { RenderTargetHandle, RenderPass } from './render-pass';
 import type { Renderer } from './renderer';
-export declare class BloomThresholdPass extends RenderPass {
+export declare class BloomPass extends RenderPass {
     sceneTextureHandle: RenderTargetHandle;
+    private readonly iterationCount;
+    private thresholdMaterial;
+    private downSampleHMaterial;
+    private downSampleVMaterial;
+    private upSampleMaterial;
+    private tempRTs;
+    private thresholdRT;
     private mainTexture;
-    private screenMesh;
-    constructor(renderer: Renderer, option: RenderPassOptions);
-    configure(renderer: Renderer): void;
-    execute(renderer: Renderer): void;
-    private onResize;
-    dispose(options?: RenderPassDestroyOptions): void;
-}
-export declare class HQGaussianDownSamplePass extends RenderPass {
-    gaussianResult: RenderTargetHandle;
-    private mainTexture;
-    private screenMesh;
-    private readonly type;
-    private readonly level;
-    constructor(renderer: Renderer, type: 'V' | 'H', level: number, options: RenderPassOptions);
-    initialize(renderer: Renderer): RenderPass;
-    configure(renderer: Renderer): void;
-    execute(renderer: Renderer): void;
-    private onResize;
-    dispose(options?: RenderPassDestroyOptions | undefined): void;
-}
-export declare class HQGaussianUpSamplePass extends RenderPass {
-    gaussianDownSampleResult: RenderTargetHandle;
-    private mainTexture;
-    private screenMesh;
-    private readonly level;
-    constructor(renderer: Renderer, level: number, options: RenderPassOptions);
-    initialize(renderer: Renderer): RenderPass;
+    constructor(renderer: Renderer, iterationCount?: number);
     configure(renderer: Renderer): void;
     execute(renderer: Renderer): void;
-    private onResize;
+    onCameraCleanup(renderer: Renderer): void;
     dispose(options?: RenderPassDestroyOptions): void;
 }
 export declare class ToneMappingPass extends RenderPass {

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

@@ -5,16 +5,11 @@ import { Vector4 } from '@galacean/effects-math/es/core/vector4';
 import type { vec4 } from '@galacean/effects-specification';
 import type { Camera } from '../camera';
 import type { PostProcessVolume, RendererComponent } from '../components';
-import type { UniformValue } from '../material';
-import { PassTextureCache } from '../paas-texture-cache';
 import type { Texture } from '../texture';
 import type { Disposable } from '../utils';
 import { DestroyOptions } from '../utils';
-import type { Mesh } from './mesh';
-import type { RenderPass, RenderPassClearAction, RenderPassColorAttachmentOptions, RenderPassDepthStencilAttachment, RenderPassDestroyOptions, RenderPassStoreAction } from './render-pass';
+import type { RenderPass, RenderPassDestroyOptions } from './render-pass';
 import type { Renderer } from './renderer';
-import type { SemanticFunc } from './semantic-map';
-import { SemanticMap } from './semantic-map';
 /**
  * 渲染数据，保存了当前渲染使用到的数据。
  */
@@ -32,72 +27,6 @@ export interface RenderingData {
      */
     currentPass: RenderPass;
 }
-/**
- * RenderPass 信息，记录了 RenderFrame 中 RenderPass 的信息
- */
-export interface RenderPassInfo {
-    /**
-     * 内部包含 Mesh 中最小优先级
-     */
-    listStart: number;
-    /**
-     * 内部包含 Mesh 中最大优先级
-     */
-    listEnd: number;
-    /**
-     * 是否绑定 Framebuffer 对象
-     */
-    intermedia: boolean;
-    /**
-     * RenderPass 对象
-     */
-    renderPass: RenderPass;
-    /**
-     * 前面的 RenderPass 对象数组
-     */
-    prePasses?: {
-        pass: RenderPass;
-        destroyOptions?: RenderPassDestroyOptions | boolean;
-    }[];
-    /**
-     * 前一个 RenderPass 对象
-     */
-    preRenderPass?: RenderPass;
-}
-/**
- * RenderFrame 内部保存的多 Pass 相关资源
- */
-export interface RenderFrameResource {
-    /**
-     * 纹理对象，用于 Framebuffer 的颜色 Attachment
-     */
-    color_a: Texture;
-    /**
-     * 纹理对象，用于 Framebuffer 的颜色 Attachment
-     */
-    color_b: Texture;
-    /**
-     * 拷贝 RenderPass 对象，将前 RenderPass 的渲染结果拷贝到硬件帧缓存中
-     */
-    finalCopyRP: RenderPass;
-    /**
-     * 资源 RenderPass 对象，为临时生成的 RenderPass 提供 Attachment 资源
-     */
-    resRP: RenderPass;
-    /**
-     * 深度和蒙版，为临时生成的 RenderPass 提供 Attachment 资源
-     */
-    depthStencil?: RenderPassDepthStencilAttachment;
-}
-/**
- * RenderPass 切分时的参数
- */
-export interface RenderPassSplitOptions {
-    attachments?: RenderPassColorAttachmentOptions[];
-    storeAction?: RenderPassStoreAction;
-    prePasses?: RenderPass[];
-}
-export declare const RENDER_PASS_NAME_PREFIX = "_effects_default_";
 /**
  * 抽象 RenderFrame 选项
  */
@@ -107,23 +36,6 @@ export interface RenderFrameOptions {
      * 编辑器整体变换，Player 开发不需要关注
      */
     editorTransform?: vec4;
-    /**
-     * 是否每次渲染时清除 RenderFrame 颜色缓存
-     */
-    keepColorBuffer?: boolean;
-    /**
-     * 渲染视口大小
-     */
-    viewport?: vec4;
-    /**
-     * RenderFrame 范围内共用的 Shader Uniform 变量，
-     * 以及多 Pass 渲染时 ColorAttachment 关联到后面的 Shader Uniform 上
-     */
-    semantics?: Record<string, UniformValue | SemanticFunc>;
-    /**
-     * 每个 RenderPass 使用前进行的 Clear 操作
-     */
-    clearAction?: RenderPassClearAction;
     /**
      * 后处理渲染配置
      */
@@ -150,45 +62,32 @@ export declare class RenderFrame implements Disposable {
      * 当前使用的全部 RenderPass
      */
     _renderPasses: RenderPass[];
-    /**
-     * RenderPass 清除帧缓存操作
-     */
-    clearAction: RenderPassClearAction;
-    /**
-     * 滤镜中 RenderPass 用到的纹理缓存器
-     */
-    passTextureCache: PassTextureCache;
     /**
      * 渲染时的相机
      */
     camera: Camera;
-    /**
-     * Composition中用到的所有纹理缓存
-     */
-    cachedTextures: Texture[];
     /**
      * 存放后处理的属性设置
      */
     globalVolume?: PostProcessVolume;
     renderer: Renderer;
-    keepColorBuffer?: boolean;
     editorTransform: Vector4;
-    renderQueue: RendererComponent[];
     /**
      * 名称
      */
     readonly name: string;
-    /**
-     * 公用 Uniform 变量表
-     */
-    readonly semantics: SemanticMap;
     readonly globalUniforms: GlobalUniforms;
-    protected destroyed: boolean;
-    protected renderPassInfoMap: WeakMap<RenderPass, RenderPassInfo>;
+    private disposed;
     private drawObjectPass;
+    private postProcessingEnabled;
+    private enableHDR;
     constructor(options: RenderFrameOptions);
     get renderPasses(): RenderPass[];
-    get isDestroyed(): boolean;
+    get isDisposed(): boolean;
+    /**
+     * 设置 RenderPasses 参数，此函数每帧调用一次
+     */
+    setup(): void;
     /**
      * 根据 Mesh 优先级添加到 RenderPass
      * @param mesh - 要添加的 Mesh 对象
@@ -205,13 +104,6 @@ export declare class RenderFrame implements Disposable {
      * @param options - 可以有选择销毁一些对象
      */
     dispose(options?: RenderFrameDestroyOptions): void;
-    /**
-     * 查找 Mesh 所在的 RenderPass 索引，没找到是-1
-     * @param mesh - 需要查找的 Mesh
-     */
-    findMeshRenderPassIndex(mesh: Mesh): number;
-    protected addToRenderPass(renderPass: RenderPass, mesh: Mesh): void;
-    protected resetClearActions(): void;
     /**
      * 设置 RenderPass 数组，直接修改内部的 RenderPass 数组
      * @param passes - RenderPass 数组
@@ -229,7 +121,6 @@ export declare class RenderFrame implements Disposable {
     removeRenderPass(pass: RenderPass): void;
 }
 export declare function getTextureSize(tex?: Texture): Vector2;
-export declare function findPreviousRenderPass(renderPasses: RenderPass[], renderPass: RenderPass): RenderPass | undefined;
 export declare class GlobalUniforms {
     floats: Record<string, number>;
     ints: Record<string, number>;

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

@@ -1,14 +1,13 @@
 import type * as spec from '@galacean/effects-specification';
 import type { vec4 } from '@galacean/effects-specification';
-import type { Camera } from '../camera';
 import type { RendererComponent } from '../components';
 import type { Engine } from '../engine';
 import type { MeshDestroyOptions, Renderer } from '../render';
-import { Framebuffer } from '../render';
+import type { Framebuffer } from '../render';
 import type { TextureConfigOptions, TextureLoadAction } from '../texture';
 import { Texture } from '../texture';
 import type { Disposable, Sortable } from '../utils';
-import { DestroyOptions, OrderType } from '../utils';
+import { DestroyOptions } from '../utils';
 import type { Renderbuffer } from './renderbuffer';
 export declare const RenderPassPriorityPrepare = 0;
 export declare const RenderPassPriorityNormal = 1000;
@@ -97,11 +96,6 @@ export declare class RenderTargetHandle implements Disposable {
     get width(): number;
     get height(): number;
 }
-export interface RenderPassDepthStencilAttachment {
-    readonly storageType: RenderPassAttachmentStorageType;
-    readonly storage?: Renderbuffer;
-    readonly texture?: Texture;
-}
 export interface RenderPassDepthStencilAttachmentOptions {
     storageType: RenderPassAttachmentStorageType;
     storage?: Renderbuffer;
@@ -133,10 +127,6 @@ export type RenderPassDestroyOptions = {
     colorAttachment?: RenderPassDestroyAttachmentType;
     depthStencilAttachment?: RenderPassDestroyAttachmentType;
 };
-export interface RenderPassOptions {
-    attachments?: RenderPassColorAttachmentOptions[];
-    depthStencilAttachment?: RenderPassDepthStencilAttachmentOptions;
-}
 /**
  * RenderPass 抽象类
  */
@@ -145,11 +135,6 @@ export declare class RenderPass implements Disposable, Sortable {
      * 优先级
      */
     priority: number;
-    /**
-     * ColorAttachment 数组
-     */
-    attachments: RenderTargetHandle[];
-    framebuffer: Framebuffer | null;
     /**
      * 名称
      */
@@ -158,36 +143,14 @@ export declare class RenderPass implements Disposable, Sortable {
      * 包含的 Mesh 列表
      */
     readonly meshes: RendererComponent[];
-    /**
-     * Mesh 渲染顺序，按照优先级升序或降序
-     */
-    readonly meshOrder: OrderType;
-    /**
-     * 相机
-     */
-    readonly camera?: Camera;
-    /**
-     * 深度和蒙版 Attachment 类型，注意区分纹理和 Renderbuffer
-     */
-    readonly depthStencilType: RenderPassAttachmentStorageType;
-    /**
-     * 渲染后清除缓冲区操作，iOS 上有性能提升, 默认关闭
-     */
-    readonly storeAction: RenderPassStoreAction;
     protected disposed: boolean;
-    protected options: RenderPassOptions;
+    protected framebuffer: Framebuffer | null;
     protected renderer: Renderer;
-    private initialized;
-    private depthTexture?;
-    private stencilTexture?;
-    constructor(renderer: Renderer, options: RenderPassOptions);
-    get isDestroyed(): boolean;
+    constructor(renderer: Renderer);
+    get isDisposed(): boolean;
     get viewport(): spec.vec4;
-    get stencilAttachment(): RenderPassDepthStencilAttachment | undefined;
-    get depthAttachment(): RenderPassDepthStencilAttachment | undefined;
     addMesh(mesh: RendererComponent): void;
     removeMesh(mesh: RendererComponent): void;
-    setMeshes(meshes: RendererComponent[]): RendererComponent[];
     /**
      * 配置当前pass的RT，在每帧渲染前调用
      */
@@ -197,25 +160,13 @@ export declare class RenderPass implements Disposable, Sortable {
      */
     execute(renderer: Renderer): void;
     /**
-     * 每帧所有的pass渲染完后调用，通常用于清空临时的RT资源
+     * 每帧所有的pass渲染完后调用，用于清空临时的RT资源
      */
-    frameCleanup(renderer: Renderer): void;
-    private _resetAttachments;
+    onCameraCleanup(renderer: Renderer): void;
     /**
      * 获取当前视口大小，格式：[x偏移，y偏移，宽度，高度]
      */
     getViewport(): vec4;
-    /**
-     * 获取深度 Attachment，可能没有
-     */
-    getDepthAttachment(): RenderPassDepthStencilAttachment | undefined;
-    /**
-     * 获取蒙版 Attachment，可能没有
-     */
-    getStencilAttachment(): RenderPassDepthStencilAttachment | undefined;
-    private getDepthTexture;
-    private getStencilTexture;
-    initialize(renderer: Renderer): RenderPass;
     /**
      * 销毁 RenderPass
      * @param options - 有选择销毁内部对象

package/dist/render/render-target-pool.d.ts

@@ -0,0 +1,22 @@
+import type { Engine } from '../engine';
+import { FilterMode, Framebuffer, RenderTextureFormat } from './framebuffer';
+export declare class RenderTargetPool {
+    engine: Engine;
+    private temporaryRTs;
+    private currentFrame;
+    private readonly maxUnusedFrames;
+    constructor(engine: Engine);
+    /**
+     * 清理 RenderTarget 池
+     * @param force - 是否强制清理所有未占用的 RT
+     * @param framesOffset - 自定义未使用帧数阈值，-1 表示使用默认值
+     */
+    flush(force?: boolean, framesOffset?: number): void;
+    get(name: string, width: number, height: number, depthBuffer?: number, filter?: FilterMode, format?: RenderTextureFormat): Framebuffer;
+    /**
+     * 释放 RenderTarget，使其可以被复用
+     * @param rt - 要释放的 Framebuffer
+     */
+    release(rt: Framebuffer): void;
+    dispose(): void;
+}

package/dist/render/renderer.d.ts

@@ -6,16 +6,19 @@ import type { LostHandler, RestoreHandler } from '../utils';
 import type { FilterMode, Framebuffer, RenderTextureFormat } from './framebuffer';
 import type { Geometry } from './geometry';
 import type { RenderFrame, RenderingData } from './render-frame';
-import type { RenderPassClearAction, RenderPassStoreAction } from './render-pass';
+import type { RenderPassClearAction } from './render-pass';
 import type { ShaderLibrary } from './shader';
+import { RenderTargetPool } from './render-target-pool';
+import type { Texture } from '../texture';
 export declare class Renderer implements LostHandler, RestoreHandler {
-    static create: (engine: Engine) => Renderer;
     engine: Engine;
+    static create: (engine: Engine) => Renderer;
     /**
     * 存放渲染需要用到的数据
     */
     renderingData: RenderingData;
-    protected currentFramebuffer: Framebuffer;
+    renderTargetPool: RenderTargetPool;
+    protected currentFramebuffer: Framebuffer | null;
     constructor(engine: Engine);
     setGlobalFloat(name: string, value: number): void;
     setGlobalInt(name: string, value: number): void;
@@ -26,7 +29,7 @@ export declare class Renderer implements LostHandler, RestoreHandler {
     setFramebuffer(framebuffer: Framebuffer | null): void;
     setViewport(x: number, y: number, width: number, height: number): void;
     resize(canvasWidth: number, canvasHeight: number): void;
-    clear(action: RenderPassClearAction | RenderPassStoreAction): void;
+    clear(action: RenderPassClearAction): void;
     getWidth(): number;
     getHeight(): number;
     /**
@@ -47,6 +50,14 @@ export declare class Renderer implements LostHandler, RestoreHandler {
     renderRenderFrame(renderFrame: RenderFrame): void;
     renderMeshes(meshes: RendererComponent[]): void;
     drawGeometry(geometry: Geometry, matrix: Matrix4, material: Material, subMeshIndex?: number): void;
-    getTemporaryRT(name: string, width: number, height: number, depthBuffer: number, filter: FilterMode, format: RenderTextureFormat): Framebuffer | null;
+    getTemporaryRT(name: string, width: number, height: number, depthBuffer: number, filter: FilterMode, format: RenderTextureFormat): Framebuffer;
+    releaseTemporaryRT(rt: Framebuffer): void;
+    /**
+     * 将源纹理复制到目标 Framebuffer，可使用自定义材质进行处理
+     * @param source - 源纹理
+     * @param destination - 目标 Framebuffer，如果为 null 则渲染到屏幕
+     * @param material - 可选的自定义材质，不传则使用默认复制材质
+     */
+    blit(source: Texture, destination: Framebuffer | null, material?: Material): void;
     dispose(): void;
 }

package/dist/scene.d.ts

@@ -1,6 +1,5 @@
 import type * as spec from '@galacean/effects-specification';
 import type { Texture } from './texture';
-import type { PluginSystem } from './plugin-system';
 import type { PickEnum } from './utils';
 export type ImageLike = spec.HTMLImageLike | ArrayBuffer | Texture;
 export type SceneRenderLevel = PickEnum<spec.RenderLevel, spec.RenderLevel.A | spec.RenderLevel.B | spec.RenderLevel.S>;
@@ -10,9 +9,8 @@ export type SceneRenderLevel = PickEnum<spec.RenderLevel, spec.RenderLevel.A | s
 export interface Scene {
     readonly jsonScene: spec.JSONScene;
     readonly bins: ArrayBuffer[];
-    readonly pluginSystem: PluginSystem;
-    readonly renderLevel?: SceneRenderLevel;
     readonly storage: Record<string, any>;
+    renderLevel?: SceneRenderLevel;
     textureOptions: Record<string, any>[];
     textures: Texture[];
     images: ImageLike[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/effects-core",
-  "version": "2.8.0-alpha.1",
+  "version": "2.8.0-alpha.3",
   "description": "Galacean Effects runtime core for the web",
   "module": "./dist/index.mjs",
   "main": "./dist/index.js",