@galacean/engine 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/browser.js

@@ -5642,6 +5642,13 @@
         TextureFormat[TextureFormat[/** 16-bit depth + 8-bit stencil format. */ "Depth24Stencil8"] = 30] = "Depth24Stencil8";
         TextureFormat[TextureFormat[/** 32-bit depth + 8-bit stencil format. */ "Depth32Stencil8"] = 31] = "Depth32Stencil8";
     })(exports.TextureFormat || (exports.TextureFormat = {}));
+    /**
+     * Texture usage.
+     */ exports.TextureUsage = void 0;
+    (function(TextureUsage) {
+        TextureUsage[TextureUsage[/** The content of the texture is intended to be specified once.  */ "Static"] = 0] = "Static";
+        TextureUsage[TextureUsage[/** The content of the texture is intended to be updated frequently, with better performance. */ "Dynamic"] = 1] = "Dynamic";
+    })(exports.TextureUsage || (exports.TextureUsage = {}));
     /**
      * Wrapping mode of the texture.
      */ exports.TextureWrapMode = void 0;
@@ -5779,6 +5786,14 @@
                     return this._height;
                 }
             },
+            {
+                key: "usage",
+                get: /**
+       * The usage of the texture.
+       */ function get() {
+                    return this._usage;
+                }
+            },
             {
                 key: "wrapModeU",
                 get: /**
@@ -6019,14 +6034,16 @@
     /**
      * Two-dimensional texture.
      */ var Texture2D = /*#__PURE__*/ function(Texture) {
-        var Texture2D = function Texture2D(engine, width, height, format, mipmap) {
+        var Texture2D = function Texture2D(engine, width, height, format, mipmap, usage) {
             if (format === void 0) format = exports.TextureFormat.R8G8B8A8;
             if (mipmap === void 0) mipmap = true;
+            if (usage === void 0) usage = exports.TextureUsage.Static;
             var _this;
             _this = Texture.call(this, engine) || this;
             _this._mipmap = mipmap;
             _this._width = width;
             _this._height = height;
+            _this._usage = usage;
             _this._format = format;
             _this._mipmapCount = _this._getMipmapCount();
             _this._isDepthTexture = format == exports.TextureFormat.Depth || format == exports.TextureFormat.DepthStencil || format == exports.TextureFormat.Depth16 || format == exports.TextureFormat.Depth24 || format == exports.TextureFormat.Depth32 || format == exports.TextureFormat.Depth24Stencil8 || format == exports.TextureFormat.Depth32Stencil8;
@@ -7116,29 +7133,7 @@
        * @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._meshRenderDataPool.garbageCollection();
-            engine._spriteRenderDataPool.garbageCollection();
-            engine._spriteMaskRenderDataPool.garbageCollection();
-            engine._textRenderDataPool.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();
+            this.engine._pendingGC();
         };
         /**
        * Add content restorer.
@@ -8056,6 +8051,17 @@
             componentContainer.length = 0;
             this._componentsContainerPool.push(componentContainer);
         };
+        /**
+       * @internal
+       */ _proto._gc = function _gc() {
+            this._renderers.garbageCollection();
+            this._onStartScripts.garbageCollection();
+            this._onUpdateScripts.garbageCollection();
+            this._onLateUpdateScripts.garbageCollection();
+            this._onPhysicsUpdateScripts.garbageCollection();
+            this._onUpdateAnimations.garbageCollection();
+            this._onUpdateRenderers.garbageCollection();
+        };
         return ComponentsManager;
     }();
     /**
@@ -10665,6 +10671,11 @@
                 elements[i]._onLateUpdate();
             }
         };
+        /**
+       * @internal
+       */ _proto._gc = function _gc() {
+            this._colliders.garbageCollection();
+        };
         _proto._setGravity = function _setGravity() {
             this._nativePhysicsManager.setGravity(this._gravity);
         };
@@ -13209,6 +13220,13 @@
                 shaderData.disableMacro("SCENE_SPOT_LIGHT_COUNT");
             }
         };
+        /**
+       * @internal
+       */ _proto._gc = function _gc() {
+            this._spotLights.garbageCollection();
+            this._pointLights.garbageCollection();
+            this._directLights.garbageCollection();
+        };
         return LightManager;
     }();
     /**
@@ -21485,6 +21503,7 @@
             _this._frameInProcess = false;
             _this._waitingDestroy = false;
             _this._isDeviceLost = false;
+            _this._waitingGC = false;
             _this._animate = function() {
                 if (_this._vSyncCount) {
                     _this._requestId = requestAnimationFrame(_this._animate);
@@ -21588,6 +21607,10 @@
             if (this._waitingDestroy) {
                 this._destroy();
             }
+            if (this._waitingGC) {
+                this._gc();
+                this._waitingGC = false;
+            }
             this._frameInProcess = false;
         };
         /**
@@ -21746,6 +21769,15 @@
         };
         /**
        * @internal
+       */ _proto._pendingGC = function _pendingGC() {
+            if (this._frameInProcess) {
+                this._waitingGC = true;
+            } else {
+                this._gc();
+            }
+        };
+        /**
+       * @internal
        */ _proto._initialize = function _initialize(configuration) {
             var _this = this;
             var physics = configuration.physics;
@@ -21808,6 +21840,16 @@
                 console.error(error);
             });
         };
+        _proto._gc = function _gc() {
+            this._renderElementPool.garbageCollection();
+            this._meshRenderDataPool.garbageCollection();
+            this._spriteRenderDataPool.garbageCollection();
+            this._spriteMaskRenderDataPool.garbageCollection();
+            this._textRenderDataPool.garbageCollection();
+            this._componentsManager._gc();
+            this._lightManager._gc();
+            this.physicsManager._gc();
+        };
         _create_class$3(Engine, [
             {
                 key: "settings",
@@ -27187,7 +27229,6 @@
      * @internal
      */ var AnimationCurveOwner = /*#__PURE__*/ function() {
         function AnimationCurveOwner(target, type, property, cureType) {
-            this.hasSavedDefaultValue = false;
             this.baseEvaluateData = {
                 curKeyframeIndex: 0,
                 value: null
@@ -27200,7 +27241,7 @@
             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);
@@ -27209,89 +27250,80 @@
             }
         }
         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) {
@@ -27382,9 +27414,24 @@
     AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights", BlendShapeWeightsAnimationCurveOwnerAssembler);
     /**
      * @internal
-     */ var AnimationCurveLayerOwner = function AnimationCurveLayerOwner() {
-        this.crossCurveMark = 0;
-    };
+     */ var AnimationCurveLayerOwner = /*#__PURE__*/ function() {
+        var AnimationCurveLayerOwner = 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() {
@@ -27398,13 +27445,18 @@
             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();
             layerOwner.curveOwner = owner;
+            curveType._initializeLayerOwner(layerOwner);
+            // 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;
         };
         /**
@@ -27489,7 +27541,8 @@
                 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);
                 }
             }
         };
@@ -27631,6 +27684,7 @@
                         break;
                 }
             }
+            evaluateData.value = value;
             return value;
         };
         /**
@@ -27686,6 +27740,11 @@
         };
         /**
        * @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];
@@ -27775,6 +27834,11 @@
         };
         /**
        * @internal
+       */ AnimationBoolCurve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+            owner.finalValue = false;
+        };
+        /**
+       * @internal
        */ AnimationBoolCurve._lerpValue = function _lerpValue(srcValue, destValue) {
             return destValue;
         };
@@ -27831,6 +27895,11 @@
         };
         /**
        * @internal
+       */ AnimationColorCurve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+            owner.finalValue = new Color$1();
+        };
+        /**
+       * @internal
        */ AnimationColorCurve._lerpValue = function _lerpValue(srcValue, destValue, weight, out) {
             Color$1.lerp(srcValue, destValue, weight, out);
             return out;
@@ -27936,6 +28005,12 @@
         };
         /**
        * @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];
@@ -28025,6 +28100,11 @@
         };
         /**
        * @internal
+       */ AnimationFloatCurve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+            owner.finalValue = 0;
+        };
+        /**
+       * @internal
        */ AnimationFloatCurve._lerpValue = function _lerpValue(srcValue, destValue, crossWeight) {
             return srcValue + (destValue - srcValue) * crossWeight;
         };
@@ -28093,6 +28173,11 @@
         };
         /**
        * @internal
+       */ AnimationQuaternionCurve1._initializeLayerOwner = function _initializeLayerOwner(owner) {
+            owner.finalValue = new Quaternion();
+        };
+        /**
+       * @internal
        */ AnimationQuaternionCurve1._lerpValue = function _lerpValue(src, dest, weight, out) {
             Quaternion.slerp(src, dest, weight, out);
             return out;
@@ -28196,6 +28281,11 @@
         };
         /**
        * @internal
+       */ AnimationVector2Curve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+            owner.finalValue = new Vector2();
+        };
+        /**
+       * @internal
        */ AnimationVector2Curve._lerpValue = function _lerpValue(srcValue, destValue, weight, out) {
             Vector2.lerp(srcValue, destValue, weight, out);
             return out;
@@ -28280,6 +28370,11 @@
         };
         /**
        * @internal
+       */ AnimationVector3Curve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+            owner.finalValue = new Vector3();
+        };
+        /**
+       * @internal
        */ AnimationVector3Curve._lerpValue = function _lerpValue(srcValue, destValue, weight, out) {
             Vector3.lerp(srcValue, destValue, weight, out);
             return out;
@@ -28376,6 +28471,11 @@
         };
         /**
        * @internal
+       */ AnimationVector4Curve._initializeLayerOwner = function _initializeLayerOwner(owner) {
+            owner.finalValue = new Vector4();
+        };
+        /**
+       * @internal
        */ AnimationVector4Curve._lerpValue = function _lerpValue(srcValue, destValue, weight, out) {
             Vector4.lerp(srcValue, destValue, weight, out);
             return out;
@@ -28481,6 +28581,7 @@
         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
@@ -28552,7 +28653,7 @@
             this.layerState = LayerState.Standby;
             this.crossCurveMark = 0;
             this.manuallyTransition = new AnimatorStateTransition();
-            this.crossOwnerLayerDataCollection = [];
+            this.crossLayerOwnerCollection = [];
         };
         var _proto = AnimatorLayerData.prototype;
         _proto.switchPlayData = function switchPlayData() {
@@ -28579,6 +28680,7 @@
             /** The playback speed of the Animator, 1.0 is normal playback speed. */ _this.speed = 1.0;
             _this._animatorLayersData = [];
             _this._curveOwnerPool = Object.create(null);
+            _this._needRevertCurveOwners = [];
             _this._animationEventHandlerPool = new ClassPool(AnimationEventHandler);
             _this._tempAnimatorStateInfo = {
                 layerIndex: -1,
@@ -28602,7 +28704,7 @@
                 this._reset();
             }
             var stateInfo = this._getAnimatorStateInfo(stateName, layerIndex);
-            var state = stateInfo.state;
+            var state = stateInfo.state, playLayerIndex = stateInfo.layerIndex;
             if (!state) {
                 return;
             }
@@ -28611,8 +28713,8 @@
                 return;
             }
             var animatorLayerData = this._getAnimatorLayerData(stateInfo.layerIndex);
-            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);
         };
@@ -28663,6 +28765,7 @@
                 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) {
@@ -28706,10 +28809,11 @@
                 var propertyOwners = animationCurveOwners[instanceId];
                 for(var property in propertyOwners){
                     var owner = propertyOwners[property];
-                    owner.hasSavedDefaultValue && owner.revertDefaultValue();
+                    owner.revertDefaultValue();
                 }
             }
             this._animatorLayersData.length = 0;
+            this._needRevertCurveOwners.length = 0;
             this._curveOwnerPool = {};
             this._animationEventHandlerPool.resetPool();
             if (this._controllerUpdateFlag) {
@@ -28737,25 +28841,18 @@
             stateInfo.state = state;
             return stateInfo;
         };
-        _proto._saveDefaultValues = function _saveDefaultValues(stateData) {
-            var curveLayerOwner = stateData.curveLayerOwner;
-            for(var i = curveLayerOwner.length - 1; i >= 0; i--){
-                var _curveLayerOwner_i;
-                (_curveLayerOwner_i = curveLayerOwner[i]) == null ? void 0 : _curveLayerOwner_i.curveOwner.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, animatorLayerData);
+                this._saveAnimatorStateData(animatorState, animatorStateData, animatorLayerData, layerIndex);
                 this._saveAnimatorEventHandlers(animatorState, animatorStateData);
             }
             return animatorStateData;
         };
-        _proto._saveAnimatorStateData = function _saveAnimatorStateData(animatorState, animatorStateData, animatorLayerData) {
+        _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;
@@ -28767,9 +28864,22 @@
                     var _curveOwnerPool, _instanceId, _propertyOwners, _property, _layerCurveOwnerPool, _instanceId1, _layerPropertyOwners, _property1;
                     var property = curve.property;
                     var instanceId = targetEntity.instanceId;
+                    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));
@@ -28803,12 +28913,12 @@
         };
         _proto._clearCrossData = function _clearCrossData(animatorLayerData) {
             animatorLayerData.crossCurveMark++;
-            animatorLayerData.crossOwnerLayerDataCollection.length = 0;
+            animatorLayerData.crossLayerOwnerCollection.length = 0;
         };
         _proto._addCrossOwner = function _addCrossOwner(animatorLayerData, layerOwner, curCurveIndex, nextCurveIndex) {
             layerOwner.crossSrcCurveIndex = curCurveIndex;
             layerOwner.crossDestCurveIndex = nextCurveIndex;
-            animatorLayerData.crossOwnerLayerDataCollection.push(layerOwner);
+            animatorLayerData.crossLayerOwnerCollection.push(layerOwner);
         };
         _proto._prepareCrossFading = function _prepareCrossFading(animatorLayerData) {
             // Add src cross curve data.
@@ -28823,10 +28933,10 @@
             this._prepareDestCrossData(animatorLayerData, true);
         };
         _proto._prepareFixedPoseCrossFading = function _prepareFixedPoseCrossFading(animatorLayerData) {
-            var crossOwnerLayerDataCollection = animatorLayerData.crossOwnerLayerDataCollection;
+            var crossLayerOwnerCollection = animatorLayerData.crossLayerOwnerCollection;
             // Save current cross curve data owner fixed pose.
-            for(var i = crossOwnerLayerDataCollection.length - 1; i >= 0; i--){
-                var layerOwner = crossOwnerLayerDataCollection[i];
+            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.
@@ -28854,7 +28964,6 @@
                     layerOwner.crossDestCurveIndex = i;
                 } else {
                     var owner = layerOwner.curveOwner;
-                    owner.saveDefaultValue();
                     saveFixed && owner.saveFixedPoseValue();
                     layerOwner.crossCurveMark = animatorLayerData.crossCurveMark;
                     this._addCrossOwner(animatorLayerData, layerOwner, -1, i);
@@ -28872,7 +28981,7 @@
             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:
@@ -28884,6 +28993,9 @@
                 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) {
@@ -28891,19 +29003,26 @@
             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 _curveLayerOwner_i;
-                (_curveLayerOwner_i = curveLayerOwner[i]) == null ? void 0 : _curveLayerOwner_i.curveOwner.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);
             }
@@ -28914,7 +29033,7 @@
             }
         };
         _proto._updateCrossFade = function _updateCrossFade(srcPlayData, destPlayData, layerData, layerIndex, weight, delta, additive, aniUpdate) {
-            var crossOwnerLayerDataCollection = layerData.crossOwnerLayerDataCollection;
+            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;
@@ -28923,18 +29042,27 @@
             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) {
@@ -28953,30 +29081,34 @@
             } else {
                 this._callAnimatorScriptOnUpdate(destState, layerIndex);
             }
-            for(var i = crossOwnerLayerDataCollection.length - 1; i >= 0; i--){
-                var layerOwner = crossOwnerLayerDataCollection[i];
-                if (!layerOwner) continue;
-                var srcCurveIndex = layerOwner.crossSrcCurveIndex;
-                var destCurveIndex = layerOwner.crossDestCurveIndex;
-                layerOwner.curveOwner.crossFadeAndApplyValue(srcCurveIndex >= 0 ? srcCurves[srcCurveIndex].curve : null, destCurveIndex >= 0 ? destCurves[destCurveIndex].curve : null, srcClipTime, destClipTime, crossWeight, weight, additive);
-            }
         };
-        _proto._updateCrossFadeFromPose = function _updateCrossFadeFromPose(destPlayData, layerData, layerIndex, layerWeight, delta, additive, aniUpdate) {
-            var crossOwnerLayerDataCollection = layerData.crossOwnerLayerDataCollection;
+        _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);
@@ -28986,11 +29118,18 @@
             } else {
                 this._callAnimatorScriptOnUpdate(state, layerIndex);
             }
-            for(var i = crossOwnerLayerDataCollection.length - 1; i >= 0; i--){
-                var layerOwner = crossOwnerLayerDataCollection[i];
-                if (!layerOwner) continue;
-                var curveIndex = layerOwner.crossDestCurveIndex;
-                layerOwner.curveOwner.crossFadeFromPoseAndApplyValue(curveIndex >= 0 ? curveBindings[curveIndex].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) {
@@ -28998,7 +29137,7 @@
             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;
                 }
@@ -29008,7 +29147,7 @@
                 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) {
@@ -29016,18 +29155,16 @@
                     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 == null ? void 0 : owner.hasSavedDefaultValue) && owner.revertDefaultValue();
+                        owner.revertDefaultValue();
                     }
-                    this._saveDefaultValues(playStateData);
                 }
             } else {
-                // layerState is CrossFading, FixedCrossFading, Standby
-                var crossOwnerLayerDataCollection = layerData.crossOwnerLayerDataCollection;
-                for(var i1 = crossOwnerLayerDataCollection.length - 1; i1 >= 0; i1--){
-                    var owner1 = crossOwnerLayerDataCollection[i1].curveOwner;
-                    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) {
@@ -29044,7 +29181,7 @@
         _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;
             }
@@ -29052,21 +29189,21 @@
                 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);
@@ -29163,6 +29300,12 @@
                 }
             }
         };
+        _proto._revertCurveOwners = function _revertCurveOwners() {
+            var curveOwners = this._needRevertCurveOwners;
+            for(var i = 0, n = curveOwners.length; i < n; ++i){
+                curveOwners[i].revertDefaultValue();
+            }
+        };
         _create_class$3(Animator, [
             {
                 key: "animatorController",
@@ -29195,6 +29338,9 @@
     __decorate$1([
         ignoreClone
     ], Animator.prototype, "_curveOwnerPool", void 0);
+    __decorate$1([
+        ignoreClone
+    ], Animator.prototype, "_needRevertCurveOwners", void 0);
     __decorate$1([
         ignoreClone
     ], Animator.prototype, "_animationEventHandlerPool", void 0);
@@ -31062,6 +31208,7 @@
         get TextureDepthCompareFunction () { return exports.TextureDepthCompareFunction; },
         get TextureFilterMode () { return exports.TextureFilterMode; },
         get TextureFormat () { return exports.TextureFormat; },
+        get TextureUsage () { return exports.TextureUsage; },
         get TextureWrapMode () { return exports.TextureWrapMode; },
         Time: Time,
         TrailMaterial: TrailMaterial,
@@ -31829,9 +31976,9 @@
             var isWebGL2 = this._isWebGL2;
             var _this__formatDetail = this._formatDetail, internalFormat = _this__formatDetail.internalFormat, baseFormat = _this__formatDetail.baseFormat, dataType = _this__formatDetail.dataType;
             // @ts-ignore
-            var _this__texture = this._texture, mipmapCount = _this__texture.mipmapCount, width = _this__texture.width, height = _this__texture.height, _isDepthTexture = _this__texture._isDepthTexture;
+            var _this__texture = this._texture, mipmapCount = _this__texture.mipmapCount, width = _this__texture.width, height = _this__texture.height, usage = _this__texture.usage, _isDepthTexture = _this__texture._isDepthTexture;
             this._bind();
-            if (isWebGL2 && !(baseFormat === gl.LUMINANCE_ALPHA || baseFormat === gl.ALPHA)) {
+            if (isWebGL2 && !(baseFormat === gl.LUMINANCE_ALPHA || baseFormat === gl.ALPHA) && usage !== exports.TextureUsage.Dynamic) {
                 gl.texStorage2D(this._target, mipmapCount, internalFormat, width, height);
             } else {
                 if (!isCube) {
@@ -32623,11 +32770,15 @@
        * {@inheritDoc IPlatformTexture2D.setImageSource}
        */ _proto.setImageSource = function setImageSource(imageSource, mipLevel, flipY, premultiplyAlpha, x, y) {
             var gl = this._gl;
-            var _this__formatDetail = this._formatDetail, baseFormat = _this__formatDetail.baseFormat, dataType = _this__formatDetail.dataType;
+            var _this__formatDetail = this._formatDetail, internalFormat = _this__formatDetail.internalFormat, baseFormat = _this__formatDetail.baseFormat, dataType = _this__formatDetail.dataType;
             this._bind();
             gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, +flipY);
             gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, +premultiplyAlpha);
-            gl.texSubImage2D(this._target, mipLevel, x || 0, y || 0, baseFormat, dataType, imageSource);
+            if (this._texture.usage === exports.TextureUsage.Dynamic) {
+                gl.texImage2D(this._target, mipLevel, internalFormat, baseFormat, dataType, imageSource);
+            } else {
+                gl.texSubImage2D(this._target, mipLevel, x || 0, y || 0, baseFormat, dataType, imageSource);
+            }
         };
         /**
        * {@inheritDoc IPlatformTexture2D.getPixelBuffer }
@@ -38156,7 +38307,7 @@
     ], GALACEAN_animation_event);
 
     //@ts-ignore
-    var version = "1.0.0-beta.11";
+    var version = "1.0.0-beta.13";
     console.log("Galacean engine version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);