diff --git a/packages/core/src/mesh/BlendShapeManager.ts b/packages/core/src/mesh/BlendShapeManager.ts
index 512a0fe04a..1ebff4a339 100644
--- a/packages/core/src/mesh/BlendShapeManager.ts
+++ b/packages/core/src/mesh/BlendShapeManager.ts
@@ -11,7 +11,6 @@ import { ListenerUpdateFlag } from "../ListenerUpdateFlag";
 import { Shader } from "../shader/Shader";
 import { ShaderData } from "../shader/ShaderData";
 import { Texture2DArray, TextureFilterMode, TextureFormat } from "../texture";
-import { UpdateFlagManager } from "../UpdateFlagManager";
 import { BlendShape } from "./BlendShape";
 import { ModelMesh } from "./ModelMesh";
 import { SkinnedMeshRenderer } from "./SkinnedMeshRenderer";
@@ -45,8 +44,6 @@ export class BlendShapeManager {
   _vertexBuffers: Buffer[] = [];
   /** @internal */
   _vertices: Float32Array;
-  /** @internal */
-  _blendShapeCountChangeManager: UpdateFlagManager = new UpdateFlagManager();
 
   private _useBlendNormal: boolean = false;
   private _useBlendTangent: boolean = false;
@@ -78,8 +75,6 @@ export class BlendShapeManager {
     this._updateLayoutChange(blendShape);
 
     this._subDataDirtyFlags.push(blendShape._createSubDataDirtyFlag());
-
-    this._blendShapeCountChangeManager.dispatch();
   }
 
   /**
@@ -98,8 +93,6 @@ export class BlendShapeManager {
       subDataDirtyFlags[i].destroy();
     }
     subDataDirtyFlags.length = 0;
-
-    this._blendShapeCountChangeManager.dispatch();
   }
 
   /**
@@ -113,7 +106,7 @@ export class BlendShapeManager {
         shaderData.enableMacro(BlendShapeManager._blendShapeTextureMacro);
         shaderData.setTexture(BlendShapeManager._blendShapeTextureProperty, this._vertexTexture);
         shaderData.setVector3(BlendShapeManager._blendShapeTextureInfoProperty, this._dataTextureInfo);
-        shaderData.setFloatArray(BlendShapeManager._blendShapeWeightsProperty, skinnedMeshRenderer._blendShapeWeights);
+        shaderData.setFloatArray(BlendShapeManager._blendShapeWeightsProperty, skinnedMeshRenderer.blendShapeWeights);
       } else {
         const maxBlendCount = this._getVertexBufferModeSupportCount();
         if (blendShapeCount > maxBlendCount) {
@@ -122,14 +115,14 @@ export class BlendShapeManager {
             condensedBlendShapeWeights = new Float32Array(maxBlendCount);
             skinnedMeshRenderer._condensedBlendShapeWeights = condensedBlendShapeWeights;
           }
-          this._filterCondensedBlendShapeWeights(skinnedMeshRenderer._blendShapeWeights, condensedBlendShapeWeights);
+          this._filterCondensedBlendShapeWeights(skinnedMeshRenderer.blendShapeWeights, condensedBlendShapeWeights);
           shaderData.setFloatArray(BlendShapeManager._blendShapeWeightsProperty, condensedBlendShapeWeights);
           this._modelMesh._enableVAO = false;
           blendShapeCount = maxBlendCount;
         } else {
           shaderData.setFloatArray(
             BlendShapeManager._blendShapeWeightsProperty,
-            skinnedMeshRenderer._blendShapeWeights
+            skinnedMeshRenderer.blendShapeWeights
           );
           this._modelMesh._enableVAO = true;
         }
diff --git a/packages/core/src/mesh/SkinnedMeshRenderer.ts b/packages/core/src/mesh/SkinnedMeshRenderer.ts
index 3d99f0732e..0db2cf9e27 100644
--- a/packages/core/src/mesh/SkinnedMeshRenderer.ts
+++ b/packages/core/src/mesh/SkinnedMeshRenderer.ts
@@ -1,6 +1,5 @@
 import { Matrix } from "@oasis-engine/math";
 import { Logger } from "../base/Logger";
-import { BoolUpdateFlag } from "../BoolUpdateFlag";
 import { ignoreClone } from "../clone/CloneManager";
 import { Entity } from "../Entity";
 import { RenderContext } from "../RenderPipeline/RenderContext";
@@ -37,11 +36,8 @@ export class SkinnedMeshRenderer extends MeshRenderer {
   /** Whether to use joint texture. Automatically used when the device can't support the maximum number of bones. */
   private _useJointTexture: boolean = false;
   private _skin: Skin;
-  private _blendShapeCountChangeFlag: BoolUpdateFlag = new BoolUpdateFlag();
-
-  /** @internal */
   @ignoreClone
-  _blendShapeWeights: Float32Array = new Float32Array(0);
+  private _blendShapeWeights: Float32Array;
 
   /** @internal */
   @ignoreClone
@@ -52,15 +48,12 @@ export class SkinnedMeshRenderer extends MeshRenderer {
    * @remarks Array index is BlendShape index.
    */
   get blendShapeWeights(): Float32Array {
-    if (this._blendShapeCountChangeFlag.flag) {
-      this._resetBlendShapeWeights(<ModelMesh>this._mesh);
-      this._blendShapeCountChangeFlag.flag = false;
-    }
-
+    this._checkBlendShapeWeightLength();
     return this._blendShapeWeights;
   }
 
   set blendShapeWeights(value: Float32Array) {
+    this._checkBlendShapeWeightLength();
     const blendShapeWeights = this._blendShapeWeights;
     if (value.length <= blendShapeWeights.length) {
       blendShapeWeights.set(value);
@@ -208,37 +201,32 @@ export class SkinnedMeshRenderer extends MeshRenderer {
     this.jointTexture.setPixelBuffer(this.matrixPalette);
   }
 
-  /**
-   * @override
-   * @internal
-   */
-  _setMesh(mesh: ModelMesh): void {
-    const lastMesh = this._mesh;
-    super._setMesh(mesh);
-
-    if (lastMesh) {
-      this._blendShapeCountChangeFlag.clearFromManagers();
-    }
-    if (mesh) {
-      mesh._blendShapeManager._blendShapeCountChangeManager.addFlag(this._blendShapeCountChangeFlag);
-    }
-    this._resetBlendShapeWeights(mesh);
-  }
-
   /**
    * @internal
    */
   _cloneTo(target: SkinnedMeshRenderer): void {
     super._cloneTo(target);
-    target.blendShapeWeights = this._blendShapeWeights.slice();
+    target._blendShapeWeights = this._blendShapeWeights.slice();
   }
 
-  private _resetBlendShapeWeights(mesh: ModelMesh): void {
-    const blendShapeCount = mesh ? mesh.blendShapeCount : 0;
-    if (this._blendShapeWeights && this._blendShapeWeights.length !== blendShapeCount) {
-      this._blendShapeWeights = new Float32Array(blendShapeCount);
+  private _checkBlendShapeWeightLength(): void {
+    const mesh = <ModelMesh>this._mesh;
+    const newBlendShapeCount = mesh ? mesh.blendShapeCount : 0;
+    const lastBlendShapeWeights = this._blendShapeWeights;
+    if (lastBlendShapeWeights) {
+      if (lastBlendShapeWeights.length !== newBlendShapeCount) {
+        const newBlendShapeWeights = new Float32Array(newBlendShapeCount);
+        if (newBlendShapeCount > lastBlendShapeWeights.length) {
+          newBlendShapeWeights.set(lastBlendShapeWeights);
+        } else {
+          for (let i = 0, n = lastBlendShapeWeights.length; i < n; i++) {
+            lastBlendShapeWeights[i] = newBlendShapeWeights[i];
+          }
+        }
+        this._blendShapeWeights = newBlendShapeWeights;
+      }
     } else {
-      this._blendShapeWeights.fill(0);
+      this._blendShapeWeights = new Float32Array(newBlendShapeCount);
     }
   }
 }