@galacean/engine-core 0.0.0-experimental-2.0-game.14 → 0.0.0-experimental-2.0-game.16

package/dist/main.js

@@ -353,10 +353,14 @@ function _instanceof(left, right) {
         if (_instanceof(sourceProperty, Map) || _instanceof(sourceProperty, Set)) return CloneMode.Deep;
         // Value types with copyFrom (math types like Vector3, Color, etc.)
         if (sourceProperty.copyFrom) return CloneMode.Deep;
-        // Plain objects - deep clone (may contain Entity/Component refs)
-        if (sourceProperty.constructor === Object) return CloneMode.Deep;
-        // Other class instances (engine resources like Material, Texture) - shared reference
-        return CloneMode.Assignment;
+        // Engine resources (Material, Texture, Mesh, Shader, ...) — refCount-managed,
+        // shared by reference. Anything outside this contract is treated as a value-like
+        // user class and gets a deep clone (so nested Entity/Component refs are remapped).
+        if (_instanceof(sourceProperty, ReferResource)) return CloneMode.Assignment;
+        // Default: deep clone. Covers plain objects {...} and user-defined value classes
+        // (EventHandler, business data containers). Internal Entity/Component refs reach
+        // line 109's _remap branch and are correctly rebound to the target tree.
+        return CloneMode.Deep;
     };
     CloneManager.deepCloneObject = function deepCloneObject(source, target, deepInstanceMap) {
         for(var k in source){
@@ -4564,6 +4568,18 @@ var RenderElement = /*#__PURE__*/ function() {
         this.subChunk = subChunk;
         this.instancedRenderers.length = 0;
     };
+    /**
+   * @internal
+   * Copy identity fields from `source` and reset per-queue batch state, so the same
+   * logical element can live in multiple queues (e.g. an Opaque + Transparent multi-pass
+   * material) without one queue's batching corrupting another's `instancedRenderers`.
+   */ _proto._cloneFrom = function _cloneFrom(source) {
+        this.set(source.component, source.material, source.primitive, source.subPrimitive, source.texture, source.subChunk);
+        this.priority = source.priority;
+        this.distanceForSort = source.distanceForSort;
+        this.subShader = source.subShader;
+        this.shaderData = source.shaderData;
+    };
     _proto.dispose = function dispose() {
         this.component = null;
         this.material = null;
@@ -5564,7 +5580,7 @@ function dependentComponents(componentOrComponents, dependentMode) {
     _inherits(Transform, Component);
     function Transform(entity) {
         var _this;
-        _this = Component.call(this, entity) || this, _this._position = new engineMath.Vector3(), _this._rotation = new engineMath.Vector3(), _this._rotationQuaternion = new engineMath.Quaternion(), _this._scale = new engineMath.Vector3(1, 1, 1), _this._localUniformScaling = true, _this._worldPosition = new engineMath.Vector3(), _this._worldRotation = new engineMath.Vector3(), _this._worldRotationQuaternion = new engineMath.Quaternion(), _this._worldUniformScaling = true, _this._lossyWorldScale = new engineMath.Vector3(1, 1, 1), _this._localMatrix = new engineMath.Matrix(), _this._worldMatrix = new engineMath.Matrix(), _this._worldForward = null, _this._worldRight = null, _this._worldUp = null, _this._isParentDirty = true, _this._parentTransformCache = null, _this._dirtyFlag = 510;
+        _this = Component.call(this, entity) || this, _this._position = new engineMath.Vector3(), _this._rotation = new engineMath.Vector3(), _this._rotationQuaternion = new engineMath.Quaternion(), _this._scale = new engineMath.Vector3(1, 1, 1), _this._localUniformScaling = true, _this._worldPosition = new engineMath.Vector3(), _this._worldRotation = new engineMath.Vector3(), _this._worldRotationQuaternion = new engineMath.Quaternion(), _this._worldUniformScaling = true, _this._lossyWorldScale = new engineMath.Vector3(1, 1, 1), _this._localMatrix = new engineMath.Matrix(), _this._worldMatrix = new engineMath.Matrix(), _this._worldForward = null, _this._worldRight = null, _this._worldUp = null, _this._frontFaceInvert = false, _this._isParentDirty = true, _this._parentTransformCache = null, _this._dirtyFlag = 2558;
         _this._onPositionChanged = _this._onPositionChanged.bind(_this);
         _this._onWorldPositionChanged = _this._onWorldPositionChanged.bind(_this);
         _this._onRotationChanged = _this._onRotationChanged.bind(_this);
@@ -5722,7 +5738,7 @@ function dependentComponents(componentOrComponents, dependentMode) {
         //    `_getParentTransform` was ever called while their ancestor chain was
         //    partially constructed during clone/instantiate). Force them to
         //    re-resolve the parent transform on next access.
-        this._propagateReparentDirty(444);
+        this._propagateReparentDirty(2492);
     };
     _proto._propagateReparentDirty = function _propagateReparentDirty(flags) {
         this._worldAssociatedChange(flags);
@@ -5738,11 +5754,16 @@ function dependentComponents(componentOrComponents, dependentMode) {
     /**
    * @internal
    */ _proto._isFrontFaceInvert = function _isFrontFaceInvert() {
-        var scale = this.lossyWorldScale;
-        var isInvert = scale.x < 0;
-        scale.y < 0 && (isInvert = !isInvert);
-        scale.z < 0 && (isInvert = !isInvert);
-        return isInvert;
+        if (this._isContainDirtyFlag(2048)) {
+            var s = this._scale;
+            var invert = s.x < 0;
+            s.y < 0 && (invert = !invert);
+            s.z < 0 && (invert = !invert);
+            var parent = this._getParentTransform();
+            this._frontFaceInvert = parent ? invert !== parent._isFrontFaceInvert() : invert;
+            this._setDirtyFlagFalse(2048);
+        }
+        return this._frontFaceInvert;
     };
     /**
    * @internal
@@ -5765,7 +5786,7 @@ function dependentComponents(componentOrComponents, dependentMode) {
         // the computed value. After this _cloneTo writes new local values, those world-derived caches are stale,
         // so re-dirty them and notify listeners (Collider._updateFlag etc.) so subsequent reads recompute correctly.
         target._setDirtyFlagTrue(2 | 64);
-        target._worldAssociatedChange(444);
+        target._worldAssociatedChange(2492);
     };
     _proto._onLocalMatrixChanging = function _onLocalMatrixChanging() {
         this._setDirtyFlagFalse(64);
@@ -5848,10 +5869,10 @@ function dependentComponents(componentOrComponents, dependentMode) {
    */ _proto._updateWorldRotationFlag = function _updateWorldRotationFlag() {
         var parent = this._getParentTransform();
         var parentWorldUniformScaling = parent ? parent._getWorldUniformScaling() : true;
-        var flags = parentWorldUniformScaling ? 152 : 184;
+        var flags = parentWorldUniformScaling ? 152 : 2232;
         if (!this._isContainDirtyFlags(flags)) {
             this._worldAssociatedChange(flags);
-            flags = this._getWorldUniformScaling() ? 156 : 188;
+            flags = this._getWorldUniformScaling() ? 156 : 2236;
             var children = this._entity._children;
             for(var i = 0, n = children.length; i < n; i++){
                 var _children_i_transform;
@@ -5870,7 +5891,7 @@ function dependentComponents(componentOrComponents, dependentMode) {
    */ _proto._updateWorldPositionAndRotationFlag = function _updateWorldPositionAndRotationFlag(flags) {
         if (!this._isContainDirtyFlags(flags)) {
             this._worldAssociatedChange(flags);
-            flags = this._getWorldUniformScaling() ? 156 : 188;
+            flags = this._getWorldUniformScaling() ? 156 : 2236;
             var children = this._entity._children;
             for(var i = 0, n = children.length; i < n; i++){
                 var _children_i_transform;
@@ -5992,9 +6013,9 @@ function dependentComponents(componentOrComponents, dependentMode) {
         var localUniformScaling = x == y && y == z;
         if (this._localUniformScaling !== localUniformScaling) {
             this._localUniformScaling = localUniformScaling;
-            this._updateWorldScaleFlag(416);
+            this._updateWorldScaleFlag(2464);
         } else {
-            this._updateWorldScaleFlag(160);
+            this._updateWorldScaleFlag(2208);
         }
     };
     _proto._getWorldUniformScaling = function _getWorldUniformScaling() {
@@ -6232,9 +6253,9 @@ function dependentComponents(componentOrComponents, dependentMode) {
                 var localUniformScaling = scale.x === scale.y && scale.y === scale.z;
                 if (this._localUniformScaling !== localUniformScaling) {
                     this._localUniformScaling = localUniformScaling;
-                    this._updateAllWorldFlag(444);
+                    this._updateAllWorldFlag(2492);
                 } else {
-                    this._updateAllWorldFlag(188);
+                    this._updateAllWorldFlag(2236);
                 }
             }
         },
@@ -6360,6 +6381,9 @@ __decorate([
 __decorate([
     ignoreClone
 ], Transform.prototype, "_worldUp", void 0);
+__decorate([
+    ignoreClone
+], Transform.prototype, "_frontFaceInvert", void 0);
 __decorate([
     ignoreClone
 ], Transform.prototype, "_isParentDirty", void 0);
@@ -6401,16 +6425,18 @@ __decorate([
     /** This is an internal flag used to assist in determining the dispatch
    *  of world scaling dirty flags in the case of non-uniform scaling.
    */ TransformModifyFlags[TransformModifyFlags["IsWorldUniformScaling"] = 256] = "IsWorldUniformScaling";
+    // Note: 0x200 (UITransformModifyFlags.Size) and 0x400 (Pivot) are reserved by UITransform — do not reuse.
+    TransformModifyFlags[TransformModifyFlags["WorldFrontFaceInvert"] = 2048] = "WorldFrontFaceInvert";
     /** WorldMatrix | WorldPosition */ TransformModifyFlags[TransformModifyFlags["WmWp"] = 132] = "WmWp";
     /** WorldMatrix | WorldEuler | WorldQuat */ TransformModifyFlags[TransformModifyFlags["WmWeWq"] = 152] = "WmWeWq";
-    /** WorldMatrix | WorldEuler | WorldQuat | WorldScale*/ TransformModifyFlags[TransformModifyFlags["WmWeWqWs"] = 184] = "WmWeWqWs";
+    /** WorldMatrix | WorldEuler | WorldQuat | WorldScale | WorldFrontFaceInvert */ TransformModifyFlags[TransformModifyFlags["WmWeWqWs"] = 2232] = "WmWeWqWs";
     /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat */ TransformModifyFlags[TransformModifyFlags["WmWpWeWq"] = 156] = "WmWpWeWq";
-    /** WorldMatrix | WorldScale */ TransformModifyFlags[TransformModifyFlags["WmWs"] = 160] = "WmWs";
-    /** WorldMatrix | WorldScale | WorldUniformScaling */ TransformModifyFlags[TransformModifyFlags["WmWsWus"] = 416] = "WmWsWus";
-    /** WorldMatrix | WorldPosition | WorldScale */ TransformModifyFlags[TransformModifyFlags["WmWpWs"] = 164] = "WmWpWs";
-    /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale */ TransformModifyFlags[TransformModifyFlags["WmWpWeWqWs"] = 188] = "WmWpWeWqWs";
-    /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling */ TransformModifyFlags[TransformModifyFlags["WmWpWeWqWsWus"] = 444] = "WmWpWeWqWsWus";
-    /** LocalQuat | LocalMatrix | WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling */ TransformModifyFlags[TransformModifyFlags["LqLmWmWpWeWqWsWus"] = 510] = "LqLmWmWpWeWqWsWus";
+    /** WorldMatrix | WorldScale | WorldFrontFaceInvert */ TransformModifyFlags[TransformModifyFlags["WmWs"] = 2208] = "WmWs";
+    /** WorldMatrix | WorldScale | WorldUniformScaling | WorldFrontFaceInvert */ TransformModifyFlags[TransformModifyFlags["WmWsWus"] = 2464] = "WmWsWus";
+    /** WorldMatrix | WorldPosition | WorldScale | WorldFrontFaceInvert */ TransformModifyFlags[TransformModifyFlags["WmWpWs"] = 2212] = "WmWpWs";
+    /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldFrontFaceInvert */ TransformModifyFlags[TransformModifyFlags["WmWpWeWqWs"] = 2236] = "WmWpWeWqWs";
+    /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling | WorldFrontFaceInvert */ TransformModifyFlags[TransformModifyFlags["WmWpWeWqWsWus"] = 2492] = "WmWpWeWqWsWus";
+    /** LocalQuat | LocalMatrix | WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling | WorldFrontFaceInvert */ TransformModifyFlags[TransformModifyFlags["LqLmWmWpWeWqWsWus"] = 2558] = "LqLmWmWpWeWqWsWus";
     return TransformModifyFlags;
 }({});
 
@@ -6460,6 +6486,12 @@ __decorate([
     function ShaderData(group) {
         /** @internal */ this._propertyValueMap = Object.create(null);
         /** @internal */ this._macroCollection = new ShaderMacroCollection();
+        /**
+   * @internal
+   * Sorted (ascending) property ids of renderer-group samplers and arrays. These values
+   * can't differ across instances inside an instanced draw call — `_canBatch` uses this
+   * list to refuse batching renderers that would disagree on what to bind
+   */ this._instanceBatchFields = [];
         this._macroMap = Object.create(null);
         this._refCount = 0;
         this._group = group;
@@ -6678,7 +6710,52 @@ __decorate([
                 throw "Shader property " + property.name + " has been used as " + ShaderPropertyType[property._type] + " type.";
             }
         }
-        this._propertyValueMap[property._uniqueId] = value;
+        var id = property._uniqueId;
+        // Track renderer-group samplers/arrays so `_canBatch` can refuse instanced batches
+        // whose leader and follower would disagree on what to bind
+        if (this._group === ShaderDataGroup.Renderer && (type === ShaderPropertyType.Texture || type === ShaderPropertyType.TextureArray || type === ShaderPropertyType.FloatArray || type === ShaderPropertyType.IntArray)) {
+            var oldHas = this._propertyValueMap[id] != null;
+            var newHas = value != null;
+            if (oldHas !== newHas) {
+                var fields = this._instanceBatchFields;
+                if (newHas) {
+                    // Insert keeping ascending order so exact compare is index-by-index
+                    var lo = 0;
+                    var hi = fields.length;
+                    while(lo < hi){
+                        var mid = lo + hi >>> 1;
+                        if (fields[mid] < id) {
+                            lo = mid + 1;
+                        } else {
+                            hi = mid;
+                        }
+                    }
+                    fields.splice(lo, 0, id);
+                } else {
+                    fields.splice(fields.indexOf(id), 1);
+                }
+            }
+        }
+        this._propertyValueMap[id] = value;
+    };
+    /**
+   * @internal
+   */ _proto._matchesRendererInstanceBatch = function _matchesRendererInstanceBatch(other) {
+        var selfFields = this._instanceBatchFields;
+        var otherFields = other._instanceBatchFields;
+        var fieldCount = selfFields.length;
+        if (fieldCount !== otherFields.length) {
+            return false;
+        }
+        var selfMap = this._propertyValueMap;
+        var otherMap = other._propertyValueMap;
+        for(var i = 0; i < fieldCount; i++){
+            var id = selfFields[i];
+            if (id !== otherFields[i] || selfMap[id] !== otherMap[id]) {
+                return false;
+            }
+        }
+        return true;
     };
     /**
    * @internal
@@ -6709,6 +6786,9 @@ __decorate([
 __decorate([
     ignoreClone
 ], ShaderData.prototype, "_macroCollection", void 0);
+__decorate([
+    ignoreClone
+], ShaderData.prototype, "_instanceBatchFields", void 0);
 __decorate([
     ignoreClone
 ], ShaderData.prototype, "_macroMap", void 0);
@@ -14401,7 +14481,9 @@ var BlendShapeFrameDirty = /*#__PURE__*/ function(BlendShapeFrameDirty) {
    * @internal
    */ _proto._canBatch = function _canBatch(preElement, curElement) {
         if (!this._engine._hardwareRenderer.isWebGL2) return false;
-        return preElement.primitive === curElement.primitive && preElement.subPrimitive === curElement.subPrimitive && preElement.material === curElement.material && this._isFrontFaceInvert() === curElement.component._isFrontFaceInvert() && this.shaderData._macroCollection.isEqual(curElement.component.shaderData._macroCollection);
+        var curShaderData = curElement.component.shaderData;
+        return preElement.primitive === curElement.primitive && preElement.subPrimitive === curElement.subPrimitive && preElement.material === curElement.material && this._isFrontFaceInvert() === curElement.component._isFrontFaceInvert() && this.shaderData._macroCollection.isEqual(curShaderData._macroCollection) && // Renderer-group samplers/arrays are shared across the whole instanced draw call
+        this.shaderData._matchesRendererInstanceBatch(curShaderData);
     };
     /**
    * @internal
@@ -18975,8 +19057,11 @@ RenderContext._flipYViewProjectionMatrix = new engineMath.Matrix();
  * @internal
  */ var RenderTargetPool = /*#__PURE__*/ function() {
     function RenderTargetPool(engine) {
+        /** Frames an entry may sit idle before `tick()` destroys it. */ this.maxFreeAgeFrames = 60;
         this._freeRenderTargets = [];
+        this._freeRenderTargetFrames = [];
         this._freeTextures = [];
+        this._freeTextureFrames = [];
         this._engine = engine;
     }
     var _proto = RenderTargetPool.prototype;
@@ -18985,8 +19070,7 @@ RenderContext._flipYViewProjectionMatrix = new engineMath.Matrix();
         for(var i = freeRenderTargets.length - 1; i >= 0; i--){
             var renderTarget = freeRenderTargets[i];
             if (RenderTargetPool._matchRenderTarget(renderTarget, width, height, colorFormat, depthFormat, needDepthTexture, mipmap, isSRGBColorSpace, antiAliasing)) {
-                freeRenderTargets[i] = freeRenderTargets[freeRenderTargets.length - 1];
-                freeRenderTargets.length--;
+                this._removeFreeRenderTargetAt(i);
                 var colorTexture = renderTarget.getColorTexture(0);
                 if (colorTexture) {
                     colorTexture.wrapModeU = colorTexture.wrapModeV = wrapMode;
@@ -19029,8 +19113,7 @@ RenderContext._flipYViewProjectionMatrix = new engineMath.Matrix();
         for(var i = freeTextures.length - 1; i >= 0; i--){
             var texture = freeTextures[i];
             if (texture.width === width && texture.height === height && texture.format === format && texture.mipmapCount > 1 === mipmap && texture.isSRGBColorSpace === isSRGBColorSpace) {
-                freeTextures[i] = freeTextures[freeTextures.length - 1];
-                freeTextures.length--;
+                this._removeFreeTextureAt(i);
                 texture.wrapModeU = texture.wrapModeV = wrapMode;
                 texture.filterMode = filterMode;
                 return texture;
@@ -19045,29 +19128,98 @@ RenderContext._flipYViewProjectionMatrix = new engineMath.Matrix();
     _proto.freeRenderTarget = function freeRenderTarget(renderTarget) {
         if (!renderTarget || renderTarget.destroyed) return;
         this._freeRenderTargets.push(renderTarget);
+        this._freeRenderTargetFrames.push(this._engine.time.frameCount);
     };
     _proto.freeTexture = function freeTexture(texture) {
         if (!texture || texture.destroyed) return;
         this._freeTextures.push(texture);
+        this._freeTextureFrames.push(this._engine.time.frameCount);
+    };
+    _proto.tick = function tick(currentFrame) {
+        var maxAge = this.maxFreeAgeFrames;
+        var rtFrames = this._freeRenderTargetFrames;
+        for(var i = rtFrames.length - 1; i >= 0; i--){
+            if (currentFrame - rtFrames[i] > maxAge) {
+                this._destroyFreeRenderTargetAt(i);
+            }
+        }
+        var texFrames = this._freeTextureFrames;
+        for(var i1 = texFrames.length - 1; i1 >= 0; i1--){
+            if (currentFrame - texFrames[i1] > maxAge) {
+                this._destroyFreeTextureAt(i1);
+            }
+        }
+    };
+    _proto.evictBySize = function evictBySize(width, height) {
+        var freeRenderTargets = this._freeRenderTargets;
+        for(var i = freeRenderTargets.length - 1; i >= 0; i--){
+            var rt = freeRenderTargets[i];
+            if (rt.width === width && rt.height === height) {
+                this._destroyFreeRenderTargetAt(i);
+            }
+        }
+        var freeTextures = this._freeTextures;
+        for(var i1 = freeTextures.length - 1; i1 >= 0; i1--){
+            var tex = freeTextures[i1];
+            if (tex.width === width && tex.height === height) {
+                this._destroyFreeTextureAt(i1);
+            }
+        }
     };
     _proto.gc = function gc() {
         var freeRenderTargets = this._freeRenderTargets;
         for(var i = 0, n = freeRenderTargets.length; i < n; i++){
-            var renderTarget = freeRenderTargets[i];
-            var colorTexture = renderTarget.getColorTexture(0);
-            var depthTexture = renderTarget.depthTexture;
-            renderTarget.destroy(true);
-            colorTexture == null ? void 0 : colorTexture.destroy(true);
-            if (depthTexture && depthTexture !== colorTexture) {
-                depthTexture.destroy(true);
-            }
+            RenderTargetPool._destroyRenderTargetResource(freeRenderTargets[i]);
         }
         freeRenderTargets.length = 0;
+        this._freeRenderTargetFrames.length = 0;
         var freeTextures = this._freeTextures;
         for(var i1 = 0, n1 = freeTextures.length; i1 < n1; i1++){
             freeTextures[i1].destroy(true);
         }
         freeTextures.length = 0;
+        this._freeTextureFrames.length = 0;
+    };
+    _proto._removeFreeRenderTargetAt = function _removeFreeRenderTargetAt(index) {
+        var rts = this._freeRenderTargets;
+        var frames = this._freeRenderTargetFrames;
+        var last = rts.length - 1;
+        if (index !== last) {
+            rts[index] = rts[last];
+            frames[index] = frames[last];
+        }
+        rts.length = last;
+        frames.length = last;
+    };
+    _proto._removeFreeTextureAt = function _removeFreeTextureAt(index) {
+        var texs = this._freeTextures;
+        var frames = this._freeTextureFrames;
+        var last = texs.length - 1;
+        if (index !== last) {
+            texs[index] = texs[last];
+            frames[index] = frames[last];
+        }
+        texs.length = last;
+        frames.length = last;
+    };
+    _proto._destroyFreeRenderTargetAt = function _destroyFreeRenderTargetAt(index) {
+        var rt = this._freeRenderTargets[index];
+        this._removeFreeRenderTargetAt(index);
+        RenderTargetPool._destroyRenderTargetResource(rt);
+    };
+    _proto._destroyFreeTextureAt = function _destroyFreeTextureAt(index) {
+        var tex = this._freeTextures[index];
+        this._removeFreeTextureAt(index);
+        tex.destroy(true);
+    };
+    RenderTargetPool._destroyRenderTargetResource = function _destroyRenderTargetResource(rt) {
+        var colorTexture = rt.getColorTexture(0);
+        var depthTexture = rt.depthTexture;
+        rt.destroy(true);
+        colorTexture == null ? void 0 : colorTexture.destroy(true);
+        if (depthTexture && depthTexture !== colorTexture) {
+            depthTexture.destroy(true);
+        }
     };
     RenderTargetPool._matchRenderTarget = function _matchRenderTarget(renderTarget, width, height, colorFormat, depthFormat, needDepthTexture, mipmap, isSRGBColorSpace, antiAliasing) {
         if (renderTarget.width !== width || renderTarget.height !== height || renderTarget.antiAliasing !== antiAliasing) {
@@ -27180,17 +27332,15 @@ Shader.create("FinalAntiAliasing", BlitVS, FinalAntiAliasingFS);
                 }
                 var switchProgram = program.bind();
                 var switchRenderCount = renderCount !== program._uploadRenderCount;
-                // Upload uniforms (cache-aware per block)
+                // Upload uniforms (cache-aware per block). Renderer block carries plain samplers/arrays
+                // even on the instanced path (GLSL forbids them in UBOs); `_canBatch` ensures the whole
+                // batch agrees on those, so the leader's values are correct for the draw call
                 if (switchRenderCount) {
                     program.groupingOtherUniformBlock();
                     program.uploadAll(program.sceneUniformBlock, sceneData);
                     program.uploadAll(program.cameraUniformBlock, cameraData);
-                    if (isInstanced) {
-                        program._uploadRendererId = -1;
-                    } else {
-                        program.uploadAll(program.rendererUniformBlock, rendererData);
-                        program._uploadRendererId = rendererId;
-                    }
+                    program.uploadAll(program.rendererUniformBlock, rendererData);
+                    program._uploadRendererId = isInstanced ? -1 : rendererId;
                     program.uploadAll(program.materialUniformBlock, materialData);
                     renderElementShaderData && program.uploadAll(program.renderElementUniformBlock, renderElementShaderData);
                     // UnGroup textures should upload default value, texture uint maybe change by logic of texture bind
@@ -27212,13 +27362,15 @@ Shader.create("FinalAntiAliasing", BlitVS, FinalAntiAliasingFS);
                     } else if (switchProgram) {
                         program.uploadTextures(program.cameraUniformBlock, cameraData);
                     }
-                    if (!isInstanced) {
-                        if (program._uploadRendererId !== rendererId) {
-                            program.uploadAll(program.rendererUniformBlock, rendererData);
-                            program._uploadRendererId = rendererId;
-                        } else if (switchProgram) {
-                            program.uploadTextures(program.rendererUniformBlock, rendererData);
-                        }
+                    if (isInstanced) {
+                        // Different batches may have different leaders, re-upload every time
+                        program.uploadAll(program.rendererUniformBlock, rendererData);
+                        program._uploadRendererId = -1;
+                    } else if (program._uploadRendererId !== rendererId) {
+                        program.uploadAll(program.rendererUniformBlock, rendererData);
+                        program._uploadRendererId = rendererId;
+                    } else if (switchProgram) {
+                        program.uploadTextures(program.rendererUniformBlock, rendererData);
                     }
                     if (program._uploadMaterialId !== materialId) {
                         program.uploadAll(program.materialUniformBlock, materialData);
@@ -28237,19 +28389,8 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
                 this._copyBackgroundTexture = copyBackgroundTexture;
             }
             this._internalColorTarget = internalColorTarget;
-        } else {
-            var internalColorTarget1 = this._internalColorTarget;
-            var copyBackgroundTexture1 = this._copyBackgroundTexture;
-            var pool = engine._renderTargetPool;
-            if (internalColorTarget1) {
-                pool.freeRenderTarget(internalColorTarget1);
-                this._internalColorTarget = null;
-            }
-            if (copyBackgroundTexture1) {
-                pool.freeTexture(copyBackgroundTexture1);
-                this._copyBackgroundTexture = null;
-            }
         }
+        // Both fields are released at the end of `_drawRenderPass`, so they're null on every entry here.
         // Scalable ambient obscurance pass
         // Before opaque pass so materials can sample ambient occlusion in BRDF
         var saoPass = this._saoPass;
@@ -28366,6 +28507,16 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
         }
         cameraRenderTarget == null ? void 0 : cameraRenderTarget._blitRenderTarget();
         cameraRenderTarget == null ? void 0 : cameraRenderTarget.generateMipmaps();
+        // Release per-frame leases so the next camera with matching shape can reuse them.
+        var pool = engine._renderTargetPool;
+        if (this._internalColorTarget) {
+            pool.freeRenderTarget(this._internalColorTarget);
+            this._internalColorTarget = null;
+        }
+        if (this._copyBackgroundTexture) {
+            pool.freeTexture(this._copyBackgroundTexture);
+            this._copyBackgroundTexture = null;
+        }
     };
     /**
    * Push render data to render queue.
@@ -28401,6 +28552,7 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
     _proto._pushRenderElementByType = function _pushRenderElementByType(renderElement, subShader, renderStates) {
         var shaderPasses = subShader.passes;
         var cullingResults = this._cullingResults;
+        renderElement.subShader = subShader;
         var pushedQueueFlags = 0;
         for(var i = 0, n = shaderPasses.length; i < n; i++){
             var renderQueueType = void 0;
@@ -28412,19 +28564,28 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
                 renderQueueType = renderStates[i].renderQueueType;
             }
             var flag = 1 << renderQueueType;
-            renderElement.subShader = subShader;
             if (pushedQueueFlags & flag) {
                 continue;
             }
+            // First queue keeps the original element; subsequent queues each get an isolated
+            // clone so per-queue batch state (`_isBatched`, `instancedRenderers`) doesn't
+            // leak across queues for multi-pass materials (e.g. Opaque + Transparent)
+            var elementForQueue = void 0;
+            if (pushedQueueFlags === 0) {
+                elementForQueue = renderElement;
+            } else {
+                elementForQueue = renderElement.component.engine._renderElementPool.get();
+                elementForQueue._cloneFrom(renderElement);
+            }
             switch(renderQueueType){
                 case RenderQueueType.Opaque:
-                    cullingResults.opaqueQueue.pushRenderElement(renderElement);
+                    cullingResults.opaqueQueue.pushRenderElement(elementForQueue);
                     break;
                 case RenderQueueType.AlphaTest:
-                    cullingResults.alphaTestQueue.pushRenderElement(renderElement);
+                    cullingResults.alphaTestQueue.pushRenderElement(elementForQueue);
                     break;
                 case RenderQueueType.Transparent:
-                    cullingResults.transparentQueue.pushRenderElement(renderElement);
+                    cullingResults.transparentQueue.pushRenderElement(elementForQueue);
                     break;
             }
             pushedQueueFlags |= flag;
@@ -28640,7 +28801,18 @@ ShaderPool.init();
     _inherits(Engine, EventDispatcher);
     function Engine(canvas, hardwareRenderer, configuration) {
         var _this;
-        _this = EventDispatcher.call(this) || this, /** @internal */ _this._renderingStatistics = new RenderingStatistics(), /** @internal */ _this._isDeviceLost = false, /** @internal */ _this._frameInProcess = false, /** @internal */ _this._pendingDestroyObjects = [], /** @internal */ _this._processingPendingDestroys = false, /** @internal */ _this._physicsInitialized = false, /* @internal */ _this._lastRenderState = new RenderState(), /* @internal */ _this._renderElementPool = new ClearableObjectPool(RenderElement), /* @internal */ _this._textRenderElementPool = new ClearableObjectPool(RenderElement), /* @internal */ _this._charRenderInfoPool = new ReturnableObjectPool(CharRenderInfo, 50), /* @internal */ _this._renderContext = new RenderContext(), /* @internal */ _this._renderCount = 0, /* @internal */ _this._shaderProgramMaps = [], /** @internal */ _this._fontMap = {}, /** @internal */ _this._macroCollection = new ShaderMacroCollection(), /** @internal */ _this._postProcessPassNeedRefresh = false, _this._settings = {}, _this._resourceManager = new ResourceManager(_this), _this._sceneManager = new SceneManager(_this), _this._vSyncCount = 1, _this._targetFrameRate = 60, _this._time = new Time(), _this._isPaused = true, _this._vSyncCounter = 1, _this._targetFrameInterval = 1000 / 60, _this._destroyed = false, _this._waitingDestroy = false, _this._waitingGC = false, _this._postProcessPasses = new Array(), _this._activePostProcessPasses = new Array(), _this._animate = function() {
+        _this = EventDispatcher.call(this) || this, /** @internal */ _this._renderingStatistics = new RenderingStatistics(), /** @internal */ _this._isDeviceLost = false, /** @internal */ _this._frameInProcess = false, /** @internal */ _this._pendingDestroyObjects = [], /** @internal */ _this._processingPendingDestroys = false, /** @internal */ _this._physicsInitialized = false, /* @internal */ _this._lastRenderState = new RenderState(), /* @internal */ _this._renderElementPool = new ClearableObjectPool(RenderElement), /* @internal */ _this._textRenderElementPool = new ClearableObjectPool(RenderElement), /* @internal */ _this._charRenderInfoPool = new ReturnableObjectPool(CharRenderInfo, 50), /* @internal */ _this._renderContext = new RenderContext(), /* @internal */ _this._renderCount = 0, /* @internal */ _this._shaderProgramMaps = [], /** @internal */ _this._fontMap = {}, /** @internal */ _this._macroCollection = new ShaderMacroCollection(), /** @internal */ _this._postProcessPassNeedRefresh = false, _this._settings = {}, _this._resourceManager = new ResourceManager(_this), _this._sceneManager = new SceneManager(_this), _this._vSyncCount = 1, _this._targetFrameRate = 60, _this._time = new Time(), _this._isPaused = true, _this._vSyncCounter = 1, _this._targetFrameInterval = 1000 / 60, _this._destroyed = false, _this._waitingDestroy = false, _this._waitingGC = false, _this._postProcessPasses = new Array(), _this._activePostProcessPasses = new Array(), _this._lastCanvasWidth = -1, _this._lastCanvasHeight = -1, /** Evict pool entries sized to the previous canvas dimensions. */ _this._onCanvasResize = function() {
+            var _$canvas = _this._canvas;
+            var newWidth = _$canvas.width;
+            var newHeight = _$canvas.height;
+            if (_this._lastCanvasWidth !== newWidth || _this._lastCanvasHeight !== newHeight) {
+                if (_this._lastCanvasWidth >= 0) {
+                    _this._renderTargetPool.evictBySize(_this._lastCanvasWidth, _this._lastCanvasHeight);
+                }
+                _this._lastCanvasWidth = newWidth;
+                _this._lastCanvasHeight = newHeight;
+            }
+        }, _this._animate = function() {
             if (_this._vSyncCount) {
                 var _this_xrManager;
                 var raf = ((_this_xrManager = _this.xrManager) == null ? void 0 : _this_xrManager._getRequestAnimationFrame()) || requestAnimationFrame;
@@ -28661,6 +28833,9 @@ ShaderPool.init();
         _this._textDefaultFont.isGCIgnored = true;
         _this._batcherManager = new BatcherManager(_this);
         _this._renderTargetPool = new RenderTargetPool(_this);
+        _this._lastCanvasWidth = canvas.width;
+        _this._lastCanvasHeight = canvas.height;
+        canvas._sizeUpdateFlagManager.addListener(_this._onCanvasResize);
         _this.inputManager = new InputManager(_this, configuration.input);
         var xrDevice = configuration.xrDevice;
         if (xrDevice) {
@@ -28720,6 +28895,7 @@ ShaderPool.init();
         var _this_xrManager;
         var time = this._time;
         time._update();
+        this._renderTargetPool.tick(time.frameCount);
         var deltaTime = time.deltaTime;
         this._frameInProcess = true;
         this._renderElementPool.clear();
@@ -28864,6 +29040,7 @@ ShaderPool.init();
         var _this_xrManager;
         this._destroyed = true;
         this._waitingDestroy = false;
+        this._canvas._sizeUpdateFlagManager.removeListener(this._onCanvasResize);
         this._sceneManager._destroyAllScene();
         this._resourceManager._destroy();
         this.inputManager._destroy();
@@ -31681,7 +31858,7 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
  */ var AnimationClipCurveBinding = /*#__PURE__*/ function() {
     function AnimationClipCurveBinding() {
         /** The index of the component that is animated. */ this.typeIndex = 0;
-        this._tempCurveOwner = {};
+        this._tempCurveOwner = new WeakMap();
     }
     var _proto = AnimationClipCurveBinding.prototype;
     /**
@@ -31707,11 +31884,12 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
     /**
    * @internal
    */ _proto._getTempCurveOwner = function _getTempCurveOwner(entity, component) {
-        var instanceId = entity.instanceId;
-        if (!this._tempCurveOwner[instanceId]) {
-            this._tempCurveOwner[instanceId] = this._createCurveOwner(entity, component);
+        var owner = this._tempCurveOwner.get(entity);
+        if (!owner) {
+            owner = this._createCurveOwner(entity, component);
+            this._tempCurveOwner.set(entity, owner);
         }
-        return this._tempCurveOwner[instanceId];
+        return owner;
     };
     return AnimationClipCurveBinding;
 }();
@@ -31793,6 +31971,13 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
         this._length = 0;
     };
     /**
+   * Samples an animation at a given time.
+   * @param entity - The animated entity
+   * @param time - The time to sample an animation
+   */ _proto.sampleAnimation = function sampleAnimation(entity, time) {
+        this._sampleAnimation(entity, time);
+    };
+    /**
    * @internal
    * Samples an animation at a given time.
    * @param entity - The animated entity
@@ -33186,7 +33371,7 @@ function _type_of(obj) {
  * @internal
  */ var AnimatorLayerData = /*#__PURE__*/ function() {
     function AnimatorLayerData() {
-        this.curveOwnerPool = Object.create(null);
+        this.curveOwnerPool = new WeakMap();
         this.animatorStateDataMap = {};
         this.srcPlayData = new AnimatorStatePlayData();
         this.destPlayData = new AnimatorStatePlayData();
@@ -33214,6 +33399,8 @@ function _type_of(obj) {
  */ var AnimatorStateData = function AnimatorStateData() {
     this.curveLayerOwner = [];
     this.eventHandlers = [];
+    this.state = null;
+    this.clipChangedListener = null;
 };
 
 /**
@@ -33222,7 +33409,7 @@ function _type_of(obj) {
     _inherits(Animator, Component);
     function Animator(entity) {
         var _this;
-        _this = Component.call(this, entity) || this, /** Culling mode of this Animator. */ _this.cullingMode = AnimatorCullingMode.None, /** The playback speed of the Animator, 1.0 is normal playback speed. */ _this.speed = 1.0, /** @internal */ _this._playFrameCount = -1, /** @internal */ _this._onUpdateIndex = -1, _this._updateMark = 0, _this._animatorLayersData = new Array(), _this._curveOwnerPool = Object.create(null), _this._animationEventHandlerPool = new ClearableObjectPool(AnimationEventHandler), _this._parametersValueMap = Object.create(null), _this._tempAnimatorStateInfo = {
+        _this = Component.call(this, entity) || this, /** Culling mode of this Animator. */ _this.cullingMode = AnimatorCullingMode.None, /** The playback speed of the Animator, 1.0 is normal playback speed. */ _this.speed = 1.0, /** Whether the Animator sends AnimationEvent callbacks. */ _this.fireEvents = true, /** @internal */ _this._playFrameCount = -1, /** @internal */ _this._onUpdateIndex = -1, _this._updateMark = 0, _this._animatorLayersData = new Array(), _this._curveOwnerPool = new WeakMap(), _this._animationEventHandlerPool = new ClearableObjectPool(AnimationEventHandler), _this._parametersValueMap = Object.create(null), _this._tempAnimatorStateInfo = {
             layerIndex: -1,
             state: null
         }, _this._controlledRenderers = new Array();
@@ -33418,16 +33605,32 @@ function _type_of(obj) {
     /**
    * @internal
    */ _proto._reset = function _reset() {
-        var _this = this, animationCurveOwners = _this._curveOwnerPool;
-        for(var instanceId in animationCurveOwners){
-            var propertyOwners = animationCurveOwners[instanceId];
-            for(var property in propertyOwners){
-                var owner = propertyOwners[property];
-                owner.revertDefaultValue();
+        // revertDefaultValue 可能在死 target 上抛；listener 清理必须始终发生，否则
+        // polyfill 的 clipChangedListener 会留在共享的 AnimatorState 上，捕获 this(Animator)→Entity 整树。
+        // 用 try/catch 隔离 revert，listener 块紧跟其后无条件执行。
+        var layersData = this._animatorLayersData;
+        for(var i = 0, n = layersData.length; i < n; i++){
+            var stateDataMap = layersData[i].animatorStateDataMap;
+            for(var stateName in stateDataMap){
+                var stateData = stateDataMap[stateName];
+                var layerOwners = stateData.curveLayerOwner;
+                for(var j = 0, m = layerOwners.length; j < m; j++){
+                    try {
+                        var _layerOwners_j_curveOwner, _layerOwners_j;
+                        (_layerOwners_j = layerOwners[j]) == null ? void 0 : (_layerOwners_j_curveOwner = _layerOwners_j.curveOwner) == null ? void 0 : _layerOwners_j_curveOwner.revertDefaultValue();
+                    } catch (e) {
+                        Logger.warn("Animator._reset: revertDefaultValue threw", e);
+                    }
+                }
+                if (stateData.clipChangedListener && stateData.state) {
+                    stateData.state._updateFlagManager.removeListener(stateData.clipChangedListener);
+                    stateData.clipChangedListener = null;
+                    stateData.state = null;
+                }
             }
         }
         this._animatorLayersData.length = 0;
-        this._curveOwnerPool = Object.create(null);
+        this._curveOwnerPool = new WeakMap();
         this._parametersValueMap = Object.create(null);
         this._animationEventHandlerPool.clear();
         if (this._controllerUpdateFlag) {
@@ -33445,6 +33648,7 @@ function _type_of(obj) {
     };
     _proto._onDestroy = function _onDestroy() {
         Component.prototype._onDestroy.call(this);
+        this._reset();
         var controller = this._animatorController;
         if (controller) {
             var _this__controllerUpdateFlag;
@@ -33511,19 +33715,26 @@ function _type_of(obj) {
             var relativePath = curve.relativePath;
             var targetEntity = curve.relativePath === "" ? entity : entity.findByPath(curve.relativePath);
             if (targetEntity) {
-                var _curveOwnerPool, _instanceId, _propertyOwners, _property, _layerCurveOwnerPool, _instanceId1, _layerPropertyOwners, _property1;
+                var _propertyOwners, _property, _layerPropertyOwners, _property1;
                 var component = curve.typeIndex > 0 ? targetEntity.getComponents(curve.type, components)[curve.typeIndex] : targetEntity.getComponent(curve.type);
                 components.length = 0;
                 if (!component) {
                     continue;
                 }
                 var property = curve.property;
-                var instanceId = component.instanceId;
-                // Get owner
-                var propertyOwners = (_curveOwnerPool = curveOwnerPool)[_instanceId = instanceId] || (_curveOwnerPool[_instanceId] = Object.create(null));
+                // Get owner — WeakMap keyed by Component so dead components let entries GC.
+                var propertyOwners = curveOwnerPool.get(component);
+                if (!propertyOwners) {
+                    propertyOwners = Object.create(null);
+                    curveOwnerPool.set(component, propertyOwners);
+                }
                 var owner = (_propertyOwners = propertyOwners)[_property = property] || (_propertyOwners[_property] = curve._createCurveOwner(targetEntity, component));
-                // Get layer owner
-                var layerPropertyOwners = (_layerCurveOwnerPool = layerCurveOwnerPool)[_instanceId1 = instanceId] || (_layerCurveOwnerPool[_instanceId1] = Object.create(null));
+                // Get layer owner — same WeakMap-by-Component pattern (was Record<instanceId,...> which kept dead components pinned for the Animator's lifetime).
+                var layerPropertyOwners = layerCurveOwnerPool.get(component);
+                if (!layerPropertyOwners) {
+                    layerPropertyOwners = Object.create(null);
+                    layerCurveOwnerPool.set(component, layerPropertyOwners);
+                }
                 var layerOwner = (_layerPropertyOwners = layerPropertyOwners)[_property1 = property] || (_layerPropertyOwners[_property1] = curve._createCurveLayerOwner(owner));
                 if (mask && mask.pathMasks.length) {
                     var _mask_getPathMask;
@@ -33565,6 +33776,8 @@ function _type_of(obj) {
         };
         clipChangedListener();
         state._updateFlagManager.addListener(clipChangedListener);
+        animatorStateData.state = state;
+        animatorStateData.clipChangedListener = clipChangedListener;
     };
     _proto._clearCrossData = function _clearCrossData(animatorLayerData) {
         animatorLayerData.crossCurveMark++;
@@ -34233,7 +34446,7 @@ function _type_of(obj) {
     };
     _proto._fireAnimationEventsAndCallScripts = function _fireAnimationEventsAndCallScripts(layerIndex, playData, state, lastClipTime, lastPlayState, deltaTime) {
         var eventHandlers = playData.stateData.eventHandlers;
-        eventHandlers.length && this._fireAnimationEvents(playData, eventHandlers, lastClipTime, deltaTime);
+        this.fireEvents && eventHandlers.length && this._fireAnimationEvents(playData, eventHandlers, lastClipTime, deltaTime);
         if (lastPlayState === AnimatorStatePlayState.UnStarted) {
             state._callOnEnter(this, layerIndex);
         }
@@ -34297,6 +34510,9 @@ Animator._passedTriggerParameterNames = new Array();
 __decorate([
     assignmentClone
 ], Animator.prototype, "speed", void 0);
+__decorate([
+    assignmentClone
+], Animator.prototype, "fireEvents", void 0);
 __decorate([
     assignmentClone
 ], Animator.prototype, "_animatorController", void 0);