@galacean/engine-core 1.3.24 → 1.3.26

package/dist/miniprogram.js

@@ -162,6 +162,34 @@ function __decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 
+function __generator(thisArg, body) {
+  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+  function verb(n) { return function (v) { return step([n, v]); }; }
+  function step(op) {
+      if (f) throw new TypeError("Generator is already executing.");
+      while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+              case 0: case 1: t = op; break;
+              case 4: _.label++; return { value: op[1], done: false };
+              case 5: _.label++; y = op[1]; op = [0]; continue;
+              case 7: op = _.ops.pop(); _.trys.pop(); continue;
+              default:
+                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                  if (t[2]) _.ops.pop();
+                  _.trys.pop(); continue;
+          }
+          op = body.call(thisArg, _);
+      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+  }
+}
+
 typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
   var e = new Error(message);
   return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
@@ -3856,11 +3884,13 @@ __decorate([
     /**
    * @internal
    * @todo Should merge when we can delete material render state
-   */ _proto._applyRenderQueueByShaderData = function _applyRenderQueueByShaderData(renderStateDataMap, shaderData) {
+   */ _proto._getRenderQueueByShaderData = function _getRenderQueueByShaderData(renderStateDataMap, shaderData) {
         var renderQueueType = renderStateDataMap[exports.RenderStateDataKey.RenderQueueType];
-        if (renderQueueType !== undefined) {
+        if (renderQueueType === undefined) {
+            return this.renderQueueType;
+        } else {
             var _shaderData_getFloat;
-            this.renderQueueType = (_shaderData_getFloat = shaderData.getFloat(renderQueueType)) != null ? _shaderData_getFloat : exports.RenderQueueType.Opaque;
+            return (_shaderData_getFloat = shaderData.getFloat(renderQueueType)) != null ? _shaderData_getFloat : exports.RenderQueueType.Opaque;
         }
     };
     _proto._applyStatesByShaderData = function _applyStatesByShaderData(renderStateDataMap, shaderData) {
@@ -5075,9 +5105,11 @@ exports.DependentMode = void 0;
         _this._rotation = new miniprogram.Vector3();
         _this._rotationQuaternion = new miniprogram.Quaternion();
         _this._scale = new miniprogram.Vector3(1, 1, 1);
+        _this._localUniformScaling = true;
         _this._worldPosition = new miniprogram.Vector3();
         _this._worldRotation = new miniprogram.Vector3();
         _this._worldRotationQuaternion = new miniprogram.Quaternion();
+        _this._worldUniformScaling = true;
         _this._lossyWorldScale = new miniprogram.Vector3(1, 1, 1);
         _this._localMatrix = new miniprogram.Matrix();
         _this._worldMatrix = new miniprogram.Matrix();
@@ -5244,7 +5276,7 @@ exports.DependentMode = void 0;
    * @internal
    */ _proto._parentChange = function _parentChange() {
         this._isParentDirty = true;
-        this._updateAllWorldFlag();
+        this._updateAllWorldFlag(0x1bc);
     };
     /**
    * @internal
@@ -5279,10 +5311,10 @@ exports.DependentMode = void 0;
    */ _proto._updateWorldPositionFlag = function _updateWorldPositionFlag() {
         if (!this._isContainDirtyFlags(0x84)) {
             this._worldAssociatedChange(0x84);
-            var nodeChildren = this._entity._children;
-            for(var i = 0, n = nodeChildren.length; i < n; i++){
-                var _nodeChildren_i_transform;
-                (_nodeChildren_i_transform = nodeChildren[i].transform) == null ? void 0 : _nodeChildren_i_transform._updateWorldPositionFlag();
+            var children = this._entity._children;
+            for(var i = 0, n = children.length; i < n; i++){
+                var _children_i_transform;
+                (_children_i_transform = children[i].transform) == null ? void 0 : _children_i_transform._updateWorldPositionFlag();
             }
         }
     };
@@ -5291,14 +5323,19 @@ exports.DependentMode = void 0;
    * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
    * Get worldRotationQuaternion: Will trigger the world rotation (in quaternion) update of itself and all parent entities.
    * Get worldRotation: Will trigger the world rotation(in euler and quaternion) update of itself and world rotation(in quaternion) update of all parent entities.
+   * Get worldScale: Will trigger the scaling update of itself and all parent entities.
    * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
    */ _proto._updateWorldRotationFlag = function _updateWorldRotationFlag() {
-        if (!this._isContainDirtyFlags(0x98)) {
-            this._worldAssociatedChange(0x98);
-            var nodeChildren = this._entity._children;
-            for(var i = 0, n = nodeChildren.length; i < n; i++){
-                var _nodeChildren_i_transform;
-                (_nodeChildren_i_transform = nodeChildren[i].transform) == null ? void 0 : _nodeChildren_i_transform._updateWorldPositionAndRotationFlag(); // Rotation update of parent entity will trigger world position and rotation update of all child entity.
+        var parent = this._getParentTransform();
+        var parentWorldUniformScaling = parent ? parent._getWorldUniformScaling() : true;
+        var flags = parentWorldUniformScaling ? 0x98 : 0xb8;
+        if (!this._isContainDirtyFlags(flags)) {
+            this._worldAssociatedChange(flags);
+            flags = this._getWorldUniformScaling() ? 0x9c : 0xbc;
+            var children = this._entity._children;
+            for(var i = 0, n = children.length; i < n; i++){
+                var _children_i_transform;
+                (_children_i_transform = children[i].transform) == null ? void 0 : _children_i_transform._updateWorldPositionAndRotationFlag(flags); // Rotation update of parent entity will trigger world position, rotation and scale update of all child entity.
             }
         }
     };
@@ -5307,14 +5344,17 @@ exports.DependentMode = void 0;
    * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
    * Get worldRotationQuaternion: Will trigger the world rotation (in quaternion) update of itself and all parent entities.
    * Get worldRotation: Will trigger the world rotation(in euler and quaternion) update of itself and world rotation(in quaternion) update of all parent entities.
+   * Get worldScale: Will trigger the scaling update of itself and all parent entities.
    * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
-   */ _proto._updateWorldPositionAndRotationFlag = function _updateWorldPositionAndRotationFlag() {
-        if (!this._isContainDirtyFlags(0x9c)) {
-            this._worldAssociatedChange(0x9c);
-            var nodeChildren = this._entity._children;
-            for(var i = 0, n = nodeChildren.length; i < n; i++){
-                var _nodeChildren_i_transform;
-                (_nodeChildren_i_transform = nodeChildren[i].transform) == null ? void 0 : _nodeChildren_i_transform._updateWorldPositionAndRotationFlag();
+   * @param flags - Dirty flag
+   */ _proto._updateWorldPositionAndRotationFlag = function _updateWorldPositionAndRotationFlag(flags) {
+        if (!this._isContainDirtyFlags(flags)) {
+            this._worldAssociatedChange(flags);
+            flags = this._getWorldUniformScaling() ? 0x9c : 0xbc;
+            var children = this._entity._children;
+            for(var i = 0, n = children.length; i < n; i++){
+                var _children_i_transform;
+                (_children_i_transform = children[i].transform) == null ? void 0 : _children_i_transform._updateWorldPositionAndRotationFlag(flags);
             }
         }
     };
@@ -5323,13 +5363,15 @@ exports.DependentMode = void 0;
    * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
    * Get worldScale: Will trigger the scaling update of itself and all parent entities.
    * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix) to be false.
-   */ _proto._updateWorldScaleFlag = function _updateWorldScaleFlag() {
-        if (!this._isContainDirtyFlags(0xa0)) {
-            this._worldAssociatedChange(0xa0);
-            var nodeChildren = this._entity._children;
-            for(var i = 0, n = nodeChildren.length; i < n; i++){
-                var _nodeChildren_i_transform;
-                (_nodeChildren_i_transform = nodeChildren[i].transform) == null ? void 0 : _nodeChildren_i_transform._updateWorldPositionAndScaleFlag();
+   * @param flags - Dirty flag
+   */ _proto._updateWorldScaleFlag = function _updateWorldScaleFlag(flags) {
+        if (!this._isContainDirtyFlags(flags)) {
+            this._worldAssociatedChange(flags);
+            flags |= 0x4;
+            var children = this._entity._children;
+            for(var i = 0, n = children.length; i < n; i++){
+                var _children_i_transform;
+                (_children_i_transform = children[i].transform) == null ? void 0 : _children_i_transform._updateWorldPositionAndScaleFlag(flags);
             }
         }
     };
@@ -5338,25 +5380,27 @@ exports.DependentMode = void 0;
    * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
    * Get worldScale: Will trigger the scaling update of itself and all parent entities.
    * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix) to be false.
-   */ _proto._updateWorldPositionAndScaleFlag = function _updateWorldPositionAndScaleFlag() {
-        if (!this._isContainDirtyFlags(0xa4)) {
-            this._worldAssociatedChange(0xa4);
-            var nodeChildren = this._entity._children;
-            for(var i = 0, n = nodeChildren.length; i < n; i++){
-                var _nodeChildren_i_transform;
-                (_nodeChildren_i_transform = nodeChildren[i].transform) == null ? void 0 : _nodeChildren_i_transform._updateWorldPositionAndScaleFlag();
+   * @param flags - Dirty flag
+   */ _proto._updateWorldPositionAndScaleFlag = function _updateWorldPositionAndScaleFlag(flags) {
+        if (!this._isContainDirtyFlags(flags)) {
+            this._worldAssociatedChange(flags);
+            var children = this._entity._children;
+            for(var i = 0, n = children.length; i < n; i++){
+                var _children_i_transform;
+                (_children_i_transform = children[i].transform) == null ? void 0 : _children_i_transform._updateWorldPositionAndScaleFlag(flags);
             }
         }
     };
     /**
    * Update all world transform property dirty flag, the principle is the same as above.
-   */ _proto._updateAllWorldFlag = function _updateAllWorldFlag() {
-        if (!this._isContainDirtyFlags(0xbc)) {
-            this._worldAssociatedChange(0xbc);
-            var nodeChildren = this._entity._children;
-            for(var i = 0, n = nodeChildren.length; i < n; i++){
-                var _nodeChildren_i_transform;
-                (_nodeChildren_i_transform = nodeChildren[i].transform) == null ? void 0 : _nodeChildren_i_transform._updateAllWorldFlag();
+   * @param flags - Dirty flag
+   */ _proto._updateAllWorldFlag = function _updateAllWorldFlag(flags) {
+        if (!this._isContainDirtyFlags(flags)) {
+            this._worldAssociatedChange(flags);
+            var children = this._entity._children;
+            for(var i = 0, n = children.length; i < n; i++){
+                var _children_i_transform;
+                (_children_i_transform = children[i].transform) == null ? void 0 : _children_i_transform._updateAllWorldFlag(flags);
             }
         }
     };
@@ -5404,7 +5448,7 @@ exports.DependentMode = void 0;
     };
     _proto._worldAssociatedChange = function _worldAssociatedChange(type) {
         this._dirtyFlag |= type;
-        this._updateFlagManager.dispatch(0x80);
+        this._updateFlagManager.dispatch(type);
     };
     _proto._rotateByQuat = function _rotateByQuat(rotateQuat, relativeToLocal) {
         if (relativeToLocal) {
@@ -5473,8 +5517,28 @@ exports.DependentMode = void 0;
         this._setDirtyFlagFalse(0x10);
     };
     _proto._onScaleChanged = function _onScaleChanged() {
+        var _this__scale = this._scale, x = _this__scale.x, y = _this__scale.y, z = _this__scale.z;
         this._setDirtyFlagTrue(0x40);
-        this._updateWorldScaleFlag();
+        var localUniformScaling = x == y && y == z;
+        if (this._localUniformScaling !== localUniformScaling) {
+            this._localUniformScaling = localUniformScaling;
+            this._updateWorldScaleFlag(0x1a0);
+        } else {
+            this._updateWorldScaleFlag(0xa0);
+        }
+    };
+    _proto._getWorldUniformScaling = function _getWorldUniformScaling() {
+        if (this._isContainDirtyFlag(0x100)) {
+            var localUniformScaling = this._localUniformScaling;
+            if (localUniformScaling) {
+                var parent = this._getParentTransform();
+                this._worldUniformScaling = localUniformScaling && (parent ? parent._getWorldUniformScaling() : true);
+            } else {
+                this._worldUniformScaling = false;
+            }
+            this._setDirtyFlagFalse(0x100);
+        }
+        return this._worldUniformScaling;
     };
     _create_class(Transform, [
         {
@@ -5641,11 +5705,12 @@ exports.DependentMode = void 0;
             key: "lossyWorldScale",
             get: /**
    * Local lossy scaling.
-   * @remarks The value obtained may not be correct under certain conditions(for example, the parent node has scaling,
-   * and the child node has a rotation), the scaling will be tilted. Vector3 cannot be used to correctly represent the scaling. Must use Matrix3x3.
+   * @remarks The value obtained may not be correct under certain conditions(for example, the parent node has non-uniform world scaling,
+   * and the child node has a rotation), the scaling will be tilted.
    */ function get() {
                 if (this._isContainDirtyFlag(0x20)) {
                     if (this._getParentTransform()) {
+                        // Vector3 cannot be used to correctly represent the scaling. Must use Matrix3x3
                         var scaleMat = this._getScaleMatrix();
                         var e = scaleMat.elements;
                         this._lossyWorldScale.set(e[0], e[4], e[8]);
@@ -5673,18 +5738,25 @@ exports.DependentMode = void 0;
                 if (this._localMatrix !== value) {
                     this._localMatrix.copyFrom(value);
                 }
+                var _this = this, position = _this._position, rotationQuaternion = _this._rotationQuaternion, scale = _this._scale;
                 // @ts-ignore
-                this._position._onValueChanged = this._rotationQuaternion._onValueChanged = this._scale._onValueChanged = null;
-                this._localMatrix.decompose(this._position, this._rotationQuaternion, this._scale);
+                position._onValueChanged = rotationQuaternion._onValueChanged = scale._onValueChanged = null;
+                this._localMatrix.decompose(position, rotationQuaternion, scale);
                 // @ts-ignore
-                this._position._onValueChanged = this._onPositionChanged;
+                position._onValueChanged = this._onPositionChanged;
                 // @ts-ignore
-                this._rotationQuaternion._onValueChanged = this._onRotationQuaternionChanged;
+                rotationQuaternion._onValueChanged = this._onRotationQuaternionChanged;
                 // @ts-ignore
-                this._scale._onValueChanged = this._onScaleChanged;
+                scale._onValueChanged = this._onScaleChanged;
                 this._setDirtyFlagTrue(0x1);
                 this._setDirtyFlagFalse(0x40 | 0x2);
-                this._updateAllWorldFlag();
+                var localUniformScaling = scale.x === scale.y && scale.y === scale.z;
+                if (this._localUniformScaling !== localUniformScaling) {
+                    this._localUniformScaling = localUniformScaling;
+                    this._updateAllWorldFlag(0x1bc);
+                } else {
+                    this._updateAllWorldFlag(0xbc);
+                }
             }
         },
         {
@@ -5794,6 +5866,9 @@ __decorate([
 __decorate([
     deepClone
 ], Transform.prototype, "_scale", void 0);
+__decorate([
+    assignmentClone
+], Transform.prototype, "_localUniformScaling", void 0);
 __decorate([
     deepClone
 ], Transform.prototype, "_worldPosition", void 0);
@@ -5803,6 +5878,9 @@ __decorate([
 __decorate([
     deepClone
 ], Transform.prototype, "_worldRotationQuaternion", void 0);
+__decorate([
+    assignmentClone
+], Transform.prototype, "_worldUniformScaling", void 0);
 __decorate([
     deepClone
 ], Transform.prototype, "_lossyWorldScale", void 0);
@@ -5861,12 +5939,18 @@ var TransformModifyFlags;
     TransformModifyFlags[TransformModifyFlags["WorldScale"] = 0x20] = "WorldScale";
     TransformModifyFlags[TransformModifyFlags["LocalMatrix"] = 0x40] = "LocalMatrix";
     TransformModifyFlags[TransformModifyFlags["WorldMatrix"] = 0x80] = "WorldMatrix";
+    TransformModifyFlags[TransformModifyFlags[/** This is an internal flag used to assist in determining the dispatch
+   *  of world scaling dirty flags in the case of non-uniform scaling.
+   */ "IsWorldUniformScaling"] = 0x100] = "IsWorldUniformScaling";
     TransformModifyFlags[TransformModifyFlags[/** WorldMatrix | WorldPosition */ "WmWp"] = 0x84] = "WmWp";
     TransformModifyFlags[TransformModifyFlags[/** WorldMatrix | WorldEuler | WorldQuat */ "WmWeWq"] = 0x98] = "WmWeWq";
+    TransformModifyFlags[TransformModifyFlags[/** WorldMatrix | WorldEuler | WorldQuat | WorldScale*/ "WmWeWqWs"] = 0xb8] = "WmWeWqWs";
     TransformModifyFlags[TransformModifyFlags[/** WorldMatrix | WorldPosition | WorldEuler | WorldQuat */ "WmWpWeWq"] = 0x9c] = "WmWpWeWq";
     TransformModifyFlags[TransformModifyFlags[/** WorldMatrix | WorldScale */ "WmWs"] = 0xa0] = "WmWs";
+    TransformModifyFlags[TransformModifyFlags[/** WorldMatrix | WorldScale | WorldUniformScaling */ "WmWsWus"] = 0x1a0] = "WmWsWus";
     TransformModifyFlags[TransformModifyFlags[/** WorldMatrix | WorldPosition | WorldScale */ "WmWpWs"] = 0xa4] = "WmWpWs";
     TransformModifyFlags[TransformModifyFlags[/** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale */ "WmWpWeWqWs"] = 0xbc] = "WmWpWeWqWs";
+    TransformModifyFlags[TransformModifyFlags[/** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling */ "WmWpWeWqWsWus"] = 0x1bc] = "WmWpWeWqWsWus";
 })(TransformModifyFlags || (TransformModifyFlags = {}));
 
 // @ts-ignore
@@ -8196,11 +8280,13 @@ var /**
    * @param viewport - Viewport
    * @param material - The material to use when blitting
    * @param passIndex - Pass index to use of the provided material
-   */ PipelineUtils.blitTexture = function blitTexture(engine, source, destination, mipLevel, viewport, material, passIndex) {
+   * @param flipYOfSource - Whether flip Y axis of source texture
+   */ PipelineUtils.blitTexture = function blitTexture(engine, source, destination, mipLevel, viewport, material, passIndex, flipYOfSource) {
         if (mipLevel === void 0) mipLevel = 0;
         if (viewport === void 0) viewport = PipelineUtils.defaultViewport;
         if (material === void 0) material = null;
         if (passIndex === void 0) passIndex = 0;
+        if (flipYOfSource === void 0) flipYOfSource = false;
         var basicResources = engine._basicResources;
         var blitMesh = destination ? basicResources.flipYBlitMesh : basicResources.blitMesh;
         var blitMaterial = material || basicResources.blitMaterial;
@@ -8214,9 +8300,15 @@ var /**
         rendererShaderData.setFloat(PipelineUtils._blitMipLevelProperty, mipLevel);
         PipelineUtils._texelSize.set(1 / source.width, 1 / source.height, source.width, source.height);
         rendererShaderData.setVector4(PipelineUtils._blitTexelSizeProperty, PipelineUtils._texelSize);
+        if (flipYOfSource) {
+            rendererShaderData.enableMacro(PipelineUtils._flipYTextureMacro);
+        } else {
+            rendererShaderData.disableMacro(PipelineUtils._flipYTextureMacro);
+        }
         var pass = blitMaterial.shader.subShaders[0].passes[passIndex];
         var compileMacros = Shader._compileMacros;
-        ShaderMacroCollection.unionCollection(context.camera._globalShaderMacro, blitMaterial.shaderData._macroCollection, compileMacros);
+        ShaderMacroCollection.unionCollection(context.camera._globalShaderMacro, rendererShaderData._macroCollection, compileMacros);
+        ShaderMacroCollection.unionCollection(compileMacros, blitMaterial.shaderData._macroCollection, compileMacros);
         var program = pass._getShaderProgram(engine, compileMacros);
         program.bind();
         program.groupingOtherUniformBlock();
@@ -8238,6 +8330,9 @@ var /**
     PipelineUtils._blitTexelSizeProperty = ShaderProperty.getByName("renderer_texelSize") // x: 1/width, y: 1/height, z: width, w: height
     ;
 })();
+(function() {
+    PipelineUtils._flipYTextureMacro = ShaderMacro.getByName("renderer_FlipYBlitTexture");
+})();
 (function() {
     PipelineUtils._rendererShaderData = new ShaderData(ShaderDataGroup.Renderer);
 })();
@@ -8361,7 +8456,7 @@ exports.Camera = (_Camera = /*#__PURE__*/ function(Component1) {
         /**
    * Multi-sample anti-aliasing samples when use independent canvas mode.
    *
-   * @remarks The `independentCanvasEnabled` property should be `true` to take effect, otherwise it will be invalid.
+   * @remarks It will take effect when `independentCanvasEnabled` property is `true`, otherwise it will be invalid.
    */ _this.msaaSamples = exports.MSAASamples.None;
         /** @internal */ _this._cameraType = exports.CameraType.Normal;
         /** @internal */ _this._globalShaderMacro = new ShaderMacroCollection();
@@ -8722,13 +8817,17 @@ exports.Camera = (_Camera = /*#__PURE__*/ function(Component1) {
             key: "independentCanvasEnabled",
             get: /**
    * Whether independent canvas is enabled.
-   *
    * @remarks If true, the msaa in viewport can turn or off independently by `msaaSamples` property.
    */ function get() {
-                if (this.enableHDR || this.enablePostProcess && this.scene._postProcessManager.hasActiveEffect) {
+                // Uber pass need internal RT
+                if (this.enablePostProcess && this.scene._postProcessManager.hasActiveEffect) {
                     return true;
                 }
-                return this.opaqueTextureEnabled && !this._renderTarget;
+                if (this.enableHDR || this.opaqueTextureEnabled) {
+                    var _this_renderTarget;
+                    return this._getInternalColorTextureFormat() !== ((_this_renderTarget = this.renderTarget) == null ? void 0 : _this_renderTarget.getColorTexture(0).format);
+                }
+                return false;
             }
         },
         {
@@ -9233,8 +9332,15 @@ var ContextRendererUpdateFlag;
                 if (shaderPass.getTagValue(pipelineStageKey) !== pipelineStageTagValue) {
                     continue;
                 }
-                var _shaderPass__renderState;
-                if (((_shaderPass__renderState = shaderPass._renderState) != null ? _shaderPass__renderState : renderStates[j]).renderQueueType !== renderQueueType) {
+                var renderState = shaderPass._renderState;
+                var passQueueType = void 0;
+                if (renderState) {
+                    passQueueType = renderState._getRenderQueueByShaderData(shaderPass._renderStateDataMap, materialData);
+                } else {
+                    renderState = renderStates[j];
+                    passQueueType = renderState.renderQueueType;
+                }
+                if (passQueueType !== renderQueueType) {
                     continue;
                 }
                 var program = shaderPass._getShaderProgram(engine, compileMacros);
@@ -9288,8 +9394,6 @@ var ContextRendererUpdateFlag;
                         program.uploadUnGroupTextures();
                     }
                 }
-                var _shaderPass__renderState1;
-                var renderState = (_shaderPass__renderState1 = shaderPass._renderState) != null ? _shaderPass__renderState1 : renderStates[j];
                 renderState._applyStates(engine, renderer.entity.transform._isFrontFaceInvert(), shaderPass._renderStateDataMap, material.shaderData);
                 rhi.drawPrimitive(primitive, subElement.subPrimitive, program);
             }
@@ -9316,9 +9420,12 @@ var ContextRendererUpdateFlag;
         var camera = context.camera;
         var engine = camera.engine;
         camera.scene._maskManager.buildMaskRenderElement(master, incrementMaskQueue, decrementMaskQueue);
+        var primitiveChunkManagerMask = engine._batcherManager.primitiveChunkManagerMask;
         incrementMaskQueue._batch(engine._batcherManager);
+        primitiveChunkManagerMask.uploadBuffer();
         incrementMaskQueue.render(context, pipelineStageTagValue, 1);
         decrementMaskQueue._batch(engine._batcherManager);
+        primitiveChunkManagerMask.uploadBuffer();
         decrementMaskQueue.render(context, pipelineStageTagValue, 2);
     };
     RenderQueue.compareForOpaque = function compareForOpaque(a, b) {
@@ -10246,6 +10353,8 @@ var /**
     function BasicRenderPipeline(camera) {
         this._lastCanvasSize = new miniprogram.Vector2();
         this._internalColorTarget = null;
+        this._canUseBlitFrameBuffer = false;
+        this._shouldGrabColor = false;
         this._camera = camera;
         var engine = camera.engine;
         this._cullingResults = new CullingResults();
@@ -10270,10 +10379,19 @@ var /**
         context.rendererUpdateFlag = ContextRendererUpdateFlag.All;
         var camera = this._camera;
         var scene = camera.scene, engine = camera.engine;
+        var rhi = engine._hardwareRenderer;
         var cullingResults = this._cullingResults;
         var sunlight = scene._lightManager._sunlight;
         var depthOnlyPass = this._depthOnlyPass;
         var depthPassEnabled = camera.depthTextureMode === exports.DepthTextureMode.PrePass && depthOnlyPass._supportDepthTexture;
+        var finalClearFlags = camera.clearFlags & ~(ignoreClear != null ? ignoreClear : exports.CameraClearFlags.None);
+        var independentCanvasEnabled = camera.independentCanvasEnabled;
+        var msaaSamples = camera.renderTarget ? camera.renderTarget.antiAliasing : camera.msaaSamples;
+        this._shouldGrabColor = independentCanvasEnabled && !(finalClearFlags & exports.CameraClearFlags.Color);
+        // 1. Only support blitFramebuffer in webgl2 context
+        // 2. Can't blit normal FBO to MSAA FBO
+        // 3. Can't blit screen MSAA FBO to normal FBO in mac safari platform and mobile, but mac chrome and firfox is OK
+        this._canUseBlitFrameBuffer = rhi.isWebGL2 && msaaSamples === 1 && (!!camera.renderTarget || !rhi.context.antialias);
         if (scene.castShadows && sunlight && sunlight.shadowType !== exports.ShadowType.None) {
             this._cascadedShadowCasterPass.onRender(context);
             context.rendererUpdateFlag = ContextRendererUpdateFlag.None;
@@ -10293,24 +10411,46 @@ var /**
         } else {
             camera.shaderData.setTexture(exports.Camera._cameraDepthTextureProperty, engine._basicResources.whiteTexture2D);
         }
-        // Check if need to create internal color texture
-        var independentCanvasEnabled = camera.independentCanvasEnabled;
+        // Check if need to create internal color texture or grab texture
         if (independentCanvasEnabled) {
+            var depthFormat;
+            if (camera.renderTarget) {
+                depthFormat = camera.renderTarget._depthFormat;
+            } else if (rhi.context.depth && rhi.context.stencil) {
+                depthFormat = exports.TextureFormat.Depth24Stencil8;
+            } else if (rhi.context.depth) {
+                depthFormat = exports.TextureFormat.Depth24;
+            } else if (rhi.context.stencil) {
+                depthFormat = exports.TextureFormat.Stencil;
+            } else {
+                depthFormat = null;
+            }
             var viewport = camera.pixelViewport;
-            var internalColorTarget = PipelineUtils.recreateRenderTargetIfNeeded(engine, this._internalColorTarget, viewport.width, viewport.height, camera._getInternalColorTextureFormat(), exports.TextureFormat.Depth24Stencil8, false, false, camera.msaaSamples, exports.TextureWrapMode.Clamp, exports.TextureFilterMode.Bilinear);
+            var internalColorTarget = PipelineUtils.recreateRenderTargetIfNeeded(engine, this._internalColorTarget, viewport.width, viewport.height, camera._getInternalColorTextureFormat(), depthFormat, false, false, msaaSamples, exports.TextureWrapMode.Clamp, exports.TextureFilterMode.Bilinear);
+            if (!this._canUseBlitFrameBuffer && this._shouldGrabColor) {
+                var _camera_renderTarget;
+                var _camera_renderTarget_getColorTexture_format;
+                var grabTexture = PipelineUtils.recreateTextureIfNeeded(engine, this._grabTexture, viewport.width, viewport.height, (_camera_renderTarget_getColorTexture_format = (_camera_renderTarget = camera.renderTarget) == null ? void 0 : _camera_renderTarget.getColorTexture(0).format) != null ? _camera_renderTarget_getColorTexture_format : exports.TextureFormat.R8G8B8A8, false, exports.TextureWrapMode.Clamp, exports.TextureFilterMode.Bilinear);
+                this._grabTexture = grabTexture;
+            }
             this._internalColorTarget = internalColorTarget;
         } else {
             var internalColorTarget1 = this._internalColorTarget;
+            var grabTexture1 = this._grabTexture;
             if (internalColorTarget1) {
                 var _internalColorTarget_getColorTexture;
                 (_internalColorTarget_getColorTexture = internalColorTarget1.getColorTexture(0)) == null ? void 0 : _internalColorTarget_getColorTexture.destroy(true);
                 internalColorTarget1.destroy(true);
                 this._internalColorTarget = null;
             }
+            if (grabTexture1) {
+                grabTexture1.destroy(true);
+                this._grabTexture = null;
+            }
         }
-        this._drawRenderPass(context, camera, cubeFace, mipLevel, ignoreClear);
+        this._drawRenderPass(context, camera, finalClearFlags, cubeFace, mipLevel);
     };
-    _proto._drawRenderPass = function _drawRenderPass(context, camera, cubeFace, mipLevel, ignoreClear) {
+    _proto._drawRenderPass = function _drawRenderPass(context, camera, finalClearFlags, cubeFace, mipLevel) {
         var _cameraRenderTarget, _cameraRenderTarget1;
         var cullingResults = this._cullingResults;
         var opaqueQueue = cullingResults.opaqueQueue, alphaTestQueue = cullingResults.alphaTestQueue, transparentQueue = cullingResults.transparentQueue;
@@ -10327,14 +10467,34 @@ var /**
             context.applyVirtualCamera(camera._virtualCamera, needFlipProjection);
         }
         rhi.activeRenderTarget(colorTarget, colorViewport, context.flipProjection, mipLevel, cubeFace);
-        var clearFlags = camera.clearFlags & ~(ignoreClear != null ? ignoreClear : exports.CameraClearFlags.None);
         var color = background.solidColor;
-        if (clearFlags !== exports.CameraClearFlags.None) {
-            rhi.clearRenderTarget(camera.engine, clearFlags, color);
+        if (internalColorTarget && finalClearFlags !== exports.CameraClearFlags.All) {
+            // Can use `blitFramebuffer` API to copy color/depth/stencil buffer from back buffer to internal RT
+            if (this._canUseBlitFrameBuffer) {
+                finalClearFlags !== exports.CameraClearFlags.None && rhi.clearRenderTarget(engine, finalClearFlags, color);
+                rhi.blitInternalRTByBlitFrameBuffer(camera.renderTarget, internalColorTarget, finalClearFlags, camera.viewport);
+            } else {
+                if (!(finalClearFlags & exports.CameraClearFlags.Depth) || !(finalClearFlags & exports.CameraClearFlags.Stencil)) {
+                    Logger.warn("We clear all depth/stencil state cause of the internalRT can't copy depth/stencil buffer from back buffer when use copy plan");
+                }
+                if (this._shouldGrabColor) {
+                    rhi.clearRenderTarget(engine, exports.CameraClearFlags.DepthStencil);
+                    // Copy RT's color buffer to grab texture
+                    rhi.copyRenderTargetToSubTexture(camera.renderTarget, this._grabTexture, camera.viewport);
+                    // Then blit grab texture to internal RT's color buffer
+                    PipelineUtils.blitTexture(engine, this._grabTexture, internalColorTarget, 0, undefined, undefined, undefined, // Only flip Y axis in webgl context
+                    !camera.renderTarget);
+                } else {
+                    rhi.clearRenderTarget(engine, exports.CameraClearFlags.All, color);
+                }
+            }
+            rhi.activeRenderTarget(colorTarget, colorViewport, context.flipProjection, mipLevel, cubeFace);
+        } else if (finalClearFlags !== exports.CameraClearFlags.None) {
+            rhi.clearRenderTarget(engine, finalClearFlags, color);
         }
         opaqueQueue.render(context, exports.PipelineStage.Forward);
         alphaTestQueue.render(context, exports.PipelineStage.Forward);
-        if (clearFlags & exports.CameraClearFlags.Color) {
+        if (finalClearFlags & exports.CameraClearFlags.Color) {
             if (background.mode === exports.BackgroundMode.Sky) {
                 background.sky._render(context);
             } else if (background.mode === exports.BackgroundMode.Texture && background.texture) {
@@ -10409,8 +10569,7 @@ var /**
             var shaderPass = shaderPasses[i];
             var renderState = shaderPass._renderState;
             if (renderState) {
-                renderState._applyRenderQueueByShaderData(shaderPass._renderStateDataMap, subRenderElement.material.shaderData);
-                renderQueueType = renderState.renderQueueType;
+                renderQueueType = renderState._getRenderQueueByShaderData(shaderPass._renderStateDataMap, subRenderElement.material.shaderData);
             } else {
                 renderQueueType = renderStates[i].renderQueueType;
             }
@@ -23256,7 +23415,7 @@ __decorate([
     ParticleBufferUtils.boundsMaxLifetimeOffset = 7;
 })();
 
-var blitFs = "#define GLSLIFY 1\nuniform mediump sampler2D renderer_BlitTexture;\n#ifdef HAS_TEX_LOD\nuniform float renderer_BlitMipLevel;\n#endif\nvarying vec2 v_uv;void main(){\n#ifdef HAS_TEX_LOD\ngl_FragColor=texture2DLodEXT(renderer_BlitTexture,v_uv,renderer_BlitMipLevel);\n#else\ngl_FragColor=texture2D(renderer_BlitTexture,v_uv);\n#endif\n}"; // eslint-disable-line
+var blitFs = "#define GLSLIFY 1\nuniform mediump sampler2D renderer_BlitTexture;\n#ifdef HAS_TEX_LOD\nuniform float renderer_BlitMipLevel;\n#endif\nvarying vec2 v_uv;void main(){vec2 uv=v_uv;\n#ifdef renderer_FlipYBlitTexture\nuv.y=1.0-uv.y;\n#endif\n#ifdef HAS_TEX_LOD\ngl_FragColor=texture2DLodEXT(renderer_BlitTexture,uv,renderer_BlitMipLevel);\n#else\ngl_FragColor=texture2D(renderer_BlitTexture,uv);\n#endif\n}"; // eslint-disable-line
 
 var blitVs = "#define GLSLIFY 1\nattribute vec4 POSITION_UV;varying vec2 v_uv;void main(){gl_Position=vec4(POSITION_UV.xy,0.0,1.0);v_uv=POSITION_UV.zw;}"; // eslint-disable-line
 
@@ -29156,13 +29315,11 @@ exports.AnimatorLayerBlendingMode = void 0;
         return true;
     };
     _proto._applyTransition = function _applyTransition(layerIndex, layerData, layer, transition, aniUpdate) {
-        // Need prepare first, it should crossFade when to exit
-        var success = this._prepareCrossFadeByTransition(transition, layerIndex);
         if (transition.isExit) {
             this._checkAnyAndEntryState(layerIndex, layerData, layer, 0, aniUpdate);
-            return true;
+            return false;
         }
-        return success;
+        return this._prepareCrossFadeByTransition(transition, layerIndex);
     };
     _proto._checkConditions = function _checkConditions(state, transition) {
         var _state;
@@ -34559,6 +34716,74 @@ var cacheDir = new miniprogram.Vector3();
     return CubeProbe;
 }(Probe);
 
+/**
+ * @internal
+ */ var Polyfill = /*#__PURE__*/ function() {
+    function Polyfill() {}
+    Polyfill.registerPolyfill = function registerPolyfill() {
+        Polyfill._registerMatchAll();
+    };
+    Polyfill._registerMatchAll = function _registerMatchAll() {
+        if (!String.prototype.matchAll) {
+            Logger.info("polyfill String.prototype.matchAll");
+            String.prototype.matchAll = function(pattern) {
+                var flags = pattern.flags;
+                var globalFlagIdx = flags.indexOf("g");
+                if (globalFlagIdx === -1) {
+                    throw TypeError("String.prototype.matchAll called with a non-global RegExp argument");
+                }
+                var bindThis = this;
+                return function() {
+                    var matchResult, matchFlag, matchPattern, _tmp, _tmp1, _i, index, item;
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                matchResult = bindThis.match(pattern);
+                                if (matchResult == null) return [
+                                    2,
+                                    null
+                                ];
+                                matchFlag = flags.split("g").join("");
+                                matchPattern = new RegExp(pattern.source, matchFlag);
+                                _tmp = [];
+                                for(_tmp1 in matchResult)_tmp.push(_tmp1);
+                                _i = 0;
+                                _state.label = 1;
+                            case 1:
+                                if (!(_i < _tmp.length)) return [
+                                    3,
+                                    4
+                                ];
+                                index = _tmp[_i];
+                                item = matchResult[index];
+                                return [
+                                    4,
+                                    item.match(matchPattern)
+                                ];
+                            case 2:
+                                _state.sent();
+                                _state.label = 3;
+                            case 3:
+                                _i++;
+                                return [
+                                    3,
+                                    1
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }();
+            };
+        }
+    };
+    return Polyfill;
+}();
+
+Polyfill.registerPolyfill();
+
 exports.AmbientLight = AmbientLight;
 exports.AnimationClip = AnimationClip;
 exports.AnimationClipCurveBinding = AnimationClipCurveBinding;