@galacean/engine-core 0.9.12 → 0.9.14

package/dist/main.js

@@ -2242,6 +2242,28 @@ var /** @internal */ PromiseState;
    * @remarks The release principle is that it is not referenced by the components, including direct and indirect reference.
    */ _proto.gc = function gc() {
         this._gc(false);
+        var engine = this.engine;
+        engine._renderElementPool.garbageCollection();
+        engine._spriteElementPool.garbageCollection();
+        engine._spriteMaskElementPool.garbageCollection();
+        engine._textElementPool.garbageCollection();
+        var _componentsManager = engine._componentsManager, _lightManager = engine._lightManager;
+        _componentsManager._renderers.garbageCollection();
+        // @ts-ignore
+        _componentsManager._onStartScripts.garbageCollection();
+        // @ts-ignore
+        _componentsManager._onUpdateScripts.garbageCollection();
+        // @ts-ignore
+        _componentsManager._onLateUpdateScripts.garbageCollection();
+        // @ts-ignore
+        _componentsManager._onPhysicsUpdateScripts.garbageCollection();
+        // @ts-ignore
+        _componentsManager._onUpdateAnimations.garbageCollection();
+        // @ts-ignore
+        _componentsManager._onUpdateRenderers.garbageCollection();
+        _lightManager._spotLights.garbageCollection();
+        _lightManager._pointLights.garbageCollection();
+        _lightManager._directLights.garbageCollection();
     };
     /**
    * @internal
@@ -4084,6 +4106,11 @@ var TransformModifyFlags;
    * @returns Cloned entity
    */ _proto.clone = function clone() {
         var cloneEntity = new Entity(this._engine, this.name);
+        var _this = this, hookResource = _this._hookResource;
+        if (hookResource) {
+            cloneEntity._hookResource = hookResource;
+            hookResource._addRefCount(1);
+        }
         cloneEntity._isActive = this._isActive;
         cloneEntity.transform.localMatrix = this.transform.localMatrix;
         var children = this._children;
@@ -4108,6 +4135,10 @@ var TransformModifyFlags;
             return;
         }
         EngineObject.prototype.destroy.call(this);
+        if (this._hookResource) {
+            this._hookResource._addRefCount(-1);
+            this._hookResource = null;
+        }
         var components = this._components;
         for(var i = components.length - 1; i >= 0; i--){
             components[i].destroy();
@@ -9784,9 +9815,9 @@ __decorate([
     function Material(engine, shader) {
         var _this;
         _this = RefObject.call(this, engine) || this;
-        /** Shader data. */ _this.shaderData = new ShaderData(ShaderDataGroup.Material);
         /** @internal */ _this._renderStates = [] // todo: later will as a part of shaderData when shader effect frame is OK, that is more powerful and flexible.
         ;
+        _this._shaderData = new ShaderData(ShaderDataGroup.Material);
         _this.shader = shader;
         return _this;
     }
@@ -9818,8 +9849,21 @@ __decorate([
    */ _proto._preRender = function _preRender(renderElement) {};
     /**
    * @override
-   */ _proto._onDestroy = function _onDestroy() {};
+   */ _proto._onDestroy = function _onDestroy() {
+        this._shader = null;
+        this._shaderData = null;
+        this._renderStates.length = 0;
+        this._renderStates = null;
+    };
     _create_class(Material, [
+        {
+            key: "shaderData",
+            get: /**
+   *  Shader data.
+   */ function get() {
+                return this._shaderData;
+            }
+        },
         {
             key: "shader",
             get: /**
@@ -9888,6 +9932,12 @@ __decorate([
    */ _proto.resetPool = function resetPool() {
         this._elementPoolIndex = 0;
     };
+    _proto.garbageCollection = function garbageCollection() {
+        var _this = this, pool = _this._elementPool;
+        for(var i = pool.length - 1; i >= 0; i--){
+            pool[i].dispose && pool[i].dispose();
+        }
+    };
     return ClassPool;
 }();
 
@@ -9910,6 +9960,9 @@ var RenderElement = function RenderElement() {
         this.renderState = renderState;
         this.shaderPass = shaderPass;
     };
+    _proto.dispose = function dispose() {
+        this.component = this.mesh = this.subMesh = this.material = this.renderState = this.shaderPass = null;
+    };
     return MeshRenderElement;
 }(RenderElement);
 
@@ -9955,6 +10008,9 @@ var SpriteElement = /*#__PURE__*/ function(RenderElement) {
         this.renderState = renderState;
         this.shaderPass = shaderPass;
     };
+    _proto.dispose = function dispose() {
+        this.component = this.renderData = this.material = this.texture = this.renderState = this.shaderPass = null;
+    };
     return SpriteElement;
 }(RenderElement);
 
@@ -9973,6 +10029,9 @@ var SpriteMaskElement = /*#__PURE__*/ function(RenderElement) {
         this.renderData = renderData;
         this.material = material;
     };
+    _proto.dispose = function dispose() {
+        this.component = this.renderData = this.material = null;
+    };
     return SpriteMaskElement;
 }(RenderElement);
 
@@ -9991,7 +10050,6 @@ exports.Renderer = (_Renderer = /*#__PURE__*/ function(Component) {
     function Renderer1(entity) {
         var _this;
         _this = Component.call(this, entity) || this;
-        /** ShaderData related to renderer. */ _this.shaderData = new ShaderData(ShaderDataGroup.Renderer);
         /** @internal */ _this._onUpdateIndex = -1;
         /** @internal */ _this._rendererIndex = -1;
         /** @internal */ _this._globalShaderMacro = new ShaderMacroCollection();
@@ -9999,6 +10057,7 @@ exports.Renderer = (_Renderer = /*#__PURE__*/ function(Component) {
         _this._overrideUpdate = false;
         _this._materials = [];
         _this._dirtyUpdateFlag = 0;
+        _this._shaderData = new ShaderData(ShaderDataGroup.Renderer);
         _this._mvMatrix = new engineMath.Matrix();
         _this._mvpMatrix = new engineMath.Matrix();
         _this._mvInvMatrix = new engineMath.Matrix();
@@ -10145,6 +10204,17 @@ exports.Renderer = (_Renderer = /*#__PURE__*/ function(Component) {
             var _materials_i;
             (_materials_i = materials[i]) == null ? void 0 : _materials_i._addRefCount(-1);
         }
+        this._entity = null;
+        this._globalShaderMacro = null;
+        this._bounds = null;
+        this._materials = null;
+        this._shaderData = null;
+        this._mvMatrix = null;
+        this._mvpMatrix = null;
+        this._mvInvMatrix = null;
+        this._normalMatrix = null;
+        this._materialsInstanced = null;
+        this._rendererLayer = null;
     };
     _proto._updateShaderData = function _updateShaderData(context) {
         var entity = this.entity;
@@ -10206,6 +10276,14 @@ exports.Renderer = (_Renderer = /*#__PURE__*/ function(Component) {
         this._dirtyUpdateFlag |= 0x1;
     };
     _create_class(Renderer1, [
+        {
+            key: "shaderData",
+            get: /**
+   * ShaderData related to renderer.
+   */ function get() {
+                return this._shaderData;
+            }
+        },
         {
             key: "isCulled",
             get: /**
@@ -10290,9 +10368,6 @@ exports.Renderer = (_Renderer = /*#__PURE__*/ function(Component) {
 }(), function() {
     _Renderer._rendererLayerProperty = Shader.getPropertyByName("oasis_RendererLayer");
 }(), _Renderer);
-__decorate([
-    deepClone
-], exports.Renderer.prototype, "shaderData", void 0);
 __decorate([
     ignoreClone
 ], exports.Renderer.prototype, "_distanceForSort", void 0);
@@ -10320,6 +10395,9 @@ __decorate([
 __decorate([
     ignoreClone
 ], exports.Renderer.prototype, "_dirtyUpdateFlag", void 0);
+__decorate([
+    deepClone
+], exports.Renderer.prototype, "_shaderData", void 0);
 __decorate([
     ignoreClone
 ], exports.Renderer.prototype, "_mvMatrix", void 0);
@@ -10574,6 +10652,7 @@ SimpleSpriteAssembler = __decorate([
             sprite._addRefCount(-1);
             sprite._updateFlagManager.removeListener(this._onSpriteChange);
         }
+        this._entity = null;
         this._sprite = null;
         this._renderData = null;
     };
@@ -11179,14 +11258,19 @@ var BufferUtil = /*#__PURE__*/ function() {
 
 /**
  * Sub-mesh, mainly contains drawing information.
- */ var SubMesh = function SubMesh(start, count, topology) {
-    if (start === void 0) start = 0;
-    if (count === void 0) count = 0;
-    if (topology === void 0) topology = exports.MeshTopology.Triangles;
-    this.start = start;
-    this.count = count;
-    this.topology = topology;
-};
+ */ var SubMesh = /*#__PURE__*/ function() {
+    function SubMesh(start, count, topology) {
+        if (start === void 0) start = 0;
+        if (count === void 0) count = 0;
+        if (topology === void 0) topology = exports.MeshTopology.Triangles;
+        this.start = start;
+        this.count = count;
+        this.topology = topology;
+    }
+    var _proto = SubMesh.prototype;
+    _proto.dispose = function dispose() {};
+    return SubMesh;
+}();
 
 /**
  * Mesh.
@@ -11302,6 +11386,7 @@ var BufferUtil = /*#__PURE__*/ function() {
         this._indexBufferBinding = null;
         this._vertexElements = null;
         this._vertexElementMap = null;
+        this._updateFlagManager = null;
         this._platformPrimitive.destroy();
     };
     _proto._setVertexElements = function _setVertexElements(elements) {
@@ -12987,8 +13072,8 @@ var VertexChangedFlags;
    */ _proto._onDestroy = function _onDestroy() {
         Renderer.prototype._onDestroy.call(this);
         var mesh = this._mesh;
-        if (mesh && !mesh.destroyed) {
-            mesh._addRefCount(-1);
+        if (mesh) {
+            mesh.destroyed || mesh._addRefCount(-1);
             mesh._updateFlagManager.removeListener(this._onMeshChanged);
             this._mesh = null;
         }
@@ -13325,10 +13410,21 @@ var rePropName = RegExp(// Match anything that isn't a dot or bracket.
    * @internal
    * @override
    */ _proto._onDestroy = function _onDestroy() {
-        var _this_rootBone, _this__jointTexture;
+        var _this__rootBone, _this__jointTexture;
         MeshRenderer.prototype._onDestroy.call(this);
-        (_this_rootBone = this.rootBone) == null ? void 0 : _this_rootBone.transform._updateFlagManager.removeListener(this._onTransformChanged);
+        (_this__rootBone = this._rootBone) == null ? void 0 : _this__rootBone.transform._updateFlagManager.removeListener(this._onTransformChanged);
+        this._rootBone = null;
+        this._jointDataCreateCache = null;
+        this._skin = null;
+        this._blendShapeWeights = null;
+        this._localBounds = null;
+        this._jointMatrices = null;
         (_this__jointTexture = this._jointTexture) == null ? void 0 : _this__jointTexture.destroy();
+        this._jointTexture = null;
+        if (this._jointEntities) {
+            this._jointEntities.length = 0;
+            this._jointEntities = null;
+        }
     };
     /**
    * @internal
@@ -14716,6 +14812,11 @@ var TextRenderElement = /*#__PURE__*/ function(RenderElement) {
         _this.multiRenderData = true;
         return _this;
     }
+    var _proto = TextRenderElement.prototype;
+    _proto.dispose = function dispose() {
+        this.component = this.material = this.renderState = this.shaderPass = null;
+        this.charElements.length = 0;
+    };
     return TextRenderElement;
 }(RenderElement);
 
@@ -14863,7 +14964,6 @@ var TextRenderElement = /*#__PURE__*/ function(RenderElement) {
         this.texture = null;
         this.solidColor = null;
         this.sky.destroy();
-        this._engine = null;
     };
     /**
    * @internal
@@ -15248,8 +15348,6 @@ var TextRenderElement = /*#__PURE__*/ function(RenderElement) {
     function Scene(engine, name) {
         var _this;
         _this = EngineObject.call(this, engine) || this;
-        /** The background of the scene. */ _this.background = new Background(_this._engine);
-        /** Scene-related shader data. */ _this.shaderData = new ShaderData(ShaderDataGroup.Scene);
         /** If cast shadows. */ _this.castShadows = true;
         /** The resolution of the shadow maps. */ _this.shadowResolution = exports.ShadowResolution.Medium;
         /** The splits of two cascade distribution. */ _this.shadowTwoCascadeSplits = 1.0 / 3.0;
@@ -15259,6 +15357,8 @@ var TextRenderElement = /*#__PURE__*/ function(RenderElement) {
         /** @internal */ _this._isActiveInEngine = false;
         /** @internal */ _this._globalShaderMacro = new ShaderMacroCollection();
         /** @internal */ _this._rootEntities = [];
+        _this._background = new Background(_this._engine);
+        _this._shaderData = new ShaderData(ShaderDataGroup.Scene);
         _this._shadowCascades = exports.ShadowCascadesMode.NoCascades;
         _this._fogMode = exports.FogMode.None;
         _this._fogColor = new engineMath.Color(0.5, 0.5, 0.5, 1.0);
@@ -15420,6 +15520,8 @@ var TextRenderElement = /*#__PURE__*/ function(RenderElement) {
         var sunLightIndex = lightManager._getSunLightIndex();
         if (sunLightIndex !== -1) {
             this._sunLight = lightManager._directLights.get(sunLightIndex);
+        } else {
+            this._sunLight = null;
         }
         if (this.castShadows && this._sunLight && this._sunLight.shadowType !== exports.ShadowType.None) {
             shaderData.enableMacro("SHADOW_TYPE", this._sunLight.shadowType.toString());
@@ -15479,6 +15581,22 @@ var TextRenderElement = /*#__PURE__*/ function(RenderElement) {
         this._fogParams.w = density / Math.sqrt(Math.LN2);
     };
     _create_class(Scene, [
+        {
+            key: "shaderData",
+            get: /**
+   * Scene-related shader data.
+   */ function get() {
+                return this._shaderData;
+            }
+        },
+        {
+            key: "background",
+            get: /**
+   * The background of the scene.
+   */ function get() {
+                return this._background;
+            }
+        },
         {
             key: "shadowCascades",
             get: /**
@@ -17770,7 +17888,6 @@ exports.Camera = (_Camera = /*#__PURE__*/ function(Component) {
     function Camera1(entity) {
         var _this;
         _this = Component.call(this, entity) || this;
-        /** Shader data. */ _this.shaderData = new ShaderData(ShaderDataGroup.Camera);
         /** Rendering priority - A Camera with higher priority will be rendered on top of a camera with lower priority. */ _this.priority = 0;
         /** Whether to enable frustum culling, it is enabled by default. */ _this.enableFrustumCulling = true;
         /**
@@ -17784,6 +17901,7 @@ exports.Camera = (_Camera = /*#__PURE__*/ function(Component) {
         /** @internal */ _this._globalShaderMacro = new ShaderMacroCollection();
         /** @internal */ _this._frustum = new engineMath.BoundingFrustum();
         /** @internal */ _this._virtualCamera = new VirtualCamera();
+        _this._shaderData = new ShaderData(ShaderDataGroup.Camera);
         _this._isProjMatSetting = false;
         _this._nearClipPlane = 0.1;
         _this._farClipPlane = 100;
@@ -17982,6 +18100,20 @@ exports.Camera = (_Camera = /*#__PURE__*/ function(Component) {
         this._isInvViewProjDirty.destroy();
         this._isViewMatrixDirty.destroy();
         this.shaderData._addRefCount(-1);
+        this._entity = null;
+        this._globalShaderMacro = null;
+        this._frustum = null;
+        this._renderPipeline = null;
+        this._virtualCamera = null;
+        this._shaderData = null;
+        this._frustumViewChangeFlag = null;
+        this._transform = null;
+        this._isViewMatrixDirty = null;
+        this._isInvViewProjDirty = null;
+        this._viewport = null;
+        this._inverseProjectionMatrix = null;
+        this._lastAspectSize = null;
+        this._invViewProjMat = null;
     };
     _proto._projMatChange = function _projMatChange() {
         this._isFrustumProjectDirty = true;
@@ -18021,6 +18153,14 @@ exports.Camera = (_Camera = /*#__PURE__*/ function(Component) {
         return this._inverseProjectionMatrix;
     };
     _create_class(Camera1, [
+        {
+            key: "shaderData",
+            get: /**
+   * Shader data.
+   */ function get() {
+                return this._shaderData;
+            }
+        },
         {
             key: "nearClipPlane",
             get: /**
@@ -20089,6 +20229,7 @@ SlicedSpriteAssembler = __decorate([
             sprite._addRefCount(-1);
             sprite._updateFlagManager.removeListener(this._onSpriteChange);
         }
+        this._entity = null;
         this._color = null;
         this._sprite = null;
         this._assembler = null;
@@ -21328,8 +21469,6 @@ var DirtyFlag;
  * @internal
  */ var AnimationCurveOwner = /*#__PURE__*/ function() {
     function AnimationCurveOwner(target, type, property, cureType) {
-        this.crossCurveMark = 0;
-        this.hasSavedDefaultValue = false;
         this.baseEvaluateData = {
             curKeyframeIndex: 0,
             value: null
@@ -21342,7 +21481,7 @@ var DirtyFlag;
         this.type = type;
         this.property = property;
         this.component = target.getComponent(type);
-        this._cureType = cureType;
+        this.cureType = cureType;
         var assemblerType = AnimationCurveOwner.getAssemblerType(type, property);
         this._assembler = new assemblerType();
         this._assembler.initialize(this);
@@ -21351,89 +21490,80 @@ var DirtyFlag;
         }
     }
     var _proto = AnimationCurveOwner.prototype;
-    _proto.evaluateAndApplyValue = function evaluateAndApplyValue(curve, time, layerWeight, additive) {
-        if (curve.keys.length) {
-            if (additive) {
-                var value = curve._evaluateAdditive(time, this.baseEvaluateData);
-                var cureType = this._cureType;
-                if (cureType._isReferenceType) {
-                    cureType._additiveValue(value, layerWeight, this.referenceTargetValue);
-                } else {
-                    var assembler = this._assembler;
-                    var originValue = assembler.getTargetValue();
-                    var additiveValue = cureType._additiveValue(value, layerWeight, originValue);
-                    assembler.setTargetValue(additiveValue);
-                }
-            } else {
-                var value1 = curve._evaluate(time, this.baseEvaluateData);
-                this._applyValue(value1, layerWeight);
-            }
-        }
+    _proto.evaluateValue = function evaluateValue(curve, time, additive) {
+        return additive ? curve._evaluateAdditive(time, this.baseEvaluateData) : curve._evaluate(time, this.baseEvaluateData);
     };
-    _proto.crossFadeAndApplyValue = function crossFadeAndApplyValue(srcCurve, destCurve, srcTime, destTime, crossWeight, layerWeight, additive) {
-        var srcValue = srcCurve && srcCurve.keys.length ? additive ? srcCurve._evaluateAdditive(srcTime, this.baseEvaluateData) : srcCurve._evaluate(srcTime, this.baseEvaluateData) : additive ? this._cureType._getZeroValue(this.baseEvaluateData.value) : this.defaultValue;
-        var destValue = destCurve && destCurve.keys.length ? additive ? destCurve._evaluateAdditive(destTime, this.crossEvaluateData) : destCurve._evaluate(destTime, this.crossEvaluateData) : additive ? this._cureType._getZeroValue(this.crossEvaluateData.value) : this.defaultValue;
-        this._applyCrossValue(srcValue, destValue, crossWeight, layerWeight, additive);
+    _proto.evaluateCrossFadeValue = function evaluateCrossFadeValue(srcCurve, destCurve, srcTime, destTime, crossWeight, additive) {
+        var srcValue = srcCurve && srcCurve.keys.length ? additive ? srcCurve._evaluateAdditive(srcTime, this.baseEvaluateData) : srcCurve._evaluate(srcTime, this.baseEvaluateData) : additive ? this.cureType._getZeroValue(this.baseEvaluateData.value) : this.defaultValue;
+        var destValue = destCurve && destCurve.keys.length ? additive ? destCurve._evaluateAdditive(destTime, this.crossEvaluateData) : destCurve._evaluate(destTime, this.crossEvaluateData) : additive ? this.cureType._getZeroValue(this.crossEvaluateData.value) : this.defaultValue;
+        return this._lerpValue(srcValue, destValue, crossWeight);
     };
-    _proto.crossFadeFromPoseAndApplyValue = function crossFadeFromPoseAndApplyValue(destCurve, destTime, crossWeight, layerWeight, additive) {
-        var srcValue = additive ? this._cureType._subtractValue(this.fixedPoseValue, this.defaultValue, this.baseEvaluateData.value) : this.fixedPoseValue;
-        var destValue = destCurve && destCurve.keys.length ? additive ? destCurve._evaluateAdditive(destTime, this.crossEvaluateData) : destCurve._evaluate(destTime, this.crossEvaluateData) : additive ? this._cureType._getZeroValue(this.crossEvaluateData.value) : this.defaultValue;
-        this._applyCrossValue(srcValue, destValue, crossWeight, layerWeight, additive);
+    _proto.crossFadeFromPoseAndApplyValue = function crossFadeFromPoseAndApplyValue(destCurve, destTime, crossWeight, additive) {
+        var srcValue = additive ? this.cureType._subtractValue(this.fixedPoseValue, this.defaultValue, this.baseEvaluateData.value) : this.fixedPoseValue;
+        var destValue = destCurve && destCurve.keys.length ? additive ? destCurve._evaluateAdditive(destTime, this.crossEvaluateData) : destCurve._evaluate(destTime, this.crossEvaluateData) : additive ? this.cureType._getZeroValue(this.crossEvaluateData.value) : this.defaultValue;
+        return this._lerpValue(srcValue, destValue, crossWeight);
     };
     _proto.revertDefaultValue = function revertDefaultValue() {
         this._assembler.setTargetValue(this.defaultValue);
     };
+    _proto.getEvaluateValue = function getEvaluateValue(out) {
+        if (this.cureType._isReferenceType) {
+            this.cureType._copyValue(this.baseEvaluateData.value, out);
+            return out;
+        } else {
+            return this.baseEvaluateData.value;
+        }
+    };
     _proto.saveDefaultValue = function saveDefaultValue() {
-        if (this._cureType._isReferenceType) {
-            this._cureType._copyValue(this.referenceTargetValue, this.defaultValue);
+        if (this.cureType._isReferenceType) {
+            this.cureType._copyValue(this.referenceTargetValue, this.defaultValue);
         } else {
             this.defaultValue = this._assembler.getTargetValue();
         }
-        this.hasSavedDefaultValue = true;
     };
     _proto.saveFixedPoseValue = function saveFixedPoseValue() {
-        if (this._cureType._isReferenceType) {
-            this._cureType._copyValue(this.referenceTargetValue, this.fixedPoseValue);
+        if (this.cureType._isReferenceType) {
+            this.cureType._copyValue(this.referenceTargetValue, this.fixedPoseValue);
         } else {
             this.fixedPoseValue = this._assembler.getTargetValue();
         }
     };
-    _proto._applyValue = function _applyValue(value, weight) {
-        if (weight === 1.0) {
-            if (this._cureType._isReferenceType) {
-                this._cureType._copyValue(value, this.referenceTargetValue);
+    _proto.applyValue = function applyValue(value, weight, additive) {
+        var cureType = this.cureType;
+        if (additive) {
+            if (cureType._isReferenceType) {
+                cureType._additiveValue(value, weight, this.referenceTargetValue);
             } else {
-                this._assembler.setTargetValue(value);
+                var assembler = this._assembler;
+                var originValue = assembler.getTargetValue();
+                var additiveValue = cureType._additiveValue(value, weight, originValue);
+                assembler.setTargetValue(additiveValue);
             }
         } else {
-            if (this._cureType._isReferenceType) {
-                var targetValue = this.referenceTargetValue;
-                this._cureType._lerpValue(targetValue, value, weight, targetValue);
+            if (weight === 1.0) {
+                if (cureType._isReferenceType) {
+                    cureType._copyValue(value, this.referenceTargetValue);
+                } else {
+                    this._assembler.setTargetValue(value);
+                }
             } else {
-                var originValue = this._assembler.getTargetValue();
-                var lerpValue = this._cureType._lerpValue(originValue, value, weight);
-                this._assembler.setTargetValue(lerpValue);
+                if (cureType._isReferenceType) {
+                    var targetValue = this.referenceTargetValue;
+                    cureType._lerpValue(targetValue, value, weight, targetValue);
+                } else {
+                    var originValue1 = this._assembler.getTargetValue();
+                    var lerpValue = cureType._lerpValue(originValue1, value, weight);
+                    this._assembler.setTargetValue(lerpValue);
+                }
             }
         }
     };
-    _proto._applyCrossValue = function _applyCrossValue(srcValue, destValue, crossWeight, layerWeight, additive) {
-        var out;
-        if (this._cureType._isReferenceType) {
-            out = this.baseEvaluateData.value;
-            this._cureType._lerpValue(srcValue, destValue, crossWeight, out);
-        } else {
-            out = this._cureType._lerpValue(srcValue, destValue, crossWeight);
-        }
-        if (additive) {
-            if (this._cureType._isReferenceType) {
-                this._cureType._additiveValue(out, layerWeight, this.referenceTargetValue);
-            } else {
-                var originValue = this._assembler.getTargetValue();
-                var lerpValue = this._cureType._additiveValue(out, layerWeight, originValue);
-                this._assembler.setTargetValue(lerpValue);
-            }
+    _proto._lerpValue = function _lerpValue(srcValue, destValue, crossWeight) {
+        if (this.cureType._isReferenceType) {
+            return this.cureType._lerpValue(srcValue, destValue, crossWeight, this.baseEvaluateData.value);
         } else {
-            this._applyValue(out, layerWeight);
+            this.baseEvaluateData.value = this.cureType._lerpValue(srcValue, destValue, crossWeight);
+            return this.baseEvaluateData.value;
         }
     };
     AnimationCurveOwner.registerAssembler = function registerAssembler(componentType, property, assemblerType) {
@@ -21527,6 +21657,27 @@ AnimationCurveOwner.registerAssembler(Transform, "scale", ScaleAnimationCurveOwn
 }();
 AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights", BlendShapeWeightsAnimationCurveOwnerAssembler);
 
+/**
+ * @internal
+ */ var AnimationCurveLayerOwner = /*#__PURE__*/ function() {
+    function AnimationCurveLayerOwner() {
+        this.crossCurveMark = 0;
+    }
+    var _proto = AnimationCurveLayerOwner.prototype;
+    _proto.initFinalValue = function initFinalValue() {
+        var _this_curveOwner = this.curveOwner, cureType = _this_curveOwner.cureType, defaultValue = _this_curveOwner.defaultValue;
+        if (cureType._isReferenceType) {
+            cureType._copyValue(defaultValue, this.finalValue);
+        } else {
+            this.finalValue = defaultValue;
+        }
+    };
+    _proto.saveFinalValue = function saveFinalValue() {
+        this.finalValue = this.curveOwner.getEvaluateValue(this.finalValue);
+    };
+    return AnimationCurveLayerOwner;
+}();
+
 /**
  * Associate AnimationCurve and the Entity
  */ var AnimationClipCurveBinding = /*#__PURE__*/ function() {
@@ -21540,10 +21691,22 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
         var curveType = this.curve.constructor;
         var owner = new AnimationCurveOwner(entity, this.type, this.property, curveType);
         curveType._initializeOwner(owner);
+        owner.saveDefaultValue();
         return owner;
     };
     /**
    * @internal
+   */ _proto._createCurveLayerOwner = function _createCurveLayerOwner(owner) {
+        var curveType = this.curve.constructor;
+        var layerOwner = new AnimationCurveLayerOwner();
+        curveType._initializeLayerOwner(layerOwner);
+        layerOwner.curveOwner = owner;
+        // If curve.keys.length is 0, updateFinishedState will assign 0 to the target, causing an error, so initialize by assigning defaultValue to finalValue.
+        layerOwner.initFinalValue();
+        return layerOwner;
+    };
+    /**
+   * @internal
    */ _proto._getTempCurveOwner = function _getTempCurveOwner(entity) {
         var instanceId = entity.instanceId;
         if (!this._tempCurveOwner[instanceId]) {
@@ -21623,7 +21786,8 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
             var targetEntity = entity.findByPath(curveData.relativePath);
             if (targetEntity) {
                 var curveOwner = curveData._getTempCurveOwner(targetEntity);
-                curveOwner.evaluateAndApplyValue(curveData.curve, time, 1, false);
+                var value = curveOwner.evaluateValue(curveData.curve, time, false);
+                curveOwner.applyValue(value, 1, false);
             }
         }
     };
@@ -21767,6 +21931,7 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
                     break;
             }
         }
+        evaluateData.value = value;
         return value;
     };
     /**
@@ -21823,6 +21988,11 @@ exports.AnimationArrayCurve = (_AnimationArrayCurve = /*#__PURE__*/ function(Ani
     };
     /**
    * @internal
+   */ AnimationArrayCurve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+        owner.finalValue = [];
+    };
+    /**
+   * @internal
    */ AnimationArrayCurve._lerpValue = function _lerpValue(srcValue, destValue, weight, out) {
         for(var i = 0, n = out.length; i < n; ++i){
             var src = srcValue[i];
@@ -21913,6 +22083,11 @@ exports.AnimationBoolCurve = (_AnimationBoolCurve = /*#__PURE__*/ function(Anima
     };
     /**
    * @internal
+   */ AnimationBoolCurve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+        owner.finalValue = false;
+    };
+    /**
+   * @internal
    */ AnimationBoolCurve._lerpValue = function _lerpValue(srcValue, destValue) {
         return destValue;
     };
@@ -21970,6 +22145,11 @@ exports.AnimationColorCurve = (_AnimationColorCurve = /*#__PURE__*/ function(Ani
     };
     /**
    * @internal
+   */ AnimationColorCurve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+        owner.finalValue = new engineMath.Color();
+    };
+    /**
+   * @internal
    */ AnimationColorCurve._lerpValue = function _lerpValue(srcValue, destValue, weight, out) {
         engineMath.Color.lerp(srcValue, destValue, weight, out);
         return out;
@@ -22077,6 +22257,12 @@ exports.AnimationFloatArrayCurve = (_AnimationFloatArrayCurve = /*#__PURE__*/ fu
     };
     /**
    * @internal
+   */ AnimationFloatArrayCurve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+        var size = owner.curveOwner.referenceTargetValue.length;
+        owner.finalValue = new Float32Array(size);
+    };
+    /**
+   * @internal
    */ AnimationFloatArrayCurve._lerpValue = function _lerpValue(srcValue, destValue, weight, out) {
         for(var i = 0, n = out.length; i < n; ++i){
             var src = srcValue[i];
@@ -22167,6 +22353,11 @@ exports.AnimationFloatCurve = (_AnimationFloatCurve = /*#__PURE__*/ function(Ani
     };
     /**
    * @internal
+   */ AnimationFloatCurve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+        owner.finalValue = 0;
+    };
+    /**
+   * @internal
    */ AnimationFloatCurve._lerpValue = function _lerpValue(srcValue, destValue, crossWeight) {
         return srcValue + (destValue - srcValue) * crossWeight;
     };
@@ -22236,6 +22427,11 @@ exports.AnimationQuaternionCurve = (_AnimationQuaternionCurve = /*#__PURE__*/ fu
     };
     /**
    * @internal
+   */ AnimationQuaternionCurve1._initializeLayerOwner = function _initializeLayerOwner(owner) {
+        owner.finalValue = new engineMath.Quaternion();
+    };
+    /**
+   * @internal
    */ AnimationQuaternionCurve1._lerpValue = function _lerpValue(src, dest, weight, out) {
         engineMath.Quaternion.slerp(src, dest, weight, out);
         return out;
@@ -22340,6 +22536,11 @@ exports.AnimationVector2Curve = (_AnimationVector2Curve = /*#__PURE__*/ function
     };
     /**
    * @internal
+   */ AnimationVector2Curve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+        owner.finalValue = new engineMath.Vector2();
+    };
+    /**
+   * @internal
    */ AnimationVector2Curve._lerpValue = function _lerpValue(srcValue, destValue, weight, out) {
         engineMath.Vector2.lerp(srcValue, destValue, weight, out);
         return out;
@@ -22425,6 +22626,11 @@ exports.AnimationVector3Curve = (_AnimationVector3Curve = /*#__PURE__*/ function
     };
     /**
    * @internal
+   */ AnimationVector3Curve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+        owner.finalValue = new engineMath.Vector3();
+    };
+    /**
+   * @internal
    */ AnimationVector3Curve._lerpValue = function _lerpValue(srcValue, destValue, weight, out) {
         engineMath.Vector3.lerp(srcValue, destValue, weight, out);
         return out;
@@ -22522,6 +22728,11 @@ exports.AnimationVector4Curve = (_AnimationVector4Curve = /*#__PURE__*/ function
     };
     /**
    * @internal
+   */ AnimationVector4Curve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+        owner.finalValue = new engineMath.Vector4();
+    };
+    /**
+   * @internal
    */ AnimationVector4Curve._lerpValue = function _lerpValue(srcValue, destValue, weight, out) {
         engineMath.Vector4.lerp(srcValue, destValue, weight, out);
         return out;
@@ -22631,13 +22842,21 @@ exports.AnimatorLayerBlendingMode = void 0;
     LayerState[LayerState[/** Playing state. */ "Playing"] = 1] = "Playing";
     LayerState[LayerState[/** CrossFading state. */ "CrossFading"] = 2] = "CrossFading";
     LayerState[LayerState[/** FixedCrossFading state. */ "FixedCrossFading"] = 3] = "FixedCrossFading";
+    LayerState[LayerState[/** Finished state. */ "Finished"] = 4] = "Finished";
 })(LayerState || (LayerState = {}));
 
 /**
  * @internal
- */ var AnimationEventHandler = function AnimationEventHandler() {
-    this.handlers = [];
-};
+ */ var AnimationEventHandler = /*#__PURE__*/ function() {
+    function AnimationEventHandler() {
+        this.handlers = [];
+    }
+    var _proto = AnimationEventHandler.prototype;
+    _proto.dispose = function dispose() {
+        this.handlers.length = 0;
+    };
+    return AnimationEventHandler;
+}();
 
 /**
  * Transitions define when and how the state machine switch from on state to another. AnimatorTransition always originate from a StateMachine or a StateMachine entry.
@@ -22695,12 +22914,14 @@ exports.AnimatorLayerBlendingMode = void 0;
  * @internal
  */ var AnimatorLayerData = /*#__PURE__*/ function() {
     function AnimatorLayerData() {
+        this.curveOwnerPool = Object.create(null);
         this.animatorStateDataMap = {};
         this.srcPlayData = new AnimatorStatePlayData();
         this.destPlayData = new AnimatorStatePlayData();
         this.layerState = LayerState.Standby;
         this.crossCurveMark = 0;
         this.manuallyTransition = new AnimatorStateTransition();
+        this.crossLayerOwnerCollection = [];
     }
     var _proto = AnimatorLayerData.prototype;
     _proto.switchPlayData = function switchPlayData() {
@@ -22715,7 +22936,7 @@ exports.AnimatorLayerBlendingMode = void 0;
 /**
  * @internal
  */ var AnimatorStateData = function AnimatorStateData() {
-    this.curveOwners = [];
+    this.curveLayerOwner = [];
     this.eventHandlers = [];
 };
 
@@ -22729,8 +22950,8 @@ exports.AnimatorLayerBlendingMode = void 0;
         /** Culling mode of this Animator. */ _this.cullingMode = exports.AnimatorCullingMode.None;
         /** The playback speed of the Animator, 1.0 is normal playback speed. */ _this.speed = 1.0;
         _this._animatorLayersData = [];
-        _this._crossOwnerCollection = [];
-        _this._animationCurveOwners = [];
+        _this._curveOwnerPool = Object.create(null);
+        _this._needRevertCurveOwners = [];
         _this._animationEventHandlerPool = new ClassPool(AnimationEventHandler);
         _this._tempAnimatorStateInfo = {
             layerIndex: -1,
@@ -22753,7 +22974,7 @@ exports.AnimatorLayerBlendingMode = void 0;
             this._reset();
         }
         var stateInfo = this._getAnimatorStateInfo(stateName, layerIndex);
-        var state = stateInfo.state;
+        var state = stateInfo.state, playLayerIndex = stateInfo.layerIndex;
         if (!state) {
             return;
         }
@@ -22762,9 +22983,8 @@ exports.AnimatorLayerBlendingMode = void 0;
             return;
         }
         var animatorLayerData = this._getAnimatorLayerData(stateInfo.layerIndex);
-        //TODO CM: Not consider same stateName, but different animation
-        var animatorStateData = this._getAnimatorStateData(stateName, state, animatorLayerData);
-        this._preparePlay(animatorLayerData, state, animatorStateData);
+        var animatorStateData = this._getAnimatorStateData(stateName, state, animatorLayerData, playLayerIndex);
+        this._preparePlay(animatorLayerData, state);
         animatorLayerData.layerState = LayerState.Playing;
         animatorLayerData.srcPlayData.reset(state, animatorStateData, state._getDuration() * normalizedTimeOffset);
     };
@@ -22815,6 +23035,7 @@ exports.AnimatorLayerBlendingMode = void 0;
             return;
         }
         deltaTime *= this.speed;
+        this._revertCurveOwners();
         for(var i1 = 0, n1 = animatorController.layers.length; i1 < n1; i1++){
             var animatorLayerData = this._getAnimatorLayerData(i1);
             if (animatorLayerData.layerState === LayerState.Standby) {
@@ -22855,17 +23076,17 @@ exports.AnimatorLayerBlendingMode = void 0;
     /**
    * @internal
    */ _proto._reset = function _reset() {
-        var _this = this, animationCurveOwners = _this._animationCurveOwners;
+        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.hasSavedDefaultValue && owner.revertDefaultValue();
+                owner.revertDefaultValue();
             }
         }
         this._animatorLayersData.length = 0;
-        this._crossOwnerCollection.length = 0;
-        this._animationCurveOwners.length = 0;
+        this._needRevertCurveOwners.length = 0;
+        this._curveOwnerPool = {};
         this._animationEventHandlerPool.resetPool();
         if (this._controllerUpdateFlag) {
             this._controllerUpdateFlag.flag = false;
@@ -22892,38 +23113,51 @@ exports.AnimatorLayerBlendingMode = void 0;
         stateInfo.state = state;
         return stateInfo;
     };
-    _proto._saveDefaultValues = function _saveDefaultValues(stateData) {
-        var curveOwners = stateData.curveOwners;
-        for(var i = curveOwners.length - 1; i >= 0; i--){
-            var _curveOwners_i;
-            (_curveOwners_i = curveOwners[i]) == null ? void 0 : _curveOwners_i.saveDefaultValue();
-        }
-    };
-    _proto._getAnimatorStateData = function _getAnimatorStateData(stateName, animatorState, animatorLayerData) {
+    _proto._getAnimatorStateData = function _getAnimatorStateData(stateName, animatorState, animatorLayerData, layerIndex) {
         var animatorStateDataMap = animatorLayerData.animatorStateDataMap;
         var animatorStateData = animatorStateDataMap[stateName];
         if (!animatorStateData) {
             animatorStateData = new AnimatorStateData();
             animatorStateDataMap[stateName] = animatorStateData;
-            this._saveAnimatorStateData(animatorState, animatorStateData);
+            this._saveAnimatorStateData(animatorState, animatorStateData, animatorLayerData, layerIndex);
             this._saveAnimatorEventHandlers(animatorState, animatorStateData);
         }
         return animatorStateData;
     };
-    _proto._saveAnimatorStateData = function _saveAnimatorStateData(animatorState, animatorStateData) {
-        var _this = this, entity = _this.entity, animationCureOwners = _this._animationCurveOwners;
-        var curveOwners = animatorStateData.curveOwners;
+    _proto._saveAnimatorStateData = function _saveAnimatorStateData(animatorState, animatorStateData, animatorLayerData, layerIndex) {
+        var _this = this, entity = _this.entity, curveOwnerPool = _this._curveOwnerPool;
+        var curveLayerOwner = animatorStateData.curveLayerOwner;
+        var layerCurveOwnerPool = animatorLayerData.curveOwnerPool;
         var _animatorState_clip = animatorState.clip, curves = _animatorState_clip._curveBindings;
         for(var i = curves.length - 1; i >= 0; i--){
             var curve = curves[i];
             var targetEntity = curve.relativePath === "" ? entity : entity.findByPath(curve.relativePath);
             if (targetEntity) {
+                var _curveOwnerPool, _instanceId, _propertyOwners, _property, _layerCurveOwnerPool, _instanceId1, _layerPropertyOwners, _property1;
                 var property = curve.property;
                 var instanceId = targetEntity.instanceId;
-                var propertyOwners = animationCureOwners[instanceId] || (animationCureOwners[instanceId] = {});
-                curveOwners[i] = propertyOwners[property] || (propertyOwners[property] = curve._createCurveOwner(targetEntity));
+                var needRevert = false;
+                var baseAnimatorLayerData = this._animatorLayersData[0];
+                var baseLayerCurveOwnerPool = baseAnimatorLayerData.curveOwnerPool;
+                if (this.animatorController.layers[layerIndex].blendingMode === exports.AnimatorLayerBlendingMode.Additive && layerIndex > 0 && !(baseLayerCurveOwnerPool[instanceId] && baseLayerCurveOwnerPool[instanceId][property])) {
+                    needRevert = true;
+                }
+                // Get owner
+                var propertyOwners = (_curveOwnerPool = curveOwnerPool)[_instanceId = instanceId] || (_curveOwnerPool[_instanceId] = Object.create(null));
+                var owner = (_propertyOwners = propertyOwners)[_property = property] || (_propertyOwners[_property] = curve._createCurveOwner(targetEntity));
+                //@todo: There is performance waste here, which will be handled together with organizing AnimatorStateData later. The logic is changing from runtime to initialization.
+                if (needRevert) {
+                    this._needRevertCurveOwners.push(owner);
+                } else {
+                    var index = this._needRevertCurveOwners.indexOf(owner);
+                    index > -1 && this._needRevertCurveOwners.splice(index, 1);
+                }
+                // Get layer owner
+                var layerPropertyOwners = (_layerCurveOwnerPool = layerCurveOwnerPool)[_instanceId1 = instanceId] || (_layerCurveOwnerPool[_instanceId1] = Object.create(null));
+                var layerOwner = (_layerPropertyOwners = layerPropertyOwners)[_property1 = property] || (_layerPropertyOwners[_property1] = curve._createCurveLayerOwner(owner));
+                curveLayerOwner[i] = layerOwner;
             } else {
-                curveOwners[i] = null;
+                curveLayerOwner[i] = null;
                 console.warn("The entity don't have the child entity which path is " + curve.relativePath + ".");
             }
         }
@@ -22951,65 +23185,60 @@ exports.AnimatorLayerBlendingMode = void 0;
     };
     _proto._clearCrossData = function _clearCrossData(animatorLayerData) {
         animatorLayerData.crossCurveMark++;
-        this._crossOwnerCollection.length = 0;
+        animatorLayerData.crossLayerOwnerCollection.length = 0;
     };
-    _proto._addCrossCurveData = function _addCrossCurveData(crossCurveData, owner, curCurveIndex, nextCurveIndex) {
-        owner.crossSrcCurveIndex = curCurveIndex;
-        owner.crossDestCurveIndex = nextCurveIndex;
-        crossCurveData.push(owner);
+    _proto._addCrossOwner = function _addCrossOwner(animatorLayerData, layerOwner, curCurveIndex, nextCurveIndex) {
+        layerOwner.crossSrcCurveIndex = curCurveIndex;
+        layerOwner.crossDestCurveIndex = nextCurveIndex;
+        animatorLayerData.crossLayerOwnerCollection.push(layerOwner);
     };
     _proto._prepareCrossFading = function _prepareCrossFading(animatorLayerData) {
-        var crossCurveData = this._crossOwnerCollection;
-        var crossCurveMark = animatorLayerData.crossCurveMark;
         // Add src cross curve data.
-        this._prepareSrcCrossData(crossCurveData, animatorLayerData.srcPlayData, crossCurveMark, false);
+        this._prepareSrcCrossData(animatorLayerData, false);
         // Add dest cross curve data.
-        this._prepareDestCrossData(crossCurveData, animatorLayerData.destPlayData, crossCurveMark, false);
+        this._prepareDestCrossData(animatorLayerData, false);
     };
     _proto._prepareStandbyCrossFading = function _prepareStandbyCrossFading(animatorLayerData) {
-        var crossOwnerCollection = this._crossOwnerCollection;
-        var srcPlayData = animatorLayerData.srcPlayData, crossCurveMark = animatorLayerData.crossCurveMark;
         // Standby have two sub state, one is never play, one is finished, never play srcPlayData.state is null.
-        srcPlayData.state && this._prepareSrcCrossData(crossOwnerCollection, srcPlayData, crossCurveMark, true);
+        animatorLayerData.srcPlayData.state && this._prepareSrcCrossData(animatorLayerData, true);
         // Add dest cross curve data.
-        this._prepareDestCrossData(crossOwnerCollection, animatorLayerData.destPlayData, crossCurveMark, true);
+        this._prepareDestCrossData(animatorLayerData, true);
     };
     _proto._prepareFixedPoseCrossFading = function _prepareFixedPoseCrossFading(animatorLayerData) {
-        var crossOwnerCollection = this._crossOwnerCollection;
+        var crossLayerOwnerCollection = animatorLayerData.crossLayerOwnerCollection;
         // Save current cross curve data owner fixed pose.
-        for(var i = crossOwnerCollection.length - 1; i >= 0; i--){
-            var item = crossOwnerCollection[i];
-            item.saveFixedPoseValue();
+        for(var i = crossLayerOwnerCollection.length - 1; i >= 0; i--){
+            var layerOwner = crossLayerOwnerCollection[i];
+            if (!layerOwner) continue;
+            layerOwner.curveOwner.saveFixedPoseValue();
             // Reset destCurveIndex When fixed pose crossFading again.
-            item.crossDestCurveIndex = -1;
+            layerOwner.crossDestCurveIndex = -1;
         }
         // prepare dest AnimatorState cross data.
-        this._prepareDestCrossData(crossOwnerCollection, animatorLayerData.destPlayData, animatorLayerData.crossCurveMark, true);
-    };
-    _proto._prepareSrcCrossData = function _prepareSrcCrossData(crossCurveData, srcPlayData, crossCurveMark, saveFixed) {
-        var curveOwners = srcPlayData.stateData.curveOwners;
-        for(var i = curveOwners.length - 1; i >= 0; i--){
-            var owner = curveOwners[i];
-            if (!owner) continue;
-            owner.crossCurveMark = crossCurveMark;
-            owner.crossCurveDataIndex = crossCurveData.length;
-            saveFixed && owner.saveFixedPoseValue();
-            this._addCrossCurveData(crossCurveData, owner, i, -1);
-        }
-    };
-    _proto._prepareDestCrossData = function _prepareDestCrossData(crossCurveData, destPlayData, crossCurveMark, saveFixed) {
-        var curveOwners = destPlayData.stateData.curveOwners;
-        for(var i = curveOwners.length - 1; i >= 0; i--){
-            var owner = curveOwners[i];
-            if (!owner) continue;
-            if (owner.crossCurveMark === crossCurveMark) {
-                crossCurveData[owner.crossCurveDataIndex].crossDestCurveIndex = i;
+        this._prepareDestCrossData(animatorLayerData, true);
+    };
+    _proto._prepareSrcCrossData = function _prepareSrcCrossData(animatorLayerData, saveFixed) {
+        var curveLayerOwner = animatorLayerData.srcPlayData.stateData.curveLayerOwner;
+        for(var i = curveLayerOwner.length - 1; i >= 0; i--){
+            var layerOwner = curveLayerOwner[i];
+            if (!layerOwner) continue;
+            layerOwner.crossCurveMark = animatorLayerData.crossCurveMark;
+            saveFixed && layerOwner.curveOwner.saveFixedPoseValue();
+            this._addCrossOwner(animatorLayerData, layerOwner, i, -1);
+        }
+    };
+    _proto._prepareDestCrossData = function _prepareDestCrossData(animatorLayerData, saveFixed) {
+        var curveLayerOwner = animatorLayerData.destPlayData.stateData.curveLayerOwner;
+        for(var i = curveLayerOwner.length - 1; i >= 0; i--){
+            var layerOwner = curveLayerOwner[i];
+            if (!layerOwner) continue;
+            if (layerOwner.crossCurveMark === animatorLayerData.crossCurveMark) {
+                layerOwner.crossDestCurveIndex = i;
             } else {
-                owner.saveDefaultValue();
+                var owner = layerOwner.curveOwner;
                 saveFixed && owner.saveFixedPoseValue();
-                owner.crossCurveMark = crossCurveMark;
-                owner.crossCurveDataIndex = crossCurveData.length;
-                this._addCrossCurveData(crossCurveData, owner, -1, i);
+                layerOwner.crossCurveMark = animatorLayerData.crossCurveMark;
+                this._addCrossOwner(animatorLayerData, layerOwner, -1, i);
             }
         }
     };
@@ -23024,7 +23253,7 @@ exports.AnimatorLayerBlendingMode = void 0;
         var srcPlayData = layerData.srcPlayData, destPlayData = layerData.destPlayData, crossFadeTransitionInfo = layerData.crossFadeTransition;
         var additive = blendingMode === exports.AnimatorLayerBlendingMode.Additive;
         firstLayer && (weight = 1.0);
-        //TODO: 任意情况都应该检查，后面要优化
+        //@todo: All situations should be checked, optimizations will follow later.
         layerData.layerState !== LayerState.FixedCrossFading && this._checkTransition(srcPlayData, crossFadeTransitionInfo, layerIndex);
         switch(layerData.layerState){
             case LayerState.Playing:
@@ -23036,26 +23265,36 @@ exports.AnimatorLayerBlendingMode = void 0;
             case LayerState.CrossFading:
                 this._updateCrossFade(srcPlayData, destPlayData, layerData, layerIndex, weight, deltaTime, additive, aniUpdate);
                 break;
+            case LayerState.Finished:
+                this._updateFinishedState(srcPlayData, weight, additive, aniUpdate);
+                break;
         }
     };
     _proto._updatePlayingState = function _updatePlayingState(playData, layerData, layerIndex, weight, delta, additive, aniUpdate) {
-        var _playData_stateData = playData.stateData, curveOwners = _playData_stateData.curveOwners, eventHandlers = _playData_stateData.eventHandlers;
+        var _playData_stateData = playData.stateData, curveLayerOwner = _playData_stateData.curveLayerOwner, eventHandlers = _playData_stateData.eventHandlers;
         var state = playData.state, lastPlayState = playData.playState, lastClipTime = playData.clipTime;
         var _state_clip = state.clip, curveBindings = _state_clip._curveBindings;
         playData.update(this.speed < 0);
-        if (!aniUpdate) {
-            return;
-        }
         var clipTime = playData.clipTime, playState = playData.playState;
-        eventHandlers.length && this._fireAnimationEvents(playData, eventHandlers, lastClipTime, clipTime);
-        for(var i = curveBindings.length - 1; i >= 0; i--){
-            var owner = curveOwners[i];
-            owner == null ? void 0 : owner.evaluateAndApplyValue(curveBindings[i].curve, clipTime, weight, additive);
+        var finished = playState === AnimatorStatePlayState.Finished;
+        if (aniUpdate || finished) {
+            for(var i = curveBindings.length - 1; i >= 0; i--){
+                var layerOwner = curveLayerOwner[i];
+                var owner = layerOwner == null ? void 0 : layerOwner.curveOwner;
+                if (!owner) continue;
+                var curve = curveBindings[i].curve;
+                if (curve.keys.length) {
+                    var value = owner.evaluateValue(curve, clipTime, additive);
+                    aniUpdate && owner.applyValue(value, weight, additive);
+                    finished && layerOwner.saveFinalValue();
+                }
+            }
         }
         playData.frameTime += state.speed * delta;
         if (playState === AnimatorStatePlayState.Finished) {
-            layerData.layerState = LayerState.Standby;
+            layerData.layerState = LayerState.Finished;
         }
+        eventHandlers.length && this._fireAnimationEvents(playData, eventHandlers, lastClipTime, clipTime);
         if (lastPlayState === AnimatorStatePlayState.UnStarted) {
             this._callAnimatorScriptOnEnter(state, layerIndex);
         }
@@ -23066,7 +23305,7 @@ exports.AnimatorLayerBlendingMode = void 0;
         }
     };
     _proto._updateCrossFade = function _updateCrossFade(srcPlayData, destPlayData, layerData, layerIndex, weight, delta, additive, aniUpdate) {
-        var _this = this, crossCurveDataCollection = _this._crossOwnerCollection;
+        var crossLayerOwnerCollection = layerData.crossLayerOwnerCollection;
         var _srcPlayData_state_clip = srcPlayData.state.clip, srcCurves = _srcPlayData_state_clip._curveBindings;
         var srcState = srcPlayData.state, srcStateData = srcPlayData.stateData, lastSrcPlayState = srcPlayData.playState;
         var srcEventHandlers = srcStateData.eventHandlers;
@@ -23075,18 +23314,27 @@ exports.AnimatorLayerBlendingMode = void 0;
         var _destState_clip = destState.clip, destCurves = _destState_clip._curveBindings;
         var lastSrcClipTime = srcPlayData.clipTime;
         var lastDestClipTime = destPlayData.clipTime;
-        var crossWeight = Math.abs(destPlayData.frameTime) / (destState._getDuration() * layerData.crossFadeTransition.duration);
-        crossWeight >= 1.0 && (crossWeight = 1.0);
+        var duration = destState._getDuration() * layerData.crossFadeTransition.duration;
+        var crossWeight = Math.abs(destPlayData.frameTime) / duration;
+        (crossWeight >= 1.0 || duration === 0) && (crossWeight = 1.0);
         srcPlayData.update(this.speed < 0);
         destPlayData.update(this.speed < 0);
-        var srcPlayState = srcPlayData.playState;
-        var destPlayState = destPlayData.playState;
-        this._updateCrossFadeData(layerData, crossWeight, delta, false);
-        if (!aniUpdate) {
-            return;
+        var srcClipTime = srcPlayData.clipTime, srcPlayState = srcPlayData.playState;
+        var destClipTime = destPlayData.clipTime, destPlayState = destPlayData.playState;
+        var finished = destPlayData.playState === AnimatorStatePlayState.Finished;
+        if (aniUpdate || finished) {
+            for(var i = crossLayerOwnerCollection.length - 1; i >= 0; i--){
+                var layerOwner = crossLayerOwnerCollection[i];
+                var owner = layerOwner == null ? void 0 : layerOwner.curveOwner;
+                if (!owner) continue;
+                var srcCurveIndex = layerOwner.crossSrcCurveIndex;
+                var destCurveIndex = layerOwner.crossDestCurveIndex;
+                var value = owner.evaluateCrossFadeValue(srcCurveIndex >= 0 ? srcCurves[srcCurveIndex].curve : null, destCurveIndex >= 0 ? destCurves[destCurveIndex].curve : null, srcClipTime, destClipTime, crossWeight, additive);
+                aniUpdate && owner.applyValue(value, weight, additive);
+                finished && layerOwner.saveFinalValue();
+            }
         }
-        var srcClipTime = srcPlayData.clipTime;
-        var destClipTime = destPlayData.clipTime;
+        this._updateCrossFadeData(layerData, crossWeight, delta, false);
         srcEventHandlers.length && this._fireAnimationEvents(srcPlayData, srcEventHandlers, lastSrcClipTime, srcClipTime);
         destEventHandlers.length && this._fireAnimationEvents(destPlayData, destEventHandlers, lastDestClipTime, destClipTime);
         if (lastSrcPlayState === AnimatorStatePlayState.UnStarted) {
@@ -23105,28 +23353,34 @@ exports.AnimatorLayerBlendingMode = void 0;
         } else {
             this._callAnimatorScriptOnUpdate(destState, layerIndex);
         }
-        for(var i = crossCurveDataCollection.length - 1; i >= 0; i--){
-            var crossCurveData = crossCurveDataCollection[i];
-            var crossSrcCurveIndex = crossCurveData.crossSrcCurveIndex, crossDestCurveIndex = crossCurveData.crossDestCurveIndex;
-            crossCurveData.crossFadeAndApplyValue(crossSrcCurveIndex >= 0 ? srcCurves[crossSrcCurveIndex].curve : null, crossDestCurveIndex >= 0 ? destCurves[crossDestCurveIndex].curve : null, srcClipTime, destClipTime, crossWeight, weight, additive);
-        }
     };
-    _proto._updateCrossFadeFromPose = function _updateCrossFadeFromPose(destPlayData, layerData, layerIndex, layerWeight, delta, additive, aniUpdate) {
-        var crossCurveDataCollection = this._crossOwnerCollection;
+    _proto._updateCrossFadeFromPose = function _updateCrossFadeFromPose(destPlayData, layerData, layerIndex, weight, delta, additive, aniUpdate) {
+        var crossLayerOwnerCollection = layerData.crossLayerOwnerCollection;
         var state = destPlayData.state, stateData = destPlayData.stateData, lastPlayState = destPlayData.playState;
         var eventHandlers = stateData.eventHandlers;
         var _state_clip = state.clip, curveBindings = _state_clip._curveBindings;
         var lastDestClipTime = destPlayData.clipTime;
-        var crossWeight = Math.abs(destPlayData.frameTime) / (state._getDuration() * layerData.crossFadeTransition.duration);
-        crossWeight >= 1.0 && (crossWeight = 1.0);
+        var duration = state._getDuration() * layerData.crossFadeTransition.duration;
+        var crossWeight = Math.abs(destPlayData.frameTime) / duration;
+        (crossWeight >= 1.0 || duration === 0) && (crossWeight = 1.0);
         destPlayData.update(this.speed < 0);
         var playState = destPlayData.playState;
         this._updateCrossFadeData(layerData, crossWeight, delta, true);
-        if (!aniUpdate) {
-            return;
-        }
         var destClipTime = destPlayData.clipTime;
-        //TODO: srcState 少了最新一段时间的判断
+        var finished = playState === AnimatorStatePlayState.Finished;
+        // When the animator is culled (aniUpdate=false), if the play state has finished, the final value needs to be calculated and saved to be applied directly.
+        if (aniUpdate || finished) {
+            for(var i = crossLayerOwnerCollection.length - 1; i >= 0; i--){
+                var layerOwner = crossLayerOwnerCollection[i];
+                var owner = layerOwner == null ? void 0 : layerOwner.curveOwner;
+                if (!owner) continue;
+                var curveIndex = layerOwner.crossDestCurveIndex;
+                var value = layerOwner.curveOwner.crossFadeFromPoseAndApplyValue(curveIndex >= 0 ? curveBindings[curveIndex].curve : null, destClipTime, crossWeight, additive);
+                aniUpdate && owner.applyValue(value, weight, additive);
+                finished && layerOwner.saveFinalValue();
+            }
+        }
+        //@todo: srcState is missing the judgment of the most recent period."
         eventHandlers.length && this._fireAnimationEvents(destPlayData, eventHandlers, lastDestClipTime, destClipTime);
         if (lastPlayState === AnimatorStatePlayState.UnStarted) {
             this._callAnimatorScriptOnEnter(state, layerIndex);
@@ -23136,10 +23390,18 @@ exports.AnimatorLayerBlendingMode = void 0;
         } else {
             this._callAnimatorScriptOnUpdate(state, layerIndex);
         }
-        for(var i = crossCurveDataCollection.length - 1; i >= 0; i--){
-            var crossCurveData = crossCurveDataCollection[i];
-            var crossDestCurveIndex = crossCurveData.crossDestCurveIndex;
-            crossCurveData.crossFadeFromPoseAndApplyValue(crossDestCurveIndex >= 0 ? curveBindings[crossDestCurveIndex].curve : null, destClipTime, crossWeight, layerWeight, additive);
+    };
+    _proto._updateFinishedState = function _updateFinishedState(playData, weight, additive, aniUpdate) {
+        if (!aniUpdate) {
+            return;
+        }
+        var curveLayerOwner = playData.stateData.curveLayerOwner;
+        var _playData_state_clip = playData.state.clip, curveBindings = _playData_state_clip._curveBindings;
+        for(var i = curveBindings.length - 1; i >= 0; i--){
+            var layerOwner = curveLayerOwner[i];
+            var owner = layerOwner == null ? void 0 : layerOwner.curveOwner;
+            if (!owner) continue;
+            owner.applyValue(layerOwner.finalValue, weight, additive);
         }
     };
     _proto._updateCrossFadeData = function _updateCrossFadeData(layerData, crossWeight, delta, fixed) {
@@ -23147,7 +23409,7 @@ exports.AnimatorLayerBlendingMode = void 0;
         destPlayData.frameTime += destPlayData.state.speed * delta;
         if (crossWeight === 1.0) {
             if (destPlayData.playState === AnimatorStatePlayState.Finished) {
-                layerData.layerState = LayerState.Standby;
+                layerData.layerState = LayerState.Finished;
             } else {
                 layerData.layerState = LayerState.Playing;
             }
@@ -23157,25 +23419,24 @@ exports.AnimatorLayerBlendingMode = void 0;
             fixed || (layerData.srcPlayData.frameTime += layerData.srcPlayData.state.speed * delta);
         }
     };
-    _proto._preparePlay = function _preparePlay(layerData, playState, playStateData) {
+    _proto._preparePlay = function _preparePlay(layerData, playState) {
         if (layerData.layerState === LayerState.Playing) {
             var srcPlayData = layerData.srcPlayData;
             if (srcPlayData.state !== playState) {
-                var curveOwners = srcPlayData.stateData.curveOwners;
-                for(var i = curveOwners.length - 1; i >= 0; i--){
-                    var owner = curveOwners[i];
-                    (owner == null ? void 0 : owner.hasSavedDefaultValue) && owner.revertDefaultValue();
+                var curveLayerOwner = srcPlayData.stateData.curveLayerOwner;
+                for(var i = curveLayerOwner.length - 1; i >= 0; i--){
+                    var _curveLayerOwner_i;
+                    var owner = (_curveLayerOwner_i = curveLayerOwner[i]) == null ? void 0 : _curveLayerOwner_i.curveOwner;
+                    owner.revertDefaultValue();
                 }
-                this._saveDefaultValues(playStateData);
             }
         } else {
-            // layerState is CrossFading, FixedCrossFading, Standby
-            var crossCurveDataCollection = this._crossOwnerCollection;
-            for(var i1 = crossCurveDataCollection.length - 1; i1 >= 0; i1--){
-                var owner1 = crossCurveDataCollection[i1];
-                owner1.hasSavedDefaultValue && owner1.revertDefaultValue();
+            // layerState is CrossFading, FixedCrossFading, Standby, Finished
+            var crossLayerOwnerCollection = layerData.crossLayerOwnerCollection;
+            for(var i1 = crossLayerOwnerCollection.length - 1; i1 >= 0; i1--){
+                var owner1 = crossLayerOwnerCollection[i1].curveOwner;
+                owner1.revertDefaultValue();
             }
-            this._saveDefaultValues(playStateData);
         }
     };
     _proto._checkTransition = function _checkTransition(stateData, crossFadeTransition, layerIndex) {
@@ -23192,7 +23453,7 @@ exports.AnimatorLayerBlendingMode = void 0;
     _proto._crossFadeByTransition = function _crossFadeByTransition(transition, layerIndex) {
         var name = transition.destinationState.name;
         var stateInfo = this._getAnimatorStateInfo(name, layerIndex);
-        var crossState = stateInfo.state;
+        var crossState = stateInfo.state, playLayerIndex = stateInfo.layerIndex;
         if (!crossState) {
             return;
         }
@@ -23200,21 +23461,21 @@ exports.AnimatorLayerBlendingMode = void 0;
             console.warn("The state named " + name + " has no AnimationClip data.");
             return;
         }
-        var animatorLayerData = this._getAnimatorLayerData(stateInfo.layerIndex);
+        var animatorLayerData = this._getAnimatorLayerData(playLayerIndex);
         var layerState = animatorLayerData.layerState;
         var destPlayData = animatorLayerData.destPlayData;
-        var animatorStateData = this._getAnimatorStateData(name, crossState, animatorLayerData);
+        var animatorStateData = this._getAnimatorStateData(name, crossState, animatorLayerData, playLayerIndex);
         var duration = crossState._getDuration();
         var offset = duration * transition.offset;
         destPlayData.reset(crossState, animatorStateData, offset);
         switch(layerState){
-            // Maybe not play, maybe end.
             case LayerState.Standby:
                 animatorLayerData.layerState = LayerState.FixedCrossFading;
                 this._clearCrossData(animatorLayerData);
                 this._prepareStandbyCrossFading(animatorLayerData);
                 break;
             case LayerState.Playing:
+            case LayerState.Finished:
                 animatorLayerData.layerState = LayerState.CrossFading;
                 this._clearCrossData(animatorLayerData);
                 this._prepareCrossFading(animatorLayerData);
@@ -23311,6 +23572,12 @@ exports.AnimatorLayerBlendingMode = void 0;
             }
         }
     };
+    _proto._revertCurveOwners = function _revertCurveOwners() {
+        var curveOwners = this._needRevertCurveOwners;
+        for(var i = 0, n = curveOwners.length; i < n; ++i){
+            curveOwners[i].revertDefaultValue();
+        }
+    };
     _create_class(Animator, [
         {
             key: "animatorController",
@@ -23342,10 +23609,10 @@ __decorate([
 ], Animator.prototype, "_animatorLayersData", void 0);
 __decorate([
     ignoreClone
-], Animator.prototype, "_crossOwnerCollection", void 0);
+], Animator.prototype, "_curveOwnerPool", void 0);
 __decorate([
     ignoreClone
-], Animator.prototype, "_animationCurveOwners", void 0);
+], Animator.prototype, "_needRevertCurveOwners", void 0);
 __decorate([
     ignoreClone
 ], Animator.prototype, "_animationEventHandlerPool", void 0);