@galacean/effects-core 2.8.0-alpha.2 → 2.8.0-alpha.4

package/dist/index.js

@@ -3,7 +3,7 @@
  * Description: Galacean Effects runtime core for the web
  * Author: Ant Group CO., Ltd.
  * Contributors: 燃然,飂兮,十弦,云垣,茂安,意绮
- * Version: v2.8.0-alpha.2
+ * Version: v2.8.0-alpha.4
  */
 
 'use strict';
@@ -2883,7 +2883,6 @@ var plugins = [];
     pluginLoaderMap[name] = pluginClass;
     var pluginInstance = new pluginClass();
     pluginInstance.name = name;
-    pluginInstance.initialize();
     plugins.push(pluginInstance);
     plugins.sort(function(a, b) {
         return a.order - b.order;
@@ -2907,29 +2906,29 @@ var PluginSystem = /*#__PURE__*/ function() {
     };
     PluginSystem.initializeComposition = function initializeComposition(composition, scene) {
         plugins.forEach(function(loader) {
-            return loader.onCompositionConstructed(composition, scene);
+            return loader.onCompositionCreated(composition, scene);
         });
     };
     PluginSystem.destroyComposition = function destroyComposition(comp) {
         plugins.forEach(function(loader) {
-            return loader.onCompositionDestroyed(comp);
+            return loader.onCompositionDestroy(comp);
         });
     };
-    PluginSystem.processAssets = function processAssets(scene, options) {
+    PluginSystem.onAssetsLoadStart = function onAssetsLoadStart(scene, options) {
         return _async_to_generator(function() {
             return __generator(this, function(_state) {
                 return [
                     2,
                     Promise.all(plugins.map(function(plugin) {
-                        return plugin.processAssets(scene, options);
+                        return plugin.onAssetsLoadStart(scene, options);
                     }))
                 ];
             });
         })();
     };
-    PluginSystem.loadResources = function loadResources(scene, options, engine) {
+    PluginSystem.onAssetsLoadFinish = function onAssetsLoadFinish(scene, options, engine) {
         plugins.forEach(function(loader) {
-            return loader.prepareResource(scene, options, engine);
+            return loader.onAssetsLoadFinish(scene, options, engine);
         });
     };
     return PluginSystem;
@@ -2959,20 +2958,18 @@ function getPluginUsageInfo(name) {
 /**
  * 抽象插件类
  * 注册合成不同生命周期的回调函数
- */ var AbstractPlugin = /*#__PURE__*/ function() {
-    function AbstractPlugin() {
+ */ var Plugin = /*#__PURE__*/ function() {
+    function Plugin() {
         this.order = 100;
-        this.name = "";
+        this.name = "Plugin";
     }
-    var _proto = AbstractPlugin.prototype;
-    _proto.initialize = function initialize() {};
+    var _proto = Plugin.prototype;
     /**
-   * loadScene 函数调用的时候会触发此函数，
-   * 此阶段可以加载插件所需类型资源，并返回原始资源和加载后的资源。
-   * @param scene
-   * @param options
-   * @returns
-   */ _proto.processAssets = function processAssets(scene, options) {
+   * 场景加载时触发，用于加载插件所需的自定义资源。
+   * 此阶段适合发起异步资源请求。
+   * @param scene - 场景对象
+   * @param options - 场景加载选项
+   */ _proto.onAssetsLoadStart = function onAssetsLoadStart(scene, options) {
         return _async_to_generator(function() {
             return __generator(this, function(_state) {
                 return [
@@ -2982,17 +2979,22 @@ function getPluginUsageInfo(name) {
         })();
     };
     /**
-   * loadScene 函数调用的时候会触发此函数，
-   * 此阶段时，json 中的图片和二进制已经被加载完成，可以对加载好的资源做进一步处理，
-   * 如果 promise 被 reject, loadScene 函数同样会被 reject，表示场景加载失败。
-   * 请记住，整个 load 阶段都不要创建 GL 相关的对象，只创建 JS 对象
-   * 此阶段晚于 processAssets
-   * @param {Scene} scene
-   * @param {SceneLoadOptions} options
-   */ _proto.prepareResource = function prepareResource(scene, options, engine) {};
-    _proto.onCompositionConstructed = function onCompositionConstructed(composition, scene) {};
-    _proto.onCompositionDestroyed = function onCompositionDestroyed(composition) {};
-    return AbstractPlugin;
+   * 场景资源加载完成后触发。
+   * 此时 JSON 中的图片和二进制已加载完成，可对资源做进一步处理。
+   * @param scene - 场景对象
+   * @param options - 场景加载选项
+   * @param engine - 引擎实例
+   */ _proto.onAssetsLoadFinish = function onAssetsLoadFinish(scene, options, engine) {};
+    /**
+   * 合成创建完成后触发。
+   * @param composition - 合成对象
+   * @param scene - 场景对象
+   */ _proto.onCompositionCreated = function onCompositionCreated(composition, scene) {};
+    /**
+   * 合成销毁时触发。
+   * @param composition - 合成对象
+   */ _proto.onCompositionDestroy = function onCompositionDestroy(composition) {};
+    return Plugin;
 }();
 
 function _set_prototype_of(o, p) {
@@ -7230,13 +7232,388 @@ __decorate([
     serialize()
 ], RendererComponent.prototype, "_priority", void 0);
 
+exports.ShaderType = void 0;
+(function(ShaderType) {
+    ShaderType[ShaderType["vertex"] = 0] = "vertex";
+    ShaderType[ShaderType["fragment"] = 1] = "fragment";
+})(exports.ShaderType || (exports.ShaderType = {}));
+exports.MaskMode = void 0;
+(function(MaskMode) {
+    /**
+   * 无
+   */ MaskMode[MaskMode["NONE"] = 0] = "NONE";
+    /**
+   * 蒙版
+   */ MaskMode[MaskMode["MASK"] = 1] = "MASK";
+    /**
+   * 被遮挡
+   */ MaskMode[MaskMode["OBSCURED"] = 2] = "OBSCURED";
+    /**
+   * 被反向遮挡
+   */ MaskMode[MaskMode["REVERSE_OBSCURED"] = 3] = "REVERSE_OBSCURED";
+})(exports.MaskMode || (exports.MaskMode = {}));
+
+exports.TextureLoadAction = void 0;
+(function(TextureLoadAction) {
+    TextureLoadAction[TextureLoadAction["whatever"] = 0] = "whatever";
+    //preserve previous attachment
+    //load = 1,
+    //clear attachment
+    TextureLoadAction[TextureLoadAction["clear"] = 2] = "clear";
+})(exports.TextureLoadAction || (exports.TextureLoadAction = {}));
+exports.TextureSourceType = void 0;
+(function(TextureSourceType) {
+    TextureSourceType[TextureSourceType["none"] = 0] = "none";
+    TextureSourceType[TextureSourceType["data"] = 1] = "data";
+    TextureSourceType[TextureSourceType["image"] = 2] = "image";
+    TextureSourceType[TextureSourceType["compressed"] = 3] = "compressed";
+    TextureSourceType[TextureSourceType["video"] = 4] = "video";
+    TextureSourceType[TextureSourceType["canvas"] = 5] = "canvas";
+    TextureSourceType[TextureSourceType["framebuffer"] = 6] = "framebuffer";
+    TextureSourceType[TextureSourceType["mipmaps"] = 7] = "mipmaps";
+})(exports.TextureSourceType || (exports.TextureSourceType = {}));
+
+var MaskProcessor = /*#__PURE__*/ function() {
+    function MaskProcessor(engine) {
+        this.engine = engine;
+        this.alphaMaskEnabled = false;
+        this.maskMode = exports.MaskMode.NONE;
+        this.maskable = null;
+        this.stencilClearAction = {
+            stencilAction: exports.TextureLoadAction.clear
+        };
+    }
+    var _proto = MaskProcessor.prototype;
+    _proto.getRefValue = function getRefValue() {
+        return 1;
+    };
+    _proto.setMaskOptions = function setMaskOptions(data) {
+        var _data_isMask = data.isMask, isMask = _data_isMask === void 0 ? false : _data_isMask, _data_inverted = data.inverted, inverted = _data_inverted === void 0 ? false : _data_inverted, reference = data.reference, _data_alphaMaskEnabled = data.alphaMaskEnabled, alphaMaskEnabled = _data_alphaMaskEnabled === void 0 ? false : _data_alphaMaskEnabled;
+        this.alphaMaskEnabled = alphaMaskEnabled;
+        if (isMask) {
+            this.maskMode = exports.MaskMode.MASK;
+        } else {
+            this.maskMode = inverted ? exports.MaskMode.REVERSE_OBSCURED : exports.MaskMode.OBSCURED;
+            this.maskable = this.engine.findObject(reference);
+        }
+    };
+    _proto.drawStencilMask = function drawStencilMask(renderer) {
+        if (this.maskable) {
+            renderer.clear(this.stencilClearAction);
+            this.maskable.drawStencilMask(renderer);
+        }
+    };
+    return MaskProcessor;
+}();
+
+/**
+ * Helper class to create a WebGL Context
+ *
+ * @param canvas
+ * @param glType
+ * @param options
+ * @returns
+ */ function createGLContext(canvas, glType, options) {
+    if (glType === void 0) glType = "webgl";
+    var context;
+    if (glType === "webgl2") {
+        context = canvas.getContext("webgl2", options);
+        if (!context) {
+            console.debug("WebGL2 context retrieval failed, falling back to WebGL context.");
+        }
+    }
+    if (!context || glType === "webgl") {
+        context = canvas.getContext("webgl", options);
+    }
+    if (!context) {
+        throw new Error("This browser does not support WebGL or the WebGL version is incorrect. Please check your WebGL version.");
+    }
+    return context;
+}
+
+function gpuTimer(gl) {
+    var ext = gl.getExtension("EXT_disjoint_timer_query_webgl2");
+    if (ext) {
+        var query = gl.createQuery();
+        var getTime = /*#__PURE__*/ _async_to_generator(function() {
+            return __generator(this, function(_state) {
+                return [
+                    2,
+                    new Promise(function(resolve, reject) {
+                        if (query) {
+                            var available = gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE);
+                            var disjoint = gl.getParameter(ext.GPU_DISJOINT_EXT);
+                            if (available && !disjoint) {
+                                // See how much time the rendering of the object took in nanoseconds.
+                                var timeElapsed = gl.getQueryParameter(query, gl.QUERY_RESULT); // Do something useful with the time.  Note that care should be
+                                // taken to use all significant bits of the result, not just the
+                                // least significant 32 bits.
+                                resolve(timeElapsed / 1000 / 1000);
+                            }
+                            if (available || disjoint) {
+                                // Clean up the query object.
+                                gl.deleteQuery(query); // Don't re-enter this polling loop.
+                                query = null;
+                            }
+                            available !== null && query && window.setTimeout(function() {
+                                getTime().then(resolve).catch;
+                            }, 1);
+                        }
+                    })
+                ];
+            });
+        });
+        if (!query) {
+            return;
+        }
+        return {
+            begin: function() {
+                query && gl.beginQuery(ext.TIME_ELAPSED_EXT, query);
+            },
+            end: function() {
+                gl.endQuery(ext.TIME_ELAPSED_EXT);
+            },
+            getTime: getTime
+        };
+    }
+}
+
+var initErrors = [];
+var glContext = {};
+var IOS16_LOCKDOWN_MODE = "iOS16 lockdown mode, WebGL Constants not in global";
+var WEBGL_CONSTANTS_NOT_IN_GLOBAL = "WebGL Constants not in global, please check your environment";
+if (!initErrors.length) {
+    initGLContext();
+}
+function initGLContext() {
+    // 重要：iOS 9/10 低版本需要拷贝 gl context 的 prototype，要不然会有属性值的缺失
+    if (typeof WebGL2RenderingContext === "function") {
+        copy(WebGL2RenderingContext);
+    } else if (typeof WebGLRenderingContext !== "undefined") {
+        copy(WebGLRenderingContext);
+        copy(WebGLRenderingContext.prototype);
+    } else {
+        if (canUseBOM) {
+            initErrors.push(// iOS 16 lockdown mode
+            isIOS() ? IOS16_LOCKDOWN_MODE : WEBGL_CONSTANTS_NOT_IN_GLOBAL);
+        } else {
+            initErrors.push(WEBGL_CONSTANTS_NOT_IN_GLOBAL);
+        }
+    }
+    if (!initErrors.length && !("HALF_FLOAT" in glContext)) {
+        // @ts-expect-error set default value
+        glContext["HALF_FLOAT"] = 5131;
+    }
+}
+function isWebGL2(gl) {
+    return typeof WebGL2RenderingContext !== "undefined" && gl.constructor.name === "WebGL2RenderingContext";
+}
+function copy(target) {
+    for(var name in target){
+        if (/^[A-Z_]/.test(name)) {
+            // @ts-expect-error safe to assign
+            glContext[name] = target[name];
+        }
+    }
+}
+function vertexFormatType2GLType(formatType) {
+    switch(formatType){
+        case VertexFormatType.Float32:
+            return WebGLRenderingContext["FLOAT"];
+        case VertexFormatType.Int16:
+            return WebGLRenderingContext["SHORT"];
+        case VertexFormatType.Int8:
+            return WebGLRenderingContext["BYTE"];
+        case VertexFormatType.UInt16:
+            return WebGLRenderingContext["UNSIGNED_SHORT"];
+        case VertexFormatType.UInt8:
+            return WebGLRenderingContext["UNSIGNED_BYTE"];
+        default:
+            return WebGLRenderingContext["FLOAT"];
+    }
+}
+function glType2VertexFormatType(webglType) {
+    switch(webglType){
+        case WebGLRenderingContext["FLOAT"]:
+            return VertexFormatType.Float32;
+        case WebGLRenderingContext["SHORT"]:
+            return VertexFormatType.Int16;
+        case WebGLRenderingContext["BYTE"]:
+            return VertexFormatType.Int8;
+        case WebGLRenderingContext["UNSIGNED_SHORT"]:
+            return VertexFormatType.UInt16;
+        case WebGLRenderingContext["UNSIGNED_BYTE"]:
+            return VertexFormatType.UInt8;
+        default:
+            return VertexFormatType.Float32;
+    }
+}
+
+function valIfUndefined(val, def) {
+    if (val === undefined || val === null) {
+        return def;
+    }
+    return val;
+}
+function getPreMultiAlpha(blending) {
+    switch(blending){
+        case BlendingMode.ALPHA:
+            return 1;
+        case BlendingMode.ADD:
+            return 1;
+        case BlendingMode.SUBTRACTION:
+            return 1;
+        case BlendingMode.STRONG_LIGHT:
+            return 1;
+        case BlendingMode.WEAK_LIGHT:
+            return 1;
+        case BlendingMode.SUPERPOSITION:
+            return 2;
+        case BlendingMode.BRIGHTNESS:
+            return 3;
+        case BlendingMode.MULTIPLY:
+            return 0;
+        default:
+            // 处理undefined
+            return 1;
+    }
+}
+function setBlendMode(material, blendMode) {
+    switch(blendMode){
+        case undefined:
+            material.blendFunction = [
+                glContext.ONE,
+                glContext.ONE_MINUS_SRC_ALPHA,
+                glContext.ONE,
+                glContext.ONE_MINUS_SRC_ALPHA
+            ];
+            break;
+        case BlendingMode.ALPHA:
+            material.blendFunction = [
+                glContext.ONE,
+                glContext.ONE_MINUS_SRC_ALPHA,
+                glContext.ONE,
+                glContext.ONE_MINUS_SRC_ALPHA
+            ];
+            break;
+        case BlendingMode.ADD:
+            material.blendFunction = [
+                glContext.ONE,
+                glContext.ONE,
+                glContext.ONE,
+                glContext.ONE
+            ];
+            break;
+        case BlendingMode.SUBTRACTION:
+            material.blendFunction = [
+                glContext.ONE,
+                glContext.ONE,
+                glContext.ZERO,
+                glContext.ONE
+            ];
+            material.blendEquation = [
+                glContext.FUNC_REVERSE_SUBTRACT,
+                glContext.FUNC_REVERSE_SUBTRACT
+            ];
+            break;
+        case BlendingMode.SUPERPOSITION:
+            material.blendFunction = [
+                glContext.ONE,
+                glContext.ONE,
+                glContext.ONE,
+                glContext.ONE
+            ];
+            break;
+        case BlendingMode.MULTIPLY:
+            material.blendFunction = [
+                glContext.DST_COLOR,
+                glContext.ONE_MINUS_SRC_ALPHA,
+                glContext.DST_COLOR,
+                glContext.ONE_MINUS_SRC_ALPHA
+            ];
+            break;
+        case BlendingMode.BRIGHTNESS:
+            material.blendFunction = [
+                glContext.ONE,
+                glContext.ONE_MINUS_SRC_ALPHA,
+                glContext.ONE,
+                glContext.ONE_MINUS_SRC_ALPHA
+            ];
+            break;
+        case BlendingMode.STRONG_LIGHT:
+            material.blendFunction = [
+                glContext.DST_COLOR,
+                glContext.DST_ALPHA,
+                glContext.ZERO,
+                glContext.ONE
+            ];
+            break;
+        case BlendingMode.WEAK_LIGHT:
+            material.blendFunction = [
+                glContext.DST_COLOR,
+                glContext.ZERO,
+                glContext.ZERO,
+                glContext.ONE
+            ];
+            break;
+        default:
+            console.warn("BlendMode " + blendMode + " not in specification, please set blend params separately.");
+    }
+}
+function setSideMode(material, side) {
+    if (side === SideMode.DOUBLE) {
+        material.culling = false;
+    } else {
+        material.culling = true;
+        material.frontFace = glContext.CW;
+        material.cullFace = side === SideMode.BACK ? glContext.BACK : glContext.FRONT;
+    }
+}
+function setMaskMode(material, maskMode) {
+    switch(maskMode){
+        case undefined:
+            material.stencilTest = false;
+            break;
+        case exports.MaskMode.MASK:
+            material.stencilTest = true;
+            material.stencilFunc = [
+                glContext.ALWAYS,
+                glContext.ALWAYS
+            ];
+            material.stencilOpZPass = [
+                glContext.REPLACE,
+                glContext.REPLACE
+            ];
+            break;
+        case exports.MaskMode.OBSCURED:
+            material.stencilTest = true;
+            material.stencilFunc = [
+                glContext.EQUAL,
+                glContext.EQUAL
+            ];
+            break;
+        case exports.MaskMode.REVERSE_OBSCURED:
+            material.stencilTest = true;
+            material.stencilFunc = [
+                glContext.NOTEQUAL,
+                glContext.NOTEQUAL
+            ];
+            break;
+        case exports.MaskMode.NONE:
+            material.stencilTest = false;
+            break;
+        default:
+            console.warn("MaskMode " + maskMode + " not in specification, please set stencil params seperately.");
+    }
+}
+
 /**
  * Mesh 组件
  */ var MeshComponent = /*#__PURE__*/ function(RendererComponent) {
     _inherits(MeshComponent, RendererComponent);
-    function MeshComponent() {
+    function MeshComponent(engine) {
         var _this;
-        _this = RendererComponent.apply(this, arguments) || this;
+        _this = RendererComponent.call(this, engine) || this;
         /**
    * 用于点击测试的碰撞器
    */ _this.meshCollider = new MeshCollider();
@@ -7252,6 +7629,7 @@ __decorate([
                 };
             }
         };
+        _this.maskManager = new MaskProcessor(engine);
         return _this;
     }
     var _proto = MeshComponent.prototype;
@@ -7261,12 +7639,42 @@ __decorate([
             renderer.drawGeometry(this.geometry, this.transform.getWorldMatrix(), material, i);
         }
     };
+    _proto.drawStencilMask = function drawStencilMask(renderer) {
+        if (!this.isActiveAndEnabled) {
+            return;
+        }
+        for(var i = 0; i < this.materials.length; i++){
+            var material = this.materials[i];
+            var previousColorMask = material.colorMask;
+            material.colorMask = false;
+            renderer.drawGeometry(this.geometry, this.transform.getWorldMatrix(), material, i);
+            material.colorMask = previousColorMask;
+        }
+    };
     _proto.getBoundingBox = function getBoundingBox() {
         var worldMatrix = this.transform.getWorldMatrix();
         this.meshCollider.setGeometry(this.geometry, worldMatrix);
         var boundingBox = this.meshCollider.getBoundingBox();
         return boundingBox;
     };
+    // TODO: Update data spec
+    _proto.fromData = function fromData(data) {
+        RendererComponent.prototype.fromData.call(this, data);
+        var maskableRendererData = data;
+        var maskOptions = maskableRendererData.mask;
+        if (maskOptions) {
+            this.maskManager.setMaskOptions(maskOptions);
+        }
+        for(var _iterator = _create_for_of_iterator_helper_loose(this.materials), _step; !(_step = _iterator()).done;){
+            var material = _step.value;
+            var stencilRef = this.maskManager.getRefValue();
+            material.stencilRef = [
+                stencilRef,
+                stencilRef
+            ];
+            setMaskMode(material, this.maskManager.maskMode);
+        }
+    };
     return MeshComponent;
 }(RendererComponent);
 __decorate([
@@ -8456,348 +8864,6 @@ Matrix4.tempVec1 = new Vector3();
 Matrix4.tempVec2 = new Vector3();
 Matrix4.tempMat0 = new Matrix4();
 
-/**
- * Helper class to create a WebGL Context
- *
- * @param canvas
- * @param glType
- * @param options
- * @returns
- */ function createGLContext(canvas, glType, options) {
-    if (glType === void 0) glType = "webgl";
-    var context;
-    if (glType === "webgl2") {
-        context = canvas.getContext("webgl2", options);
-        if (!context) {
-            console.debug("WebGL2 context retrieval failed, falling back to WebGL context.");
-        }
-    }
-    if (!context || glType === "webgl") {
-        context = canvas.getContext("webgl", options);
-    }
-    if (!context) {
-        throw new Error("This browser does not support WebGL or the WebGL version is incorrect. Please check your WebGL version.");
-    }
-    return context;
-}
-
-function gpuTimer(gl) {
-    var ext = gl.getExtension("EXT_disjoint_timer_query_webgl2");
-    if (ext) {
-        var query = gl.createQuery();
-        var getTime = /*#__PURE__*/ _async_to_generator(function() {
-            return __generator(this, function(_state) {
-                return [
-                    2,
-                    new Promise(function(resolve, reject) {
-                        if (query) {
-                            var available = gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE);
-                            var disjoint = gl.getParameter(ext.GPU_DISJOINT_EXT);
-                            if (available && !disjoint) {
-                                // See how much time the rendering of the object took in nanoseconds.
-                                var timeElapsed = gl.getQueryParameter(query, gl.QUERY_RESULT); // Do something useful with the time.  Note that care should be
-                                // taken to use all significant bits of the result, not just the
-                                // least significant 32 bits.
-                                resolve(timeElapsed / 1000 / 1000);
-                            }
-                            if (available || disjoint) {
-                                // Clean up the query object.
-                                gl.deleteQuery(query); // Don't re-enter this polling loop.
-                                query = null;
-                            }
-                            available !== null && query && window.setTimeout(function() {
-                                getTime().then(resolve).catch;
-                            }, 1);
-                        }
-                    })
-                ];
-            });
-        });
-        if (!query) {
-            return;
-        }
-        return {
-            begin: function() {
-                query && gl.beginQuery(ext.TIME_ELAPSED_EXT, query);
-            },
-            end: function() {
-                gl.endQuery(ext.TIME_ELAPSED_EXT);
-            },
-            getTime: getTime
-        };
-    }
-}
-
-var initErrors = [];
-var glContext = {};
-var IOS16_LOCKDOWN_MODE = "iOS16 lockdown mode, WebGL Constants not in global";
-var WEBGL_CONSTANTS_NOT_IN_GLOBAL = "WebGL Constants not in global, please check your environment";
-if (!initErrors.length) {
-    initGLContext();
-}
-function initGLContext() {
-    // 重要：iOS 9/10 低版本需要拷贝 gl context 的 prototype，要不然会有属性值的缺失
-    if (typeof WebGL2RenderingContext === "function") {
-        copy(WebGL2RenderingContext);
-    } else if (typeof WebGLRenderingContext !== "undefined") {
-        copy(WebGLRenderingContext);
-        copy(WebGLRenderingContext.prototype);
-    } else {
-        if (canUseBOM) {
-            initErrors.push(// iOS 16 lockdown mode
-            isIOS() ? IOS16_LOCKDOWN_MODE : WEBGL_CONSTANTS_NOT_IN_GLOBAL);
-        } else {
-            initErrors.push(WEBGL_CONSTANTS_NOT_IN_GLOBAL);
-        }
-    }
-    if (!initErrors.length && !("HALF_FLOAT" in glContext)) {
-        // @ts-expect-error set default value
-        glContext["HALF_FLOAT"] = 5131;
-    }
-}
-function isWebGL2(gl) {
-    return typeof WebGL2RenderingContext !== "undefined" && gl.constructor.name === "WebGL2RenderingContext";
-}
-function copy(target) {
-    for(var name in target){
-        if (/^[A-Z_]/.test(name)) {
-            // @ts-expect-error safe to assign
-            glContext[name] = target[name];
-        }
-    }
-}
-function vertexFormatType2GLType(formatType) {
-    switch(formatType){
-        case VertexFormatType.Float32:
-            return WebGLRenderingContext["FLOAT"];
-        case VertexFormatType.Int16:
-            return WebGLRenderingContext["SHORT"];
-        case VertexFormatType.Int8:
-            return WebGLRenderingContext["BYTE"];
-        case VertexFormatType.UInt16:
-            return WebGLRenderingContext["UNSIGNED_SHORT"];
-        case VertexFormatType.UInt8:
-            return WebGLRenderingContext["UNSIGNED_BYTE"];
-        default:
-            return WebGLRenderingContext["FLOAT"];
-    }
-}
-function glType2VertexFormatType(webglType) {
-    switch(webglType){
-        case WebGLRenderingContext["FLOAT"]:
-            return VertexFormatType.Float32;
-        case WebGLRenderingContext["SHORT"]:
-            return VertexFormatType.Int16;
-        case WebGLRenderingContext["BYTE"]:
-            return VertexFormatType.Int8;
-        case WebGLRenderingContext["UNSIGNED_SHORT"]:
-            return VertexFormatType.UInt16;
-        case WebGLRenderingContext["UNSIGNED_BYTE"]:
-            return VertexFormatType.UInt8;
-        default:
-            return VertexFormatType.Float32;
-    }
-}
-
-exports.ShaderType = void 0;
-(function(ShaderType) {
-    ShaderType[ShaderType["vertex"] = 0] = "vertex";
-    ShaderType[ShaderType["fragment"] = 1] = "fragment";
-})(exports.ShaderType || (exports.ShaderType = {}));
-exports.MaskMode = void 0;
-(function(MaskMode) {
-    /**
-   * 无
-   */ MaskMode[MaskMode["NONE"] = 0] = "NONE";
-    /**
-   * 蒙版
-   */ MaskMode[MaskMode["MASK"] = 1] = "MASK";
-    /**
-   * 被遮挡
-   */ MaskMode[MaskMode["OBSCURED"] = 2] = "OBSCURED";
-    /**
-   * 被反向遮挡
-   */ MaskMode[MaskMode["REVERSE_OBSCURED"] = 3] = "REVERSE_OBSCURED";
-})(exports.MaskMode || (exports.MaskMode = {}));
-
-function valIfUndefined(val, def) {
-    if (val === undefined || val === null) {
-        return def;
-    }
-    return val;
-}
-function getPreMultiAlpha(blending) {
-    switch(blending){
-        case BlendingMode.ALPHA:
-            return 1;
-        case BlendingMode.ADD:
-            return 1;
-        case BlendingMode.SUBTRACTION:
-            return 1;
-        case BlendingMode.STRONG_LIGHT:
-            return 1;
-        case BlendingMode.WEAK_LIGHT:
-            return 1;
-        case BlendingMode.SUPERPOSITION:
-            return 2;
-        case BlendingMode.BRIGHTNESS:
-            return 3;
-        case BlendingMode.MULTIPLY:
-            return 0;
-        default:
-            // 处理undefined
-            return 1;
-    }
-}
-function setBlendMode(material, blendMode) {
-    switch(blendMode){
-        case undefined:
-            material.blendFunction = [
-                glContext.ONE,
-                glContext.ONE_MINUS_SRC_ALPHA,
-                glContext.ONE,
-                glContext.ONE_MINUS_SRC_ALPHA
-            ];
-            break;
-        case BlendingMode.ALPHA:
-            material.blendFunction = [
-                glContext.ONE,
-                glContext.ONE_MINUS_SRC_ALPHA,
-                glContext.ONE,
-                glContext.ONE_MINUS_SRC_ALPHA
-            ];
-            break;
-        case BlendingMode.ADD:
-            material.blendFunction = [
-                glContext.ONE,
-                glContext.ONE,
-                glContext.ONE,
-                glContext.ONE
-            ];
-            break;
-        case BlendingMode.SUBTRACTION:
-            material.blendFunction = [
-                glContext.ONE,
-                glContext.ONE,
-                glContext.ZERO,
-                glContext.ONE
-            ];
-            material.blendEquation = [
-                glContext.FUNC_REVERSE_SUBTRACT,
-                glContext.FUNC_REVERSE_SUBTRACT
-            ];
-            break;
-        case BlendingMode.SUPERPOSITION:
-            material.blendFunction = [
-                glContext.ONE,
-                glContext.ONE,
-                glContext.ONE,
-                glContext.ONE
-            ];
-            break;
-        case BlendingMode.MULTIPLY:
-            material.blendFunction = [
-                glContext.DST_COLOR,
-                glContext.ONE_MINUS_SRC_ALPHA,
-                glContext.DST_COLOR,
-                glContext.ONE_MINUS_SRC_ALPHA
-            ];
-            break;
-        case BlendingMode.BRIGHTNESS:
-            material.blendFunction = [
-                glContext.ONE,
-                glContext.ONE_MINUS_SRC_ALPHA,
-                glContext.ONE,
-                glContext.ONE_MINUS_SRC_ALPHA
-            ];
-            break;
-        case BlendingMode.STRONG_LIGHT:
-            material.blendFunction = [
-                glContext.DST_COLOR,
-                glContext.DST_ALPHA,
-                glContext.ZERO,
-                glContext.ONE
-            ];
-            break;
-        case BlendingMode.WEAK_LIGHT:
-            material.blendFunction = [
-                glContext.DST_COLOR,
-                glContext.ZERO,
-                glContext.ZERO,
-                glContext.ONE
-            ];
-            break;
-        default:
-            console.warn("BlendMode " + blendMode + " not in specification, please set blend params separately.");
-    }
-}
-function setSideMode(material, side) {
-    if (side === SideMode.DOUBLE) {
-        material.culling = false;
-    } else {
-        material.culling = true;
-        material.frontFace = glContext.CW;
-        material.cullFace = side === SideMode.BACK ? glContext.BACK : glContext.FRONT;
-    }
-}
-function setMaskMode(material, maskMode) {
-    switch(maskMode){
-        case undefined:
-            material.stencilTest = false;
-            break;
-        case exports.MaskMode.MASK:
-            material.stencilTest = true;
-            material.stencilFunc = [
-                glContext.ALWAYS,
-                glContext.ALWAYS
-            ];
-            material.stencilOpZPass = [
-                glContext.REPLACE,
-                glContext.REPLACE
-            ];
-            break;
-        case exports.MaskMode.OBSCURED:
-            material.stencilTest = true;
-            material.stencilFunc = [
-                glContext.EQUAL,
-                glContext.EQUAL
-            ];
-            break;
-        case exports.MaskMode.REVERSE_OBSCURED:
-            material.stencilTest = true;
-            material.stencilFunc = [
-                glContext.NOTEQUAL,
-                glContext.NOTEQUAL
-            ];
-            break;
-        case exports.MaskMode.NONE:
-            material.stencilTest = false;
-            break;
-        default:
-            console.warn("MaskMode " + maskMode + " not in specification, please set stencil params seperately.");
-    }
-}
-
-exports.TextureLoadAction = void 0;
-(function(TextureLoadAction) {
-    TextureLoadAction[TextureLoadAction["whatever"] = 0] = "whatever";
-    //preserve previous attachment
-    //load = 1,
-    //clear attachment
-    TextureLoadAction[TextureLoadAction["clear"] = 2] = "clear";
-})(exports.TextureLoadAction || (exports.TextureLoadAction = {}));
-exports.TextureSourceType = void 0;
-(function(TextureSourceType) {
-    TextureSourceType[TextureSourceType["none"] = 0] = "none";
-    TextureSourceType[TextureSourceType["data"] = 1] = "data";
-    TextureSourceType[TextureSourceType["image"] = 2] = "image";
-    TextureSourceType[TextureSourceType["compressed"] = 3] = "compressed";
-    TextureSourceType[TextureSourceType["video"] = 4] = "video";
-    TextureSourceType[TextureSourceType["canvas"] = 5] = "canvas";
-    TextureSourceType[TextureSourceType["framebuffer"] = 6] = "framebuffer";
-    TextureSourceType[TextureSourceType["mipmaps"] = 7] = "mipmaps";
-})(exports.TextureSourceType || (exports.TextureSourceType = {}));
-
 /**
  * 负责下载各种资源，并提供了一些异步加载和缓存管理的功能
  */ var Downloader = /*#__PURE__*/ function() {
@@ -10276,39 +10342,6 @@ exports.MaterialRenderType = void 0;
     return Material;
 }(EffectsObject);
 
-var MaskProcessor = /*#__PURE__*/ function() {
-    function MaskProcessor(engine) {
-        this.engine = engine;
-        this.alphaMaskEnabled = false;
-        this.maskMode = exports.MaskMode.NONE;
-        this.maskable = null;
-        this.stencilClearAction = {
-            stencilAction: exports.TextureLoadAction.clear
-        };
-    }
-    var _proto = MaskProcessor.prototype;
-    _proto.getRefValue = function getRefValue() {
-        return 1;
-    };
-    _proto.setMaskOptions = function setMaskOptions(data) {
-        var _data_isMask = data.isMask, isMask = _data_isMask === void 0 ? false : _data_isMask, _data_inverted = data.inverted, inverted = _data_inverted === void 0 ? false : _data_inverted, reference = data.reference, _data_alphaMaskEnabled = data.alphaMaskEnabled, alphaMaskEnabled = _data_alphaMaskEnabled === void 0 ? false : _data_alphaMaskEnabled;
-        this.alphaMaskEnabled = alphaMaskEnabled;
-        if (isMask) {
-            this.maskMode = exports.MaskMode.MASK;
-        } else {
-            this.maskMode = inverted ? exports.MaskMode.REVERSE_OBSCURED : exports.MaskMode.OBSCURED;
-            this.maskable = this.engine.findObject(reference);
-        }
-    };
-    _proto.drawStencilMask = function drawStencilMask(renderer) {
-        if (this.maskable) {
-            renderer.clear(this.stencilClearAction);
-            this.maskable.drawStencilMask(renderer);
-        }
-    };
-    return MaskProcessor;
-}();
-
 var EFFECTS_COPY_MESH_NAME = "effects-internal-copy";
 var COPY_MESH_SHADER_ID = "effects-internal-copy-mesh";
 var 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}";
@@ -10621,6 +10654,9 @@ var DrawObjectPass = /*#__PURE__*/ function(RenderPass) {
                 stencilAction: exports.TextureLoadAction.clear
             });
         }
+        this.meshes.sort(function(a, b) {
+            return a.priority - b.priority;
+        });
         renderer.renderMeshes(this.meshes);
     };
     _proto.onCameraCleanup = function onCameraCleanup(renderer) {
@@ -12722,244 +12758,131 @@ var ShaderFactory = /*#__PURE__*/ function() {
     return ShaderFactory;
 }();
 
-// Bloom 阈值 Pass
-var BloomThresholdPass = /*#__PURE__*/ function(RenderPass) {
-    _inherits(BloomThresholdPass, RenderPass);
-    function BloomThresholdPass(renderer) {
+// Bloom Pass - 包含阈值提取、高斯模糊（Down Sample 和 Up Sample）
+var BloomPass = /*#__PURE__*/ function(RenderPass) {
+    _inherits(BloomPass, RenderPass);
+    function BloomPass(renderer, iterationCount) {
+        if (iterationCount === void 0) iterationCount = 4;
         var _this;
         _this = RenderPass.call(this, renderer) || this;
+        _this.tempRTs = [];
+        _this.iterationCount = iterationCount;
         var engine = _this.renderer.engine;
-        var geometry = Geometry.create(engine, {
-            mode: glContext.TRIANGLE_STRIP,
-            attributes: {
-                aPos: {
-                    type: glContext.FLOAT,
-                    size: 2,
-                    data: new Float32Array([
-                        -1,
-                        1,
-                        -1,
-                        -1,
-                        1,
-                        1,
-                        1,
-                        -1
-                    ])
-                }
-            },
-            drawCount: 4
-        });
-        var material = Material.create(engine, {
+        // Threshold material
+        _this.thresholdMaterial = Material.create(engine, {
             shader: {
                 vertex: screenMeshVert,
                 fragment: thresholdFrag,
                 glslVersion: exports.GLSLVersion.GLSL1
             }
         });
-        material.blending = false;
-        material.depthTest = false;
-        material.culling = false;
-        _this.screenMesh = Mesh.create(engine, {
-            geometry: geometry,
-            material: material,
-            priority: 0
+        _this.thresholdMaterial.blending = false;
+        _this.thresholdMaterial.depthTest = false;
+        _this.thresholdMaterial.culling = false;
+        // Down sample H material
+        _this.downSampleHMaterial = Material.create(engine, {
+            shader: {
+                vertex: screenMeshVert,
+                fragment: gaussianDownHFrag,
+                glslVersion: exports.GLSLVersion.GLSL1
+            }
         });
+        _this.downSampleHMaterial.blending = false;
+        _this.downSampleHMaterial.depthTest = false;
+        _this.downSampleHMaterial.culling = false;
+        // Down sample V material
+        _this.downSampleVMaterial = Material.create(engine, {
+            shader: {
+                vertex: screenMeshVert,
+                fragment: gaussianDownVFrag,
+                glslVersion: exports.GLSLVersion.GLSL1
+            }
+        });
+        _this.downSampleVMaterial.blending = false;
+        _this.downSampleVMaterial.depthTest = false;
+        _this.downSampleVMaterial.culling = false;
+        // Up sample material
+        _this.upSampleMaterial = Material.create(engine, {
+            shader: {
+                vertex: screenMeshVert,
+                fragment: gaussianUpFrag,
+                glslVersion: exports.GLSLVersion.GLSL1
+            }
+        });
+        _this.upSampleMaterial.blending = false;
+        _this.upSampleMaterial.depthTest = false;
+        _this.upSampleMaterial.culling = false;
         _this.priority = 5000;
-        _this.name = "BloomThresholdPass";
+        _this.name = "BloomPass";
         return _this;
     }
-    var _proto = BloomThresholdPass.prototype;
+    var _proto = BloomPass.prototype;
     _proto.configure = function configure(renderer) {
-        this.framebuffer = renderer.getTemporaryRT(this.name, renderer.getWidth(), renderer.getHeight(), 0, exports.FilterMode.Linear, exports.RenderTextureFormat.RGBAHalf);
+        // 获取场景纹理用于 ToneMappingPass
         this.mainTexture = renderer.getFramebuffer().getColorTextures()[0];
         this.sceneTextureHandle.texture = this.mainTexture;
-        renderer.setFramebuffer(this.framebuffer);
     };
     _proto.execute = function execute(renderer) {
         var _renderer_renderingData_currentFrame_globalVolume_bloom, _renderer_renderingData_currentFrame_globalVolume;
-        renderer.clear({
-            colorAction: exports.TextureLoadAction.clear,
-            depthAction: exports.TextureLoadAction.clear,
-            stencilAction: exports.TextureLoadAction.clear
-        });
-        this.screenMesh.material.setTexture("_MainTex", this.mainTexture);
+        var baseWidth = renderer.getWidth();
+        var baseHeight = renderer.getHeight();
         var _renderer_renderingData_currentFrame_globalVolume_bloom_threshold;
+        // 1. Threshold pass - 提取高亮区域
         var threshold = (_renderer_renderingData_currentFrame_globalVolume_bloom_threshold = (_renderer_renderingData_currentFrame_globalVolume = renderer.renderingData.currentFrame.globalVolume) == null ? void 0 : (_renderer_renderingData_currentFrame_globalVolume_bloom = _renderer_renderingData_currentFrame_globalVolume.bloom) == null ? void 0 : _renderer_renderingData_currentFrame_globalVolume_bloom.threshold) != null ? _renderer_renderingData_currentFrame_globalVolume_bloom_threshold : 1.0;
-        this.screenMesh.material.setFloat("_Threshold", threshold);
-        renderer.renderMeshes([
-            this.screenMesh
-        ]);
+        this.thresholdRT = renderer.getTemporaryRT("_BloomThreshold", baseWidth, baseHeight, 0, exports.FilterMode.Linear, exports.RenderTextureFormat.RGBAHalf);
+        this.thresholdMaterial.setFloat("_Threshold", threshold);
+        renderer.blit(this.mainTexture, this.thresholdRT, this.thresholdMaterial);
+        var currentTexture = this.thresholdRT.getColorTextures()[0];
+        // 2. Down sample passes
+        for(var i = 0; i < this.iterationCount; i++){
+            var downWidth = Math.floor(baseWidth / Math.pow(2, i + 1));
+            var downHeight = Math.floor(baseHeight / Math.pow(2, i + 1));
+            // Horizontal pass
+            var tempH = renderer.getTemporaryRT("_BloomDownH" + i, downWidth, downHeight, 0, exports.FilterMode.Linear, exports.RenderTextureFormat.RGBAHalf);
+            this.downSampleHMaterial.setVector2("_TextureSize", getTextureSize(currentTexture));
+            renderer.blit(currentTexture, tempH, this.downSampleHMaterial);
+            // Vertical pass
+            var tempV = renderer.getTemporaryRT("_BloomDownV" + i, downWidth, downHeight, 0, exports.FilterMode.Linear, exports.RenderTextureFormat.RGBAHalf);
+            this.downSampleVMaterial.setVector2("_TextureSize", getTextureSize(tempH.getColorTextures()[0]));
+            renderer.blit(tempH.getColorTextures()[0], tempV, this.downSampleVMaterial);
+            // 释放 H pass RT，保留 V pass RT 用于 up sample
+            renderer.releaseTemporaryRT(tempH);
+            this.tempRTs.push(tempV);
+            currentTexture = tempV.getColorTextures()[0];
+        }
+        // 释放 threshold RT
+        renderer.releaseTemporaryRT(this.thresholdRT);
+        // 3. Up sample passes
+        for(var i1 = this.iterationCount - 1; i1 > 0; i1--){
+            var upWidth = Math.floor(baseWidth / Math.pow(2, i1 - 1));
+            var upHeight = Math.floor(baseHeight / Math.pow(2, i1 - 1));
+            var tempUp = renderer.getTemporaryRT("_BloomUp" + i1, upWidth, upHeight, 0, exports.FilterMode.Linear, exports.RenderTextureFormat.RGBAHalf);
+            // 获取下一层的 down sample 结果
+            var downSampleTexture = this.tempRTs[i1 - 1].getColorTextures()[0];
+            this.upSampleMaterial.setTexture("_GaussianDownTex", downSampleTexture);
+            this.upSampleMaterial.setVector2("_GaussianDownTextureSize", getTextureSize(downSampleTexture));
+            renderer.blit(currentTexture, tempUp, this.upSampleMaterial);
+            currentTexture = tempUp.getColorTextures()[0];
+            this.tempRTs.push(tempUp);
+        }
+        // 设置最终输出到当前 framebuffer
+        renderer.setFramebuffer(this.tempRTs[this.tempRTs.length - 1]);
     };
     _proto.onCameraCleanup = function onCameraCleanup(renderer) {
-        if (this.framebuffer) {
-            renderer.releaseTemporaryRT(this.framebuffer);
+        // 释放所有临时 RT
+        for(var i = 0; i < this.tempRTs.length; i++){
+            renderer.releaseTemporaryRT(this.tempRTs[i]);
         }
+        this.tempRTs = [];
     };
     _proto.dispose = function dispose(options) {
+        this.thresholdMaterial.dispose();
+        this.downSampleHMaterial.dispose();
+        this.downSampleVMaterial.dispose();
+        this.upSampleMaterial.dispose();
         RenderPass.prototype.dispose.call(this, options);
     };
-    return BloomThresholdPass;
-}(RenderPass);
-var HQGaussianDownSamplePass = /*#__PURE__*/ function(RenderPass) {
-    _inherits(HQGaussianDownSamplePass, RenderPass);
-    function HQGaussianDownSamplePass(renderer, type, level) {
-        var _this;
-        _this = RenderPass.call(this, renderer) || this;
-        _this.type = type;
-        _this.level = level;
-        var engine = _this.renderer.engine;
-        var name = "PostProcess";
-        var geometry = Geometry.create(engine, {
-            name: name,
-            mode: glContext.TRIANGLE_STRIP,
-            attributes: {
-                aPos: {
-                    type: glContext.FLOAT,
-                    size: 2,
-                    data: new Float32Array([
-                        -1,
-                        1,
-                        -1,
-                        -1,
-                        1,
-                        1,
-                        1,
-                        -1
-                    ])
-                }
-            },
-            drawCount: 4
-        });
-        var fragment = type === "H" ? gaussianDownHFrag : gaussianDownVFrag;
-        var shader = {
-            vertex: screenMeshVert,
-            fragment: fragment,
-            glslVersion: exports.GLSLVersion.GLSL1
-        };
-        var material = Material.create(engine, {
-            name: name,
-            shader: shader
-        });
-        material.blending = false;
-        material.depthTest = false;
-        material.culling = false;
-        _this.screenMesh = Mesh.create(engine, {
-            name: name,
-            geometry: geometry,
-            material: material,
-            priority: 0
-        });
-        _this.priority = 5000;
-        _this.name = "GaussianDownPass" + type + level;
-        return _this;
-    }
-    var _proto = HQGaussianDownSamplePass.prototype;
-    _proto.configure = function configure(renderer) {
-        var width = Math.floor(this.renderer.getWidth() / Math.pow(2, this.level + 1));
-        var height = Math.floor(this.renderer.getHeight() / Math.pow(2, this.level + 1));
-        this.framebuffer = renderer.getTemporaryRT(this.name, width, height, 0, exports.FilterMode.Linear, exports.RenderTextureFormat.RGBAHalf);
-        this.mainTexture = renderer.getFramebuffer().getColorTextures()[0];
-        renderer.setFramebuffer(this.framebuffer);
-    };
-    _proto.execute = function execute(renderer) {
-        renderer.clear({
-            colorAction: exports.TextureLoadAction.clear,
-            depthAction: exports.TextureLoadAction.clear,
-            stencilAction: exports.TextureLoadAction.clear
-        });
-        this.screenMesh.material.setTexture("_MainTex", this.mainTexture);
-        this.screenMesh.material.setVector2("_TextureSize", getTextureSize(this.mainTexture));
-        renderer.renderMeshes([
-            this.screenMesh
-        ]);
-        if (this.type === "V") {
-            this.gaussianResult.texture = renderer.getFramebuffer().getColorTextures()[0];
-        }
-    };
-    _proto.onCameraCleanup = function onCameraCleanup(renderer) {
-        if (this.framebuffer) {
-            renderer.releaseTemporaryRT(this.framebuffer);
-        }
-    };
-    return HQGaussianDownSamplePass;
-}(RenderPass);
-var HQGaussianUpSamplePass = /*#__PURE__*/ function(RenderPass) {
-    _inherits(HQGaussianUpSamplePass, RenderPass);
-    function HQGaussianUpSamplePass(renderer, level) {
-        var _this;
-        _this = RenderPass.call(this, renderer) || this;
-        _this.level = level;
-        var name = "PostProcess";
-        var engine = _this.renderer.engine;
-        var geometry = Geometry.create(engine, {
-            name: name,
-            mode: glContext.TRIANGLE_STRIP,
-            attributes: {
-                aPos: {
-                    type: glContext.FLOAT,
-                    size: 2,
-                    data: new Float32Array([
-                        -1,
-                        1,
-                        -1,
-                        -1,
-                        1,
-                        1,
-                        1,
-                        -1
-                    ])
-                }
-            },
-            drawCount: 4
-        });
-        var shader = {
-            vertex: screenMeshVert,
-            fragment: gaussianUpFrag
-        };
-        var material = Material.create(engine, {
-            name: name,
-            shader: shader
-        });
-        material.blending = false;
-        material.depthTest = false;
-        material.culling = false;
-        _this.screenMesh = Mesh.create(engine, {
-            name: name,
-            geometry: geometry,
-            material: material,
-            priority: 0
-        });
-        _this.priority = 5000;
-        _this.name = "GaussianUpPass" + level;
-        return _this;
-    }
-    var _proto = HQGaussianUpSamplePass.prototype;
-    _proto.configure = function configure(renderer) {
-        var width = Math.floor(this.renderer.getWidth() / Math.pow(2, this.level - 1));
-        var height = Math.floor(this.renderer.getHeight() / Math.pow(2, this.level - 1));
-        this.framebuffer = renderer.getTemporaryRT(this.name, width, height, 0, exports.FilterMode.Linear, exports.RenderTextureFormat.RGBAHalf);
-        this.mainTexture = renderer.getFramebuffer().getColorTextures()[0];
-        renderer.setFramebuffer(this.framebuffer);
-    };
-    _proto.execute = function execute(renderer) {
-        renderer.clear({
-            colorAction: exports.TextureLoadAction.clear,
-            depthAction: exports.TextureLoadAction.clear,
-            stencilAction: exports.TextureLoadAction.clear
-        });
-        this.screenMesh.material.setTexture("_MainTex", this.mainTexture);
-        this.screenMesh.material.setTexture("_GaussianDownTex", this.gaussianDownSampleResult.texture);
-        this.screenMesh.material.setVector2("_GaussianDownTextureSize", getTextureSize(this.gaussianDownSampleResult.texture));
-        renderer.renderMeshes([
-            this.screenMesh
-        ]);
-    };
-    _proto.onCameraCleanup = function onCameraCleanup(renderer) {
-        if (this.framebuffer) {
-            renderer.releaseTemporaryRT(this.framebuffer);
-        }
-    };
-    return HQGaussianUpSamplePass;
+    return BloomPass;
 }(RenderPass);
 // 合并Bloom的高斯模糊结果，并应用ACES Tonemapping
 var ToneMappingPass = /*#__PURE__*/ function(RenderPass) {
@@ -13103,36 +13026,11 @@ var seed$5 = 1;
         if (postProcessingEnabled) {
             var sceneTextureHandle = new RenderTargetHandle(engine); //保存后处理前的屏幕图像
             var gaussianStep = 7; // 高斯模糊的迭代次数，次数越高模糊范围越大
-            var viewport = [
-                0,
-                0,
-                this.renderer.getWidth() / 2,
-                this.renderer.getHeight() / 2
-            ];
-            var gaussianDownResults = new Array(gaussianStep); //存放多个高斯Pass的模糊结果，用于Bloom
-            var bloomThresholdPass = new BloomThresholdPass(renderer);
-            bloomThresholdPass.sceneTextureHandle = sceneTextureHandle;
-            this.addRenderPass(bloomThresholdPass);
-            for(var i = 0; i < gaussianStep; i++){
-                gaussianDownResults[i] = new RenderTargetHandle(engine);
-                var gaussianDownHPass = new HQGaussianDownSamplePass(renderer, "H", i);
-                var gaussianDownVPass = new HQGaussianDownSamplePass(renderer, "V", i);
-                gaussianDownVPass.gaussianResult = gaussianDownResults[i];
-                this.addRenderPass(gaussianDownHPass);
-                this.addRenderPass(gaussianDownVPass);
-                viewport[2] /= 2;
-                viewport[3] /= 2;
-            // TODO 限制最大迭代
-            }
-            viewport[2] *= 4;
-            viewport[3] *= 4;
-            for(var i1 = 0; i1 < gaussianStep - 1; i1++){
-                var gaussianUpPass = new HQGaussianUpSamplePass(renderer, gaussianStep - i1);
-                gaussianUpPass.gaussianDownSampleResult = gaussianDownResults[gaussianStep - 2 - i1];
-                this.addRenderPass(gaussianUpPass);
-                viewport[2] *= 2;
-                viewport[3] *= 2;
-            }
+            // Bloom Pass（包含阈值提取、高斯模糊）
+            var bloomPass = new BloomPass(renderer, gaussianStep);
+            bloomPass.sceneTextureHandle = sceneTextureHandle;
+            this.addRenderPass(bloomPass);
+            // Tone Mapping Pass
             var postProcessPass = new ToneMappingPass(renderer, sceneTextureHandle);
             this.addRenderPass(postProcessPass);
         }
@@ -13626,6 +13524,14 @@ var Renderer = /*#__PURE__*/ function() {
     _proto.releaseTemporaryRT = function releaseTemporaryRT(rt) {
         this.renderTargetPool.release(rt);
     };
+    /**
+   * 将源纹理复制到目标 Framebuffer，可使用自定义材质进行处理
+   * @param source - 源纹理
+   * @param destination - 目标 Framebuffer，如果为 null 则渲染到屏幕
+   * @param material - 可选的自定义材质，不传则使用默认复制材质
+   */ _proto.blit = function blit(source, destination, material) {
+    // OVERRIDE
+    };
     _proto.dispose = function dispose() {
     // OVERRIDE
     };
@@ -16688,13 +16594,49 @@ exports.CameraController = __decorate([
     effectsClass(DataType.CameraController)
 ], exports.CameraController);
 
-var CameraVFXItemLoader = /*#__PURE__*/ function(AbstractPlugin) {
-    _inherits(CameraVFXItemLoader, AbstractPlugin);
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function _wrap_native_super(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") throw new TypeError("Super expression must either be null or a function");
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+
+var CameraVFXItemLoader = /*#__PURE__*/ function(Plugin) {
+    _inherits(CameraVFXItemLoader, Plugin);
     function CameraVFXItemLoader() {
-        return AbstractPlugin.apply(this, arguments);
+        return Plugin.apply(this, arguments);
     }
     return CameraVFXItemLoader;
-}(AbstractPlugin);
+}(_wrap_native_super(Plugin));
 
 exports.HitTestType = void 0;
 (function(HitTestType) {
@@ -16978,13 +16920,13 @@ function getCoord(event) {
     };
 }
 
-var InteractLoader = /*#__PURE__*/ function(AbstractPlugin) {
-    _inherits(InteractLoader, AbstractPlugin);
+var InteractLoader = /*#__PURE__*/ function(Plugin) {
+    _inherits(InteractLoader, Plugin);
     function InteractLoader() {
-        return AbstractPlugin.apply(this, arguments);
+        return Plugin.apply(this, arguments);
     }
     return InteractLoader;
-}(AbstractPlugin);
+}(_wrap_native_super(Plugin));
 
 var vertex = "\nprecision highp float;\n\nattribute vec2 aPoint;\nuniform vec4 uPos;\nuniform vec2 uSize;\nuniform vec4 uQuat;\nuniform vec4 uColor;\nuniform mat4 effects_ObjectToWorld;\nuniform mat4 effects_MatrixInvV;\nuniform mat4 effects_MatrixVP;\nvarying vec4 vColor;\n\nvec3 rotateByQuat(vec3 a, vec4 quat){\n  vec3 qvec = quat.xyz;\n  vec3 uv = cross(qvec, a);\n  vec3 uuv = cross(qvec, uv) * 2.;\n  return a +(uv * 2. * quat.w + uuv);\n}\n\nvoid main() {\n  vec4 _pos = uPos;\n  vec3 point = rotateByQuat(vec3(aPoint.xy * uSize, 0.),uQuat);\n  vec4 pos = vec4(_pos.xyz, 1.0);\n  pos = effects_ObjectToWorld * pos;\n  pos.xyz += effects_MatrixInvV[0].xyz * point.x+ effects_MatrixInvV[1].xyz * point.y;\n  gl_Position = effects_MatrixVP * pos;\n  vColor = uColor;\n}\n";
 var fragment = "\nprecision highp float;\n\n#define fragColor gl_FragColor\n\nvarying vec4 vColor;\nvoid main() {\n  gl_FragColor = vColor*vColor.a;\n}\n";
@@ -17583,16 +17525,16 @@ function shouldIgnoreBouncing(arg, mul) {
     return MeshCollider;
 }();
 
-var SpriteLoader = /*#__PURE__*/ function(AbstractPlugin) {
-    _inherits(SpriteLoader, AbstractPlugin);
+var SpriteLoader = /*#__PURE__*/ function(Plugin) {
+    _inherits(SpriteLoader, Plugin);
     function SpriteLoader() {
         var _this;
-        _this = AbstractPlugin.apply(this, arguments) || this;
+        _this = Plugin.apply(this, arguments) || this;
         _this.name = "sprite";
         return _this;
     }
     return SpriteLoader;
-}(AbstractPlugin);
+}(_wrap_native_super(Plugin));
 
 /**
  * 动画图可播放节点对象
@@ -20083,7 +20025,7 @@ function calculateDirection(prePoint, point, nextPoint) {
             if (this.time >= 0 && this.time < particleSystem.item.duration && particleSystem.isEnded()) {
                 particleSystem.reset();
             }
-            particleSystem.update(this.time - particleSystem.time);
+            particleSystem.simulate(this.time - particleSystem.time);
         }
         this.lastTime = this.time;
     };
@@ -21534,126 +21476,133 @@ exports.ParticleSystem = /*#__PURE__*/ function(Component) {
         this.initEmitterTransform();
     };
     _proto.onUpdate = function onUpdate(dt) {
-        this.update(dt);
+        if (!this.frozen) {
+            this.update(dt);
+        }
+    };
+    _proto.simulate = function simulate(time) {
+        this.update(time * 1000);
+        this.frozen = true;
     };
     _proto.update = function update(delta) {
         var _this = this;
-        if (this.started && !this.frozen) {
-            var now = this.time + delta / 1000;
-            var options = this.options;
-            var loopStartTime = this.loopStartTime;
-            var emission = this.emission;
-            this.time = now;
-            this.upDirectionWorld = null;
-            this.renderer.updateTime(now, delta);
-            var link = this.particleLink;
-            var emitterLifetime = (now - loopStartTime) / this.item.duration;
-            var timePassed = this.timePassed;
-            var trailUpdated = false;
-            var updateTrail = function() {
-                if (_this.trails && !trailUpdated) {
-                    trailUpdated = true;
-                    link.forEach(function(param) {
-                        var time = param[0], pointIndex = param[1], delay = param[2], point = param[3];
-                        if (time < timePassed) {
-                            _this.clearPointTrail(pointIndex);
-                        } else if (timePassed > delay) {
-                            _this.updatePointTrail(pointIndex, emitterLifetime, point, delay);
-                        }
-                    });
+        if (!this.started) {
+            return;
+        }
+        var now = this.time + delta / 1000;
+        var options = this.options;
+        var loopStartTime = this.loopStartTime;
+        var emission = this.emission;
+        this.time = now;
+        this.upDirectionWorld = null;
+        this.renderer.updateTime(now, delta);
+        var link = this.particleLink;
+        var emitterLifetime = (now - loopStartTime) / this.item.duration;
+        var timePassed = this.timePassed;
+        var trailUpdated = false;
+        var updateTrail = function() {
+            if (_this.trails && !trailUpdated) {
+                trailUpdated = true;
+                link.forEach(function(param) {
+                    var time = param[0], pointIndex = param[1], delay = param[2], point = param[3];
+                    if (time < timePassed) {
+                        _this.clearPointTrail(pointIndex);
+                    } else if (timePassed > delay) {
+                        _this.updatePointTrail(pointIndex, emitterLifetime, point, delay);
+                    }
+                });
+            }
+        };
+        if (!this.ended) {
+            var duration = this.item.duration;
+            var lifetime = this.lifetime;
+            if (timePassed < duration) {
+                var interval = 1 / emission.rateOverTime.getValue(lifetime);
+                var pointCount = Math.floor((timePassed - this.lastEmitTime) / interval);
+                var maxEmissionCount = pointCount;
+                var timeDelta = interval / pointCount;
+                var meshTime = now;
+                var maxCount = options.maxCount;
+                this.updateEmitterTransform(timePassed);
+                var shouldSkipGenerate = function() {
+                    var first = link.first;
+                    return _this.emissionStopped || link.length === maxCount && first && first.content[0] - loopStartTime > timePassed;
+                };
+                for(var i = 0; i < maxEmissionCount && i < maxCount; i++){
+                    if (shouldSkipGenerate()) {
+                        break;
+                    }
+                    var p = this.createPoint(lifetime);
+                    p.delay += meshTime + i * timeDelta;
+                    this.addParticle(p, maxCount);
+                    this.lastEmitTime = timePassed;
                 }
-            };
-            if (!this.ended) {
-                var duration = this.item.duration;
-                var lifetime = this.lifetime;
-                if (timePassed < duration) {
-                    var interval = 1 / emission.rateOverTime.getValue(lifetime);
-                    var pointCount = Math.floor((timePassed - this.lastEmitTime) / interval);
-                    var maxEmissionCount = pointCount;
-                    var timeDelta = interval / pointCount;
-                    var meshTime = now;
-                    var maxCount = options.maxCount;
-                    this.updateEmitterTransform(timePassed);
-                    var shouldSkipGenerate = function() {
-                        var first = link.first;
-                        return _this.emissionStopped || link.length === maxCount && first && first.content[0] - loopStartTime > timePassed;
-                    };
-                    for(var i = 0; i < maxEmissionCount && i < maxCount; i++){
-                        if (shouldSkipGenerate()) {
-                            break;
-                        }
-                        var p = this.createPoint(lifetime);
-                        p.delay += meshTime + i * timeDelta;
-                        this.addParticle(p, maxCount);
-                        this.lastEmitTime = timePassed;
+                var bursts = emission.bursts;
+                for(var j = (bursts == null ? void 0 : bursts.length) - 1, cursor = 0; j >= 0 && cursor < maxCount; j--){
+                    if (shouldSkipGenerate()) {
+                        break;
                     }
-                    var bursts = emission.bursts;
-                    for(var j = (bursts == null ? void 0 : bursts.length) - 1, cursor = 0; j >= 0 && cursor < maxCount; j--){
-                        if (shouldSkipGenerate()) {
-                            break;
+                    var burst = bursts[j];
+                    var opts = !burst.disabled && burst.getGeneratorOptions(timePassed, lifetime);
+                    if (opts) {
+                        var originVec = [
+                            0,
+                            0,
+                            0
+                        ];
+                        var offsets = emission.burstOffsets[j];
+                        var burstOffset = offsets && offsets[opts.cycleIndex] || originVec;
+                        if (burst.once) {
+                            this.removeBurst(j);
                         }
-                        var burst = bursts[j];
-                        var opts = !burst.disabled && burst.getGeneratorOptions(timePassed, lifetime);
-                        if (opts) {
-                            var originVec = [
-                                0,
-                                0,
-                                0
-                            ];
-                            var offsets = emission.burstOffsets[j];
-                            var burstOffset = offsets && offsets[opts.cycleIndex] || originVec;
-                            if (burst.once) {
-                                this.removeBurst(j);
-                            }
-                            for(var i1 = 0; i1 < opts.count && cursor < maxCount; i1++){
-                                var _p_transform;
-                                if (shouldSkipGenerate()) {
-                                    break;
-                                }
-                                var p1 = this.initPoint(this.shape.generate({
-                                    total: opts.total,
-                                    index: opts.index,
-                                    burstIndex: i1,
-                                    burstCount: opts.count
-                                }));
-                                p1.delay += meshTime;
-                                cursor++;
-                                (_p_transform = p1.transform).translate.apply(_p_transform, [].concat(burstOffset));
-                                this.addParticle(p1, maxCount);
+                        for(var i1 = 0; i1 < opts.count && cursor < maxCount; i1++){
+                            var _p_transform;
+                            if (shouldSkipGenerate()) {
+                                break;
                             }
+                            var p1 = this.initPoint(this.shape.generate({
+                                total: opts.total,
+                                index: opts.index,
+                                burstIndex: i1,
+                                burstCount: opts.count
+                            }));
+                            p1.delay += meshTime;
+                            cursor++;
+                            (_p_transform = p1.transform).translate.apply(_p_transform, [].concat(burstOffset));
+                            this.addParticle(p1, maxCount);
                         }
                     }
-                } else if (this.item.endBehavior === EndBehavior.restart) {
-                    updateTrail();
-                    this.loopStartTime = now - duration;
-                    this.lastEmitTime -= duration;
-                    this.time -= duration;
-                    emission.bursts.forEach(function(b) {
-                        return b.reset();
-                    });
-                    this.particleLink.forEach(function(content) {
-                        content[0] -= duration;
-                        content[2] -= duration;
-                        content[3].delay -= duration;
-                    });
-                    this.renderer.minusTimeForLoop(duration);
-                } else {
-                    this.ended = true;
-                    var endBehavior = this.item.endBehavior;
-                    if (endBehavior === EndBehavior.freeze) {
-                        this.frozen = true;
-                    }
                 }
-            } else if (this.item.endBehavior !== EndBehavior.restart) {
-                if (EndBehavior.destroy === this.item.endBehavior) {
-                    var node = link.last;
-                    if (node && node.content[0] < this.time) {
-                        this.destroyed = true;
-                    }
+            } else if (this.item.endBehavior === EndBehavior.restart) {
+                updateTrail();
+                this.loopStartTime = now - duration;
+                this.lastEmitTime -= duration;
+                this.time -= duration;
+                emission.bursts.forEach(function(b) {
+                    return b.reset();
+                });
+                this.particleLink.forEach(function(content) {
+                    content[0] -= duration;
+                    content[2] -= duration;
+                    content[3].delay -= duration;
+                });
+                this.renderer.minusTimeForLoop(duration);
+            } else {
+                this.ended = true;
+                var endBehavior = this.item.endBehavior;
+                if (endBehavior === EndBehavior.freeze) {
+                    this.frozen = true;
+                }
+            }
+        } else if (this.item.endBehavior !== EndBehavior.restart) {
+            if (EndBehavior.destroy === this.item.endBehavior) {
+                var node = link.last;
+                if (node && node.content[0] < this.time) {
+                    this.destroyed = true;
                 }
             }
-            updateTrail();
         }
+        updateTrail();
     };
     _proto.drawStencilMask = function drawStencilMask(renderer) {
         if (!this.isActiveAndEnabled) {
@@ -25693,7 +25642,6 @@ exports.SpriteComponent = /*#__PURE__*/ function(MaskableGraphic) {
         _this = MaskableGraphic.call(this, engine) || this;
         _this.time = 0;
         _this.duration = 1;
-        _this.loop = true;
         /**
    * @internal
   */ _this.splits = singleSplits;
@@ -25708,11 +25656,15 @@ exports.SpriteComponent = /*#__PURE__*/ function(MaskableGraphic) {
         var _this = this;
         var time = this.time;
         var duration = this.duration;
-        if (time > duration && this.loop) {
+        var textureAnimation = this.textureSheetAnimation;
+        var _textureAnimation_loop;
+        // TODO: Update textureAnimation spec.
+        // @ts-expect-error
+        var loop = (_textureAnimation_loop = textureAnimation == null ? void 0 : textureAnimation.loop) != null ? _textureAnimation_loop : true;
+        if (time > duration && loop) {
             time = time % duration;
         }
         var life = Math.min(Math.max(time / duration, 0.0), 1.0);
-        var ta = this.textureSheetAnimation;
         var video = this.renderer.texture.source.video;
         if (video) {
             if (time === 0) {
@@ -25724,9 +25676,9 @@ exports.SpriteComponent = /*#__PURE__*/ function(MaskableGraphic) {
             }
             this.renderer.texture.uploadCurrentVideoFrame();
         }
-        if (ta) {
+        if (textureAnimation) {
             var _this_material_getVector4;
-            var total = ta.total || ta.row * ta.col;
+            var total = textureAnimation.total || textureAnimation.row * textureAnimation.col;
             var texRectX = 0;
             var texRectY = 0;
             var texRectW = 1;
@@ -25747,20 +25699,20 @@ exports.SpriteComponent = /*#__PURE__*/ function(MaskableGraphic) {
             }
             var dx, dy;
             if (flip) {
-                dx = 1 / ta.row * texRectW;
-                dy = 1 / ta.col * texRectH;
+                dx = 1 / textureAnimation.row * texRectW;
+                dy = 1 / textureAnimation.col * texRectH;
             } else {
-                dx = 1 / ta.col * texRectW;
-                dy = 1 / ta.row * texRectH;
+                dx = 1 / textureAnimation.col * texRectW;
+                dy = 1 / textureAnimation.row * texRectH;
             }
             var texOffset;
-            if (ta.animate) {
+            if (textureAnimation.animate) {
                 var frameIndex = Math.round(life * (total - 1));
-                var yIndex = Math.floor(frameIndex / ta.col);
-                var xIndex = frameIndex - yIndex * ta.col;
+                var yIndex = Math.floor(frameIndex / textureAnimation.col);
+                var xIndex = frameIndex - yIndex * textureAnimation.col;
                 texOffset = flip ? [
                     dx * yIndex,
-                    dy * (ta.col - xIndex)
+                    dy * (textureAnimation.col - xIndex)
                 ] : [
                     dx * xIndex,
                     dy * (1 + yIndex)
@@ -25948,8 +25900,6 @@ exports.SpriteComponent = /*#__PURE__*/ function(MaskableGraphic) {
         var _data_duration;
         //@ts-expect-error
         this.duration = (_data_duration = data.duration) != null ? _data_duration : this.item.duration;
-        var _data_loop;
-        this.loop = (_data_loop = data.loop) != null ? _data_loop : true;
     };
     return SpriteComponent;
 }(MaskableGraphic);
@@ -25957,21 +25907,21 @@ exports.SpriteComponent = __decorate([
     effectsClass(DataType.SpriteComponent)
 ], exports.SpriteComponent);
 
-var ParticleLoader = /*#__PURE__*/ function(AbstractPlugin) {
-    _inherits(ParticleLoader, AbstractPlugin);
+var ParticleLoader = /*#__PURE__*/ function(Plugin) {
+    _inherits(ParticleLoader, Plugin);
     function ParticleLoader() {
-        return AbstractPlugin.apply(this, arguments);
+        return Plugin.apply(this, arguments);
     }
     return ParticleLoader;
-}(AbstractPlugin);
+}(_wrap_native_super(Plugin));
 
-var CalculateLoader = /*#__PURE__*/ function(AbstractPlugin) {
-    _inherits(CalculateLoader, AbstractPlugin);
+var CalculateLoader = /*#__PURE__*/ function(Plugin) {
+    _inherits(CalculateLoader, Plugin);
     function CalculateLoader() {
-        return AbstractPlugin.apply(this, arguments);
+        return Plugin.apply(this, arguments);
     }
     return CalculateLoader;
-}(AbstractPlugin);
+}(_wrap_native_super(Plugin));
 
 // Based on:
 /**
@@ -29073,6 +29023,12 @@ exports.TextComponent = /*#__PURE__*/ function(MaskableGraphic) {
         /**
    * 每一行文本的最大宽度
    */ _this.maxLineWidth = 0;
+        /**
+   * 初始文本宽度，用于计算缩放比例
+   */ _this.baseTextWidth = 0;
+        /**
+   * 初始 `transform.size.x`，用于按比例更新显示宽度
+   */ _this.baseScaleX = 1;
         _this.name = "MText" + seed$1++;
         // 初始化canvas资源
         _this.canvas = canvasPool.getCanvas();
@@ -29098,10 +29054,11 @@ exports.TextComponent = /*#__PURE__*/ function(MaskableGraphic) {
                 text: "默认文本",
                 fontFamily: "AlibabaSans-BoldItalic",
                 fontSize: 40,
+                // 统一使用 0-1 颜色值
                 textColor: [
-                    255,
-                    255,
-                    255,
+                    1,
+                    1,
+                    1,
                     1
                 ],
                 fontWeight: TextWeight.normal,
@@ -29138,6 +29095,10 @@ exports.TextComponent = /*#__PURE__*/ function(MaskableGraphic) {
         // TextComponentBase
         this.updateWithOptions(options);
         this.renderText(options);
+        // 记录初始的 textWidth 和 x 缩放，用于后续按比例更新显示宽度
+        // 添加兜底值 1 防止除 0
+        this.baseTextWidth = options.textWidth || this.textLayout.width || 1;
+        this.baseScaleX = this.item.transform.size.x;
         // 恢复默认颜色
         this.material.setColor("_Color", new Color(1, 1, 1, 1));
     };
@@ -29336,9 +29297,9 @@ exports.TextComponent = /*#__PURE__*/ function(MaskableGraphic) {
             if (style.isOutlined) {
                 _this.setupOutline();
             }
-            // 文本颜色 - 直接使用 vec4 原值，不乘以 255
+            // textColor 统一是 0-1，写入 canvas 时乘 255
             var _style_textColor = style.textColor, r = _style_textColor[0], g = _style_textColor[1], b = _style_textColor[2], a = _style_textColor[3];
-            context.fillStyle = "rgba(" + r + ", " + g + ", " + b + ", " + a + ")";
+            context.fillStyle = "rgba(" + r * 255 + ", " + g * 255 + ", " + b * 255 + ", " + a + ")";
             var charsInfo = [];
             var x = 0;
             var y = layout.getOffsetY(style, _this.lineCount, lineHeight, fontSize);
@@ -29400,6 +29361,46 @@ exports.TextComponent = /*#__PURE__*/ function(MaskableGraphic) {
         layout.autoWidth = normalizedValue;
         this.isDirty = true;
     };
+    /**
+   * 设置文本框宽度
+   * 手动设置宽度时会自动关闭 `autoWidth`
+   * 同时会按比例更新 `transform.size.x`，让 UI 框宽度也跟着变化
+   * @param value - 文本框宽度
+   */ _proto.setTextWidth = function setTextWidth(value) {
+        var width = Math.max(0, Number(value) || 0);
+        var layout = this.textLayout;
+        // 宽度没变且已是非 autoWidth 模式,直接返回
+        if (layout.width === width && layout.autoWidth === false) {
+            return;
+        }
+        // 手动设置宽度时关闭 autoWidth
+        layout.autoWidth = false;
+        layout.width = width;
+        // 按当前 overflow 模式重新计算行数和 maxLineWidth
+        this.lineCount = this.getLineCount(this.text || "");
+        this.isDirty = true;
+        // 同步更新外层显示宽度(按比例缩放 transform)
+        // 这样 UI 框的视觉宽度也会跟着文本宽度变化
+        if (this.baseTextWidth > 0) {
+            var scale = width / this.baseTextWidth;
+            this.item.transform.size.x = this.baseScaleX * scale;
+        }
+    };
+    /**
+   * 设置文本框高度
+   * @param value - 文本框高度
+   */ _proto.setTextHeight = function setTextHeight(value) {
+        var height = Math.max(0, Number(value) || 0);
+        if (height === 0) {
+            return;
+        }
+        var layout = this.textLayout;
+        if (layout.height === height) {
+            return;
+        }
+        layout.height = height;
+        this.isDirty = true;
+    };
     _proto.setFontSize = function setFontSize(value) {
         if (this.textStyle.fontSize === value) {
             return;
@@ -29467,13 +29468,13 @@ applyMixins(exports.TextComponent, [
 ]);
 
 // TODO: 注册必须用
-var TextLoader = /*#__PURE__*/ function(AbstractPlugin) {
-    _inherits(TextLoader, AbstractPlugin);
+var TextLoader = /*#__PURE__*/ function(Plugin) {
+    _inherits(TextLoader, Plugin);
     function TextLoader() {
-        return AbstractPlugin.apply(this, arguments);
+        return Plugin.apply(this, arguments);
     }
     return TextLoader;
-}(AbstractPlugin);
+}(_wrap_native_super(Plugin));
 
 var Asset = /*#__PURE__*/ function(EffectsObject) {
     _inherits(Asset, EffectsObject);
@@ -30530,6 +30531,10 @@ function version35Migration(json) {
             if (component.dataType === DataType.TextComponent || component.dataType === DataType.RichTextComponent && component.options) {
                 ensureTextVerticalAlign(component.options);
             }
+            // 处理文本颜色从 0-255 到 0-1 的转换
+            if (component.dataType === DataType.TextComponent) {
+                convertTextColorTo01(component.options);
+            }
         }
     }
     //@ts-expect-error
@@ -30549,6 +30554,22 @@ function version35Migration(json) {
         options.TextVerticalAlign = options.textBaseline;
     }
 }
+/**
+ * 将文本颜色从 0-255 转换到 0-1
+ */ function convertTextColorTo01(options) {
+    if (!options || !options.textColor) {
+        return;
+    }
+    var textColor = options.textColor;
+    var _textColor_;
+    // 将 RGB 从 0-255 转换到 0-1（alpha 通道已经是 0-1，不需要转换）
+    options.textColor = [
+        textColor[0] / 255.0,
+        textColor[1] / 255.0,
+        textColor[2] / 255.0,
+        (_textColor_ = textColor[3]) != null ? _textColor_ : 1
+    ];
+}
 /**
  * 根据形状获取形状几何体数据
  * @param shape - 形状
@@ -31471,7 +31492,7 @@ function getStandardSpriteContent(sprite, transform) {
     return ret;
 }
 
-var version$1 = "2.8.0-alpha.2";
+var version$1 = "2.8.0-alpha.4";
 var v0 = /^(\d+)\.(\d+)\.(\d+)(-(\w+)\.\d+)?$/;
 var standardVersion = /^(\d+)\.(\d+)$/;
 var reverseParticle = false;
@@ -32111,8 +32132,8 @@ var seed = 1;
                                 };
                                 return [
                                     4,
-                                    hookTimeInfo("plugin:processAssets", function() {
-                                        return _this.processPluginAssets(scene);
+                                    hookTimeInfo("plugin:onAssetsLoadStart", function() {
+                                        return _this.onPluginSceneLoadStart(scene);
                                     })
                                 ];
                             case 6:
@@ -32400,7 +32421,7 @@ var seed = 1;
             });
         })();
     };
-    _proto.processPluginAssets = function processPluginAssets(scene) {
+    _proto.onPluginSceneLoadStart = function onPluginSceneLoadStart(scene) {
         var _this = this;
         return _async_to_generator(function() {
             return __generator(this, function(_state) {
@@ -32408,7 +32429,7 @@ var seed = 1;
                     case 0:
                         return [
                             4,
-                            PluginSystem.processAssets(scene, _this.options)
+                            PluginSystem.onAssetsLoadStart(scene, _this.options)
                         ];
                     case 1:
                         _state.sent();
@@ -35109,8 +35130,8 @@ var SceneLoader = /*#__PURE__*/ function() {
                     case 1:
                         loadedScene = _state.sent();
                         engine.clearResources();
-                        // 触发插件系统 pluginSystem 的回调 prepareResource
-                        PluginSystem.loadResources(loadedScene, assetManager.options, engine);
+                        // 触发插件系统 pluginSystem 的回调 onAssetsLoadFinish
+                        PluginSystem.onAssetsLoadFinish(loadedScene, assetManager.options, engine);
                         engine.assetService.prepareAssets(loadedScene, loadedScene.assets);
                         engine.assetService.updateTextVariables(loadedScene, options.variables);
                         engine.assetService.initializeTexture(loadedScene);
@@ -35172,10 +35193,9 @@ registerPlugin("sprite", SpriteLoader);
 registerPlugin("particle", ParticleLoader);
 registerPlugin("cal", CalculateLoader);
 registerPlugin("interact", InteractLoader);
-var version = "2.8.0-alpha.2";
+var version = "2.8.0-alpha.4";
 logger.info("Core version: " + version + ".");
 
-exports.AbstractPlugin = AbstractPlugin;
 exports.ActivationMixerPlayable = ActivationMixerPlayable;
 exports.ActivationPlayable = ActivationPlayable;
 exports.AndNode = AndNode;
@@ -35275,6 +35295,7 @@ exports.PathSegments = PathSegments;
 exports.Playable = Playable;
 exports.PlayableAsset = PlayableAsset;
 exports.PlayableOutput = PlayableOutput;
+exports.Plugin = Plugin;
 exports.PluginSystem = PluginSystem;
 exports.PointerEventData = PointerEventData;
 exports.PolyStar = PolyStar;