修复

src/babylonjs/AppModel.ts

@@ -1,10 +1,12 @@
-import { ImportMeshAsync } from '@babylonjs/core/Loading/sceneLoader';
+import { ImportMeshAsync, ISceneLoaderProgressEvent } from '@babylonjs/core/Loading/sceneLoader';
 import '@babylonjs/loaders/glTF';
 import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
 import { Scene } from '@babylonjs/core/scene';
+import { ActionManager, ExecuteCodeAction } from '@babylonjs/core/Actions';
 import { Monobehiver } from '../base/Monobehiver';
 import { Dictionary } from '../utils/Dictionary';
 import { AppConfig } from './AppConfig';
+import { EventBridge } from '../event/bridge';
 
 type LoadResult = {
     success: boolean;
@@ -44,10 +46,45 @@ export class AppModel extends Monobehiver {
         if (!AppConfig.modelUrlList?.length || this.isLoading) return;
         this.isLoading = true;
         try {
-            for (const url of AppConfig.modelUrlList) {
-                await this.loadSingleModel(url);
+            const total = AppConfig.modelUrlList.length;
+            EventBridge.modelLoadProgress({ loaded: 0, total, urls: AppConfig.modelUrlList, progress: 0, percentage: 0 });
+            for (let i = 0; i < AppConfig.modelUrlList.length; i++) {
+                const url = AppConfig.modelUrlList[i];
+                const handleProgress = (event: ISceneLoaderProgressEvent): void => {
+                    const currentProgress = event.lengthComputable && event.total > 0
+                        ? Math.min(1, event.loaded / event.total)
+                        : 0;
+                    const overallProgress = Math.min(1, (i + currentProgress) / total);
+                    EventBridge.modelLoadProgress({
+                        loaded: i + currentProgress,
+                        total,
+                        url,
+                        progress: overallProgress,
+                        percentage: Number((overallProgress * 100).toFixed(2)),
+                        detail: {
+                            url,
+                            lengthComputable: event.lengthComputable,
+                            loadedBytes: event.loaded,
+                            totalBytes: event.total
+                        }
+                    });
+                };
+
+                const result = await this.loadSingleModel(url, handleProgress);
+                const overallProgress = Math.min(1, (i + 1) / total);
+                EventBridge.modelLoadProgress({
+                    loaded: i + 1,
+                    total,
+                    url,
+                    success: result.success,
+                    progress: overallProgress,
+                    percentage: Number((overallProgress * 100).toFixed(2))
+                });
+                if (!result.success) {
+                    EventBridge.modelLoadError({ url, error: result.error });
+                }
             }
-         
+            EventBridge.modelLoaded({ urls: AppConfig.modelUrlList });
         } finally {
             this.isLoading = false;
         }
@@ -57,7 +94,7 @@ export class AppModel extends Monobehiver {
      * 加载单个模型
      * @param modelUrl 模型URL
      */
-    async loadSingleModel(modelUrl: string): Promise<LoadResult> {
+    async loadSingleModel(modelUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void): Promise<LoadResult> {
         try {
             const cached = this.getCachedMeshes(modelUrl);
             if (cached) return { success: true, meshes: cached };
@@ -65,16 +102,11 @@ export class AppModel extends Monobehiver {
             const scene: Scene | null = this.mainApp.appScene.object;
             if (!scene) return { success: false, error: '场景未初始化' };
 
-            // ImportMeshAsync的签名与当前调用不完全一致，使用any规避编译报错
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const result: any = await (ImportMeshAsync as any)(modelUrl, scene);
+            const result = await ImportMeshAsync(modelUrl, scene, { onProgress });
             if (!result?.meshes?.length) return { success: false, error: '未找到网格' };
 
             this.modelDic.Set(modelUrl, result.meshes);
             this.loadedMeshes.push(...result.meshes);
-
-            this.setupShadows(result.meshes as AbstractMesh[]);
-
             return { success: true, meshes: result.meshes, skeletons: result.skeletons };
         } catch (e: any) {
             console.error(`模型加载失败: ${modelUrl}`, e);
@@ -116,4 +148,5 @@ export class AppModel extends Monobehiver {
         this.isLoading = false;
         this.skeletonMerged = false;
     }
+
 }