sa2kit 1.0.6 → 1.0.8

package/dist/mmd/index.js

@@ -461,7 +461,18 @@ var MMDPlayerEnhanced = ({
       animationIdRef.current = requestAnimationFrame(animate);
       if (helperRef.current && isPlayingRef.current) {
         const delta = clockRef.current.getDelta();
-        helperRef.current.update(delta);
+        try {
+          helperRef.current.update(delta);
+        } catch (error2) {
+          if (error2.message && error2.message.includes("OOM")) {
+            console.error("\u274C \u7269\u7406\u5F15\u64CE\u5185\u5B58\u6EA2\u51FA\uFF0C\u505C\u6B62\u64AD\u653E");
+            isPlayingRef.current = false;
+            setIsPlaying(false);
+            onError?.(new Error("\u7269\u7406\u5F15\u64CE\u5185\u5B58\u6EA2\u51FA"));
+            return;
+          }
+          throw error2;
+        }
         if (!hasAudioRef.current && !loop && !animationEndedFiredRef.current) {
           const currentTime = clockRef.current.getElapsedTime();
           if (animationDurationRef.current > 0) {
@@ -516,7 +527,6 @@ var MMDPlayerEnhanced = ({
     };
   }, [stage]);
   const clearOldResources = () => {
-    console.log("\u{1F9F9} [MMDPlayerEnhanced] \u5F00\u59CB\u6E05\u9664\u65E7\u8D44\u6E90\uFF08\u589E\u5F3A\u6E05\u7406\uFF09");
     if (!sceneRef.current) return;
     if (isPlayingRef.current) {
       isPlayingRef.current = false;
@@ -526,58 +536,92 @@ var MMDPlayerEnhanced = ({
       audioRef.current.pause();
       audioRef.current.currentTime = 0;
       audioRef.current.onended = null;
+      audioRef.current.src = "";
+      audioRef.current.load();
       audioRef.current = null;
     }
     if (helperRef.current) {
-      console.log("\u{1F9F9} \u5F00\u59CB\u6E05\u7406 MMDAnimationHelper");
       try {
         helperRef.current.enable("animation", false);
         helperRef.current.enable("ik", false);
         helperRef.current.enable("grant", false);
         helperRef.current.enable("physics", false);
-        console.log("\u2705 \u5DF2\u505C\u7528\u6240\u6709 helper \u7CFB\u7EDF");
-      } catch (error2) {
-        console.warn("\u26A0\uFE0F \u505C\u7528 helper \u7CFB\u7EDF\u5931\u8D25:", error2);
-      }
-      try {
         const helperObjects = helperRef.current.objects;
         if (helperObjects && Array.isArray(helperObjects)) {
-          console.log(`\u{1F9F9} \u6E05\u9664 helper \u4E2D\u7684 ${helperObjects.length} \u4E2A\u5BF9\u8C61\uFF08\u5305\u62EC\u7269\u7406\u7CFB\u7EDF\uFF09`);
+          const physicsWorldsToDestroy = /* @__PURE__ */ new Set();
           helperObjects.forEach((obj) => {
             if (obj.physics) {
-              console.log("\u{1F527} \u6E05\u7406\u7269\u7406\u7CFB\u7EDF:", obj.mesh?.name || "unnamed");
               try {
-                if (obj.physics.reset) {
-                  obj.physics.reset();
+                const physics = obj.physics;
+                if (physics.world) {
+                  physicsWorldsToDestroy.add(physics.world);
+                }
+                if (physics.bodies && Array.isArray(physics.bodies)) {
+                  physics.bodies.forEach((body) => {
+                    if (physics.world && body) {
+                      try {
+                        physics.world.removeRigidBody(body);
+                        if (window.Ammo && body.destroy) {
+                          body.destroy();
+                        }
+                      } catch (e) {
+                      }
+                    }
+                  });
+                  physics.bodies.length = 0;
+                  physics.bodies = null;
                 }
-                if (obj.physics.world) {
-                  const world = obj.physics.world;
-                  while (world.getNumCollisionObjects() > 0) {
-                    const body = world.getCollisionObjectArray().at(0);
-                    world.removeCollisionObject(body);
-                  }
+                if (physics.constraints && Array.isArray(physics.constraints)) {
+                  physics.constraints.forEach((constraint) => {
+                    if (physics.world && constraint) {
+                      try {
+                        physics.world.removeConstraint(constraint);
+                        if (window.Ammo && constraint.destroy) {
+                          constraint.destroy();
+                        }
+                      } catch (e) {
+                      }
+                    }
+                  });
+                  physics.constraints.length = 0;
+                  physics.constraints = null;
                 }
+                if (physics.reset) physics.reset();
+                physics.world = null;
                 obj.physics = null;
-              } catch (physicsError) {
-                console.warn("\u26A0\uFE0F \u6E05\u7406\u7269\u7406\u7CFB\u7EDF\u5931\u8D25:", physicsError);
+              } catch (e) {
+                console.warn("\u6E05\u7406\u7269\u7406\u7CFB\u7EDF\u5931\u8D25:", e);
               }
             }
           });
+          physicsWorldsToDestroy.forEach((world) => {
+            try {
+              while (world.getNumCollisionObjects() > 0) {
+                const obj = world.getCollisionObjectArray().at(0);
+                world.removeCollisionObject(obj);
+                if (obj && obj.destroy) {
+                  obj.destroy();
+                }
+              }
+              if (world.destroy) {
+                world.destroy();
+              }
+            } catch (e) {
+              console.warn("\u9500\u6BC1\u7269\u7406\u4E16\u754C\u5931\u8D25:", e);
+            }
+          });
           helperObjects.length = 0;
         }
       } catch (error2) {
-        console.warn("\u26A0\uFE0F \u65E0\u6CD5\u8BBF\u95EE helper.objects:", error2);
+        console.warn("\u6E05\u7406 helper \u5931\u8D25:", error2);
       }
       helperRef.current = null;
-      console.log("\u2705 MMDAnimationHelper \u6E05\u7406\u5B8C\u6210");
     }
     if (sceneRef.current.background && sceneRef.current.background.isTexture) {
-      console.log("\u{1F9F9} \u6E05\u9664\u573A\u666F\u80CC\u666F\u8D34\u56FE");
       sceneRef.current.background.dispose();
       sceneRef.current.background = null;
     }
     if (sceneRef.current.environment && sceneRef.current.environment.isTexture) {
-      console.log("\u{1F9F9} \u6E05\u9664\u573A\u666F\u73AF\u5883\u8D34\u56FE");
       sceneRef.current.environment.dispose();
       sceneRef.current.environment = null;
     }
@@ -591,26 +635,28 @@ var MMDPlayerEnhanced = ({
       }
     });
     objectsToRemove.forEach((obj) => {
-      if (obj.parent) {
-        obj.parent.remove(obj);
-      }
+      if (obj.parent) obj.parent.remove(obj);
       if (obj.geometry) {
         obj.geometry.dispose();
       }
       if (obj.material) {
-        const material = obj.material;
         const disposeMaterial = (m) => {
-          if (m.map) m.map.dispose();
-          if (m.emissiveMap) m.emissiveMap.dispose();
-          if (m.normalMap) m.normalMap.dispose();
-          if (m.bumpMap) m.bumpMap.dispose();
-          if (m.specularMap) m.specularMap.dispose();
-          if (m.envMap) m.envMap.dispose();
-          if (m.lightMap) m.lightMap.dispose();
-          if (m.aoMap) m.aoMap.dispose();
-          if (m.alphaMap) m.alphaMap.dispose();
+          [
+            "map",
+            "emissiveMap",
+            "normalMap",
+            "bumpMap",
+            "specularMap",
+            "envMap",
+            "lightMap",
+            "aoMap",
+            "alphaMap"
+          ].forEach((prop) => {
+            if (m[prop]) m[prop].dispose();
+          });
           m.dispose();
         };
+        const material = obj.material;
         if (Array.isArray(material)) {
           material.forEach(disposeMaterial);
         } else {
@@ -618,29 +664,23 @@ var MMDPlayerEnhanced = ({
         }
       }
       if (obj.skeleton) {
-        console.log("\u{1F9F9} \u6E05\u7406\u9AA8\u9ABC\u6570\u636E");
         obj.skeleton = null;
       }
     });
     clockRef.current = new THREE2__namespace.Clock();
     vmdDataRef.current = null;
     setNeedReset(false);
-    console.log(`\u2705 [MMDPlayerEnhanced] \u5DF2\u6E05\u9664 ${objectsToRemove.length} \u4E2A\u5BF9\u8C61\uFF08\u589E\u5F3A\u6E05\u7406\u5B8C\u6210\uFF09`);
+    if (window.gc) {
+      try {
+        window.gc();
+      } catch (e) {
+      }
+    }
+    console.log(`\u2705 \u8D44\u6E90\u6E05\u7406\u5B8C\u6210 (${objectsToRemove.length} \u4E2A\u5BF9\u8C61)`);
   };
   React2.useEffect(() => {
-    console.log("\u{1F4E6} [MMDPlayerEnhanced] \u8D44\u6E90\u52A0\u8F7D useEffect \u89E6\u53D1");
-    console.log("\u{1F50D} [MMDPlayerEnhanced] sceneRef.current:", sceneRef.current);
-    console.log("\u{1F50D} [MMDPlayerEnhanced] cameraRef.current:", cameraRef.current);
-    console.log("\u{1F50D} [MMDPlayerEnhanced] isLoadedRef.current:", isLoadedRef.current);
-    if (!sceneRef.current || !cameraRef.current) {
-      console.warn("\u26A0\uFE0F [MMDPlayerEnhanced] \u573A\u666F\u6216\u76F8\u673A\u672A\u521D\u59CB\u5316\uFF0C\u8DF3\u8FC7\u8D44\u6E90\u52A0\u8F7D");
-      return;
-    }
-    if (isLoadedRef.current) {
-      console.log("\u26A0\uFE0F [MMDPlayerEnhanced] \u8D44\u6E90\u5DF2\u52A0\u8F7D\uFF0C\u8DF3\u8FC7\u91CD\u590D\u52A0\u8F7D");
-      return;
-    }
-    console.log("\u2705 [MMDPlayerEnhanced] \u573A\u666F\u548C\u76F8\u673A\u5DF2\u5C31\u7EEA\uFF0C\u5F00\u59CB\u52A0\u8F7D\u8D44\u6E90");
+    if (!sceneRef.current || !cameraRef.current) return;
+    if (isLoadedRef.current) return;
     clearOldResources();
     isLoadedRef.current = true;
     const loadMMD = async () => {
@@ -653,63 +693,39 @@ var MMDPlayerEnhanced = ({
         lastAnimationTimeRef.current = 0;
         animationStoppedCountRef.current = 0;
         if (stage?.enablePhysics !== false) {
-          const ammoScriptPath = stage?.ammoPath || "/mikutalking/libs/ammo.wasm.js";
-          const ammoWasmPath = stage?.ammoWasmPath || "/mikutalking/libs/";
-          console.log("\u{1F527} [MMDPlayerEnhanced] \u68C0\u6D4B\u5230\u542F\u7528\u7269\u7406\uFF0C\u5F00\u59CB\u52A0\u8F7D Ammo.js");
-          console.log("\u{1F4C2} [MMDPlayerEnhanced] Ammo \u811A\u672C\u8DEF\u5F84:", ammoScriptPath);
-          console.log("\u{1F4C2} [MMDPlayerEnhanced] Ammo WASM \u8DEF\u5F84:", ammoWasmPath);
           setLoadingProgress(5);
           await loadAmmo({
-            scriptPath: ammoScriptPath,
-            wasmBasePath: ammoWasmPath
+            scriptPath: stage?.ammoPath || "/mikutalking/libs/ammo.wasm.js",
+            wasmBasePath: stage?.ammoWasmPath || "/mikutalking/libs/"
           });
-          console.log("\u2705 [MMDPlayerEnhanced] Ammo.js \u52A0\u8F7D\u5B8C\u6210");
         }
         const manager = new THREE2__namespace.LoadingManager();
-        const modelUrl = currentResources.modelPath;
-        const basePath = modelUrl.substring(0, modelUrl.lastIndexOf("/") + 1);
-        console.log("\u{1F4C2} [MMDPlayerEnhanced] \u6A21\u578B\u57FA\u7840\u8DEF\u5F84:", basePath);
+        const basePath = currentResources.modelPath.substring(0, currentResources.modelPath.lastIndexOf("/") + 1);
         manager.setURLModifier((url) => {
-          if (url.startsWith("http://") || url.startsWith("https://")) {
-            console.log("\u{1F517} [MMDPlayerEnhanced] \u4F7F\u7528\u5B8C\u6574 URL:", url);
-            return url;
-          }
-          if (url.startsWith("/")) {
-            console.log("\u{1F517} [MMDPlayerEnhanced] \u4F7F\u7528\u7EDD\u5BF9\u8DEF\u5F84:", url);
-            return url;
-          }
-          const fullUrl = basePath + url;
-          console.log("\u{1F517} [MMDPlayerEnhanced] \u76F8\u5BF9\u8DEF\u5F84\u8F6C\u6362:", url, "->", fullUrl);
-          return fullUrl;
+          if (url.startsWith("http://") || url.startsWith("https://")) return url;
+          if (url.startsWith("/")) return url;
+          return basePath + url;
         });
         const loader = new threeStdlib.MMDLoader(manager);
         const helper = new threeStdlib.MMDAnimationHelper();
         helperRef.current = helper;
         setLoadingProgress(20);
         const modelStartTime = performance.now();
-        console.log("\u{1F3AD} \u5F00\u59CB\u52A0\u8F7D\u6A21\u578B:", currentResources.modelPath);
-        console.log("\u{1F4CA} [\u6027\u80FD] \u6A21\u578B\u52A0\u8F7D\u5F00\u59CB\u65F6\u95F4:", (/* @__PURE__ */ new Date()).toISOString());
         const mesh = await new Promise((resolve, reject) => {
           loader.load(
             currentResources.modelPath,
             (object) => {
-              const modelEndTime = performance.now();
-              const modelLoadTime = ((modelEndTime - modelStartTime) / 1e3).toFixed(2);
-              console.log(`\u2705 \u6A21\u578B\u52A0\u8F7D\u6210\u529F (\u8017\u65F6: ${modelLoadTime}\u79D2)`);
-              console.log(`\u{1F4CA} [\u6027\u80FD] \u6A21\u578B\u5927\u5C0F: ${object.geometry ? (object.geometry.attributes.position.count * 3 * 4 / 1024 / 1024).toFixed(2) : "N/A"} MB`);
+              const loadTime = ((performance.now() - modelStartTime) / 1e3).toFixed(2);
+              console.log(`\u2705 \u6A21\u578B\u52A0\u8F7D\u5B8C\u6210 (${loadTime}s)`);
               resolve(object);
             },
             (progress) => {
               if (progress.total > 0) {
-                const percent = progress.loaded / progress.total * 30 + 20;
-                setLoadingProgress(Math.min(percent, 50));
-                console.log(`\u{1F4E5} \u6A21\u578B\u52A0\u8F7D\u8FDB\u5EA6: ${(progress.loaded / progress.total * 100).toFixed(1)}% (${(progress.loaded / 1024 / 1024).toFixed(2)}MB / ${(progress.total / 1024 / 1024).toFixed(2)}MB)`);
+                setLoadingProgress(Math.min(progress.loaded / progress.total * 30 + 20, 50));
               }
             },
             (error2) => {
-              const modelEndTime = performance.now();
-              const modelLoadTime = ((modelEndTime - modelStartTime) / 1e3).toFixed(2);
-              console.error(`\u274C \u6A21\u578B\u52A0\u8F7D\u5931\u8D25 (\u8017\u65F6: ${modelLoadTime}\u79D2):`, error2);
+              console.error("\u274C \u6A21\u578B\u52A0\u8F7D\u5931\u8D25:", error2);
               reject(error2);
             }
           );
@@ -719,52 +735,21 @@ var MMDPlayerEnhanced = ({
         }
         sceneRef.current.add(mesh);
         if (currentResources.stageModelPath) {
-          console.log("\u{1F3F0} \u5F00\u59CB\u52A0\u8F7D\u573A\u666F\u6A21\u578B:", currentResources.stageModelPath);
           const stageMesh = await new Promise((resolve, reject) => {
-            loader.load(
-              currentResources.stageModelPath,
-              (object) => {
-                console.log("\u2705 \u573A\u666F\u6A21\u578B\u52A0\u8F7D\u6210\u529F");
-                resolve(object);
-              },
-              void 0,
-              (error2) => {
-                console.error("\u274C \u573A\u666F\u6A21\u578B\u52A0\u8F7D\u5931\u8D25:", error2);
-                reject(error2);
-              }
-            );
+            loader.load(currentResources.stageModelPath, resolve, void 0, reject);
           });
           sceneRef.current.add(stageMesh);
         }
         if (currentResources.backgroundPath && sceneRef.current) {
-          const bgStartTime = performance.now();
-          console.log("\u{1F5BC}\uFE0F \u5F00\u59CB\u52A0\u8F7D\u80CC\u666F\u56FE\u7247:", currentResources.backgroundPath);
           const textureLoader = new THREE2__namespace.TextureLoader();
           const backgroundTexture = await new Promise((resolve, reject) => {
-            textureLoader.load(
-              currentResources.backgroundPath,
-              (texture) => {
-                const bgEndTime = performance.now();
-                const bgLoadTime = ((bgEndTime - bgStartTime) / 1e3).toFixed(2);
-                console.log(`\u2705 \u80CC\u666F\u56FE\u7247\u52A0\u8F7D\u6210\u529F (\u8017\u65F6: ${bgLoadTime}\u79D2, \u5C3A\u5BF8: ${texture.image.width}x${texture.image.height})`);
-                resolve(texture);
-              },
-              void 0,
-              (err) => {
-                const bgEndTime = performance.now();
-                const bgLoadTime = ((bgEndTime - bgStartTime) / 1e3).toFixed(2);
-                console.error(`\u274C \u80CC\u666F\u56FE\u7247\u52A0\u8F7D\u5931\u8D25 (\u8017\u65F6: ${bgLoadTime}\u79D2):`, err);
-                reject(err);
-              }
-            );
+            textureLoader.load(currentResources.backgroundPath, resolve, void 0, reject);
           });
           backgroundTexture.colorSpace = THREE2__namespace.SRGBColorSpace;
           if (stage?.backgroundType === "skybox") {
             backgroundTexture.mapping = THREE2__namespace.EquirectangularReflectionMapping;
             sceneRef.current.background = backgroundTexture;
             sceneRef.current.environment = backgroundTexture;
-          } else if (stage?.backgroundType === "image") {
-            sceneRef.current.background = backgroundTexture;
           } else {
             sceneRef.current.background = backgroundTexture;
           }
@@ -773,31 +758,17 @@ var MMDPlayerEnhanced = ({
         let cameraVmd = null;
         if (currentResources.motionPath) {
           setLoadingProgress(60);
-          const motionStartTime = performance.now();
-          console.log("\u{1F483} \u5F00\u59CB\u52A0\u8F7D\u52A8\u4F5C:", currentResources.motionPath);
           vmd = await new Promise((resolve, reject) => {
             loader.loadAnimation(
               currentResources.motionPath,
               mesh,
-              (vmdObject) => {
-                const motionEndTime = performance.now();
-                const motionLoadTime = ((motionEndTime - motionStartTime) / 1e3).toFixed(2);
-                console.log(`\u2705 \u52A8\u4F5C\u52A0\u8F7D\u6210\u529F (\u8017\u65F6: ${motionLoadTime}\u79D2)`);
-                resolve(vmdObject);
-              },
+              resolve,
               (progress) => {
                 if (progress.total > 0) {
-                  const percent = progress.loaded / progress.total * 20 + 60;
-                  setLoadingProgress(Math.min(percent, 80));
-                  console.log(`\u{1F4E5} \u52A8\u4F5C\u52A0\u8F7D\u8FDB\u5EA6: ${(progress.loaded / progress.total * 100).toFixed(1)}%`);
+                  setLoadingProgress(Math.min(progress.loaded / progress.total * 20 + 60, 80));
                 }
               },
-              (error2) => {
-                const motionEndTime = performance.now();
-                const motionLoadTime = ((motionEndTime - motionStartTime) / 1e3).toFixed(2);
-                console.error(`\u274C \u52A8\u4F5C\u52A0\u8F7D\u5931\u8D25 (\u8017\u65F6: ${motionLoadTime}\u79D2):`, error2);
-                reject(error2);
-              }
+              reject
             );
           });
           helper.add(mesh, {
@@ -815,10 +786,6 @@ var MMDPlayerEnhanced = ({
             }
             if (maxDuration > 0) {
               animationDurationRef.current = maxDuration;
-              console.log("\u23F1\uFE0F \u52A8\u753B\u65F6\u957F:", maxDuration, "\u79D2");
-            } else {
-              console.warn("\u26A0\uFE0F \u65E0\u6CD5\u83B7\u53D6\u52A8\u753B\u65F6\u957F\uFF0C\u5C06\u65E0\u6CD5\u81EA\u52A8\u68C0\u6D4B\u52A8\u753B\u7ED3\u675F");
-              console.log("\u{1F4CB} VMD \u6570\u636E\u7ED3\u6784:", vmd);
             }
           }
         } else {
@@ -826,38 +793,18 @@ var MMDPlayerEnhanced = ({
         }
         if (currentResources.cameraPath && cameraRef.current) {
           setLoadingProgress(80);
-          console.log("\u{1F4F7} \u5F00\u59CB\u52A0\u8F7D\u955C\u5934:", currentResources.cameraPath);
           cameraVmd = await new Promise((resolve, reject) => {
-            loader.loadAnimation(
-              currentResources.cameraPath,
-              cameraRef.current,
-              (vmdObject) => {
-                console.log("\u2705 \u955C\u5934\u52A0\u8F7D\u6210\u529F");
-                resolve(vmdObject);
-              },
-              void 0,
-              (error2) => {
-                console.error("\u274C \u955C\u5934\u52A0\u8F7D\u5931\u8D25:", error2);
-                reject(error2);
-              }
-            );
+            loader.loadAnimation(currentResources.cameraPath, cameraRef.current, resolve, void 0, reject);
           });
           helper.add(cameraRef.current, { animation: cameraVmd });
         }
         if (currentResources.audioPath) {
           setLoadingProgress(90);
-          const audioStartTime = performance.now();
-          console.log("\u{1F3B5} \u5F00\u59CB\u52A0\u8F7D\u97F3\u9891:", currentResources.audioPath);
           const audio = new Audio(currentResources.audioPath);
           audio.volume = 0.5;
           audio.loop = loop;
           audioRef.current = audio;
           hasAudioRef.current = true;
-          audio.onloadedmetadata = () => {
-            const audioEndTime = performance.now();
-            const audioLoadTime = ((audioEndTime - audioStartTime) / 1e3).toFixed(2);
-            console.log(`\u2705 \u97F3\u9891\u52A0\u8F7D\u6210\u529F (\u8017\u65F6: ${audioLoadTime}\u79D2, \u65F6\u957F: ${audio.duration.toFixed(2)}\u79D2)`);
-          };
           audio.onended = () => {
             if (!loop) {
               setIsPlaying(false);
@@ -875,12 +822,7 @@ var MMDPlayerEnhanced = ({
         }
         setLoadingProgress(100);
         setLoading(false);
-        vmdDataRef.current = {
-          mesh,
-          vmd,
-          cameraVmd
-        };
-        console.log("\u{1F389} \u6240\u6709\u8D44\u6E90\u52A0\u8F7D\u5B8C\u6210\uFF01");
+        vmdDataRef.current = { mesh, vmd, cameraVmd };
         if (shouldAutoPlayAfterReloadRef.current) {
           shouldAutoPlayAfterReloadRef.current = false;
           setTimeout(() => play(), 500);
@@ -899,64 +841,49 @@ var MMDPlayerEnhanced = ({
     loadMMD();
   }, [currentResources, stage?.enablePhysics, autoPlay, loop, onLoad, onError, reloadTrigger]);
   const play = () => {
-    console.log("\u{1F3AC} [play] \u51FD\u6570\u88AB\u8C03\u7528\uFF0CneedReset =", needReset);
     if (!helperRef.current && !needReset) return;
     if (needReset && vmdDataRef.current && sceneRef.current && cameraRef.current) {
-      console.log("\u{1F504} \u68C0\u6D4B\u5230\u9700\u8981\u91CD\u7F6E\uFF0C\u91CD\u65B0\u521D\u59CB\u5316 helper\uFF08\u4FDD\u7559\u6A21\u578B\uFF09");
       const { mesh, vmd, cameraVmd } = vmdDataRef.current;
       if (helperRef.current) {
         try {
           const helperObjects = helperRef.current.objects;
           if (helperObjects && Array.isArray(helperObjects)) {
             helperObjects.length = 0;
-            console.log("\u{1F9F9} \u6E05\u7A7A\u4E86\u65E7 helper \u7684 objects \u6570\u7EC4");
           }
         } catch (error2) {
-          console.warn("\u26A0\uFE0F \u65E0\u6CD5\u6E05\u7A7A\u65E7 helper.objects:", error2);
         }
       }
       const newHelper = new threeStdlib.MMDAnimationHelper();
       helperRef.current = newHelper;
       clockRef.current = new THREE2__namespace.Clock();
       if (vmd && typeof vmd === "object") {
-        console.log("\u{1F4E6} \u91CD\u65B0\u6DFB\u52A0\u6A21\u578B\u52A8\u753B");
         try {
           newHelper.add(mesh, {
             animation: vmd,
             physics: stage?.enablePhysics !== false
           });
-          console.log("\u2705 \u6A21\u578B\u52A8\u753B\u6DFB\u52A0\u6210\u529F");
         } catch (error2) {
-          console.error("\u274C \u91CD\u65B0\u6DFB\u52A0\u6A21\u578B\u52A8\u753B\u5931\u8D25:", error2);
           try {
             newHelper.add(mesh, { physics: stage?.enablePhysics !== false });
-            console.log("\u2705 \u4EC5\u6DFB\u52A0\u6A21\u578B\u548C\u7269\u7406\uFF08\u65E0\u52A8\u753B\uFF09");
           } catch (innerError) {
-            console.error("\u274C \u6DFB\u52A0\u6A21\u578B\u4E5F\u5931\u8D25\u4E86:", innerError);
           }
         }
       } else {
         try {
           newHelper.add(mesh, { physics: stage?.enablePhysics !== false });
-          console.log("\u2705 \u4EC5\u6DFB\u52A0\u6A21\u578B\u548C\u7269\u7406\uFF08\u65E0\u52A8\u753B\u6570\u636E\uFF09");
         } catch (error2) {
-          console.error("\u274C \u6DFB\u52A0\u6A21\u578B\u5931\u8D25:", error2);
         }
       }
       if (cameraVmd && typeof cameraVmd === "object") {
-        console.log("\u{1F4F7} \u91CD\u65B0\u6DFB\u52A0\u76F8\u673A\u52A8\u753B");
         try {
           newHelper.add(cameraRef.current, { animation: cameraVmd });
-          console.log("\u2705 \u76F8\u673A\u52A8\u753B\u6DFB\u52A0\u6210\u529F");
         } catch (error2) {
-          console.error("\u274C \u91CD\u65B0\u6DFB\u52A0\u76F8\u673A\u52A8\u753B\u5931\u8D25:", error2);
         }
       }
       if (audioRef.current) {
         audioRef.current.currentTime = 0;
       }
       setNeedReset(false);
-      console.log("\u2705 Helper \u91CD\u65B0\u521D\u59CB\u5316\u5B8C\u6210\uFF0C\u51C6\u5907\u4ECE\u7B2C\u4E00\u5E27\u64AD\u653E");
     }
     if (!helperRef.current) {
       console.error("\u274C [play] helper \u4E0D\u5B58\u5728\uFF0C\u65E0\u6CD5\u64AD\u653E");