feat: 纹理路径稳定 ID 与架构改进 (#305)

* feat(asset-system): 实现路径稳定 ID 生成器

使用 FNV-1a hash 算法为纹理生成稳定的运行时 ID：
- 新增 _pathIdCache 静态缓存，跨 Play/Stop 循环保持稳定
- 新增 getStableIdForPath() 方法，相同路径永远返回相同 ID
- 修改 loadTextureForComponent/loadTextureByGuid 使用稳定 ID
- clearTextureMappings() 不再清除 _pathIdCache

这解决了 Play/Stop 后纹理 ID 失效的根本问题。

* fix(runtime-core): 移除 Play/Stop 循环中的 clearTextureMappings 调用

使用路径稳定 ID 后，不再需要在快照保存/恢复时清除纹理缓存：
- saveSceneSnapshot() 移除 clearTextureMappings() 调用
- restoreSceneSnapshot() 移除 clearTextureMappings() 调用
- 组件保存的 textureId 在 Play/Stop 后仍然有效

* fix(editor-core): 修复场景切换时的资源泄漏

在 openScene() 加载新场景前先卸载旧场景资源：
- 调用 sceneResourceManager.unloadSceneResources() 释放旧资源
- 使用引用计数机制，仅卸载不再被引用的资源
- 路径稳定 ID 缓存不受影响，保持 ID 稳定性

* fix(runtime-core): 修复 PluginManager 组件注册类型错误

将 ComponentRegistry 类改为 GlobalComponentRegistry 实例：
- registerComponents() 期望 IComponentRegistry 接口实例
- GlobalComponentRegistry 是 ComponentRegistry 的全局实例

* refactor(core): 提取 IComponentRegistry 接口

将组件注册表抽象为接口，支持场景级组件注册：
- 新增 IComponentRegistry 接口定义
- Scene 持有独立的 componentRegistry 实例
- 支持从 GlobalComponentRegistry 克隆
- 各系统支持传入自定义注册表

* refactor(engine-core): 改进插件服务注册机制

- 更新 IComponentRegistry 类型引用
- 优化 PluginServiceRegistry 服务管理

* refactor(modules): 适配新的组件注册接口

更新各模块 RuntimeModule 使用 IComponentRegistry 接口：
- audio, behavior-tree, camera
- sprite, tilemap, world-streaming

* fix(physics-rapier2d): 修复物理插件组件注册

- PhysicsEditorPlugin 添加 runtimeModule 引用
- 适配 IComponentRegistry 接口
- 修复物理组件在场景加载时未注册的问题

* feat(editor-core): 添加 UserCodeService 就绪信号机制

- 新增 waitForReady()/signalReady() API
- 支持等待用户脚本编译完成
- 解决场景加载时组件未注册的时序问题

* fix(editor-app): 在编译完成后调用 signalReady()

确保用户脚本编译完成后发出就绪信号：
- 编译成功后调用 userCodeService.signalReady()
- 编译失败也要发出信号，避免阻塞场景加载

* feat(editor-core): 改进编辑器核心服务

- EntityStoreService 添加调试日志
- AssetRegistryService 优化资产注册
- PluginManager 改进插件管理
- IFileAPI 添加 getFileMtime 接口

* feat(engine): 改进 Rust 纹理管理器

- 支持任意 ID 的纹理加载（非递增）
- 添加纹理状态追踪 API
- 优化纹理缓存清理机制
- 更新 TypeScript 绑定

* feat(ui): 添加场景切换和文本闪烁组件

新增组件：
- SceneLoadTriggerComponent: 场景切换触发器
- TextBlinkComponent: 文本闪烁效果

新增系统：
- SceneLoadTriggerSystem: 处理场景切换逻辑
- TextBlinkSystem: 处理文本闪烁动画

其他改进：
- UIRuntimeModule 适配新组件注册接口
- UI 渲染系统优化

* feat(editor-app): 添加外部文件修改检测

- 新增 ExternalModificationDialog 组件
- TauriFileAPI 支持 getFileMtime
- 场景文件被外部修改时提示用户

* feat(editor-app): 添加渲染调试面板

- 新增 RenderDebugService 和调试面板 UI
- App/ContentBrowser 添加调试日志
- TitleBar/Viewport 优化
- DialogManager 改进

* refactor(editor-app): 编辑器服务和组件优化

- EngineService 改进引擎集成
- EditorEngineSync 同步优化
- AssetFileInspector 改进
- VectorFieldEditors 优化
- InstantiatePrefabCommand 改进

* feat(i18n): 更新国际化翻译

- 添加新功能相关翻译
- 更新中文、英文、西班牙文

* feat(tauri): 添加文件修改时间查询命令

- 新增 get_file_mtime 命令
- 支持检测文件外部修改

* refactor(particle): 粒子系统改进

- 适配新的组件注册接口
- ParticleSystem 优化
- 添加单元测试

* refactor(platform): 平台适配层优化

- BrowserRuntime 改进
- 新增 RuntimeSceneManager 服务
- 导出优化

* refactor(asset-system-editor): 资产元数据改进

- AssetMetaFile 优化
- 导出调整

* fix(asset-system): 移除未使用的 TextureLoader 导入

* fix(tests): 更新测试以使用 GlobalComponentRegistry 实例

修复多个测试文件以适配 ComponentRegistry 从静态类变为实例类的变更：
- ComponentStorage.test.ts: 使用 GlobalComponentRegistry.reset()
- EntitySerializer.test.ts: 使用 GlobalComponentRegistry 实例
- IncrementalSerialization.test.ts: 使用 GlobalComponentRegistry 实例
- SceneSerializer.test.ts: 使用 GlobalComponentRegistry 实例
- ComponentRegistry.extended.test.ts: 使用 GlobalComponentRegistry，同时注册到 scene.componentRegistry
- SystemTypes.test.ts: 在 Scene 创建前注册组件
- QuerySystem.test.ts: mockScene 添加 componentRegistry

packages/editor-app/src/App.tsx

@@ -40,11 +40,15 @@ import { Inspector } from './components/inspectors/Inspector';
 import { AssetBrowser } from './components/AssetBrowser';
 import { Viewport } from './components/Viewport';
 import { AdvancedProfilerWindow } from './components/AdvancedProfilerWindow';
+import { RenderDebugPanel } from './components/debug/RenderDebugPanel';
+import { emit, emitTo, listen } from '@tauri-apps/api/event';
+import { renderDebugService } from './services/RenderDebugService';
 import { PortManager } from './components/PortManager';
 import { SettingsWindow } from './components/SettingsWindow';
 import { AboutDialog } from './components/AboutDialog';
 import { ErrorDialog } from './components/ErrorDialog';
 import { ConfirmDialog } from './components/ConfirmDialog';
+import { ExternalModificationDialog } from './components/ExternalModificationDialog';
 import { PluginGeneratorWindow } from './components/PluginGeneratorWindow';
 import { BuildSettingsWindow } from './components/BuildSettingsWindow';
 import { ForumPanel } from './components/forum';
@@ -63,6 +67,7 @@ import { useLocale } from './hooks/useLocale';
 import { useStoreSubscriptions } from './hooks/useStoreSubscriptions';
 import { en, zh, es } from './locales';
 import type { Locale } from '@esengine/editor-core';
+import { UserCodeService } from '@esengine/editor-core';
 import { Loader2 } from 'lucide-react';
 import './styles/App.css';
 
@@ -84,12 +89,24 @@ Core.services.registerInstance(ICompilerRegistry, compilerRegistryInstance);
 
 const logger = createLogger('App');
 
+// 检查是否为独立窗口模式 | Check if standalone window mode
+const isFrameDebuggerMode = new URLSearchParams(window.location.search).get('mode') === 'frame-debugger';
+
 function App() {
     const initRef = useRef(false);
     const layoutContainerRef = useRef<FlexLayoutDockContainerHandle>(null);
     const [pluginLoader] = useState(() => new PluginLoader());
     const { showToast, hideToast } = useToast();
 
+    // 如果是独立调试窗口模式，只渲染调试面板 | If standalone debugger mode, only render debug panel
+    if (isFrameDebuggerMode) {
+        return (
+            <div style={{ width: '100vw', height: '100vh', overflow: 'hidden' }}>
+                <RenderDebugPanel visible={true} onClose={() => window.close()} standalone />
+            </div>
+        );
+    }
+
     // ===== 本地初始化状态（只用于初始化阶段）| Local init state (only for initialization) =====
     const [initialized, setInitialized] = useState(false);
 
@@ -170,10 +187,40 @@ function App() {
         showAbout, setShowAbout,
         showPluginGenerator, setShowPluginGenerator,
         showBuildSettings, setShowBuildSettings,
+        showRenderDebug, setShowRenderDebug,
         errorDialog, setErrorDialog,
-        confirmDialog, setConfirmDialog
+        confirmDialog, setConfirmDialog,
+        externalModificationDialog, setExternalModificationDialog
     } = useDialogStore();
 
+    // 全局监听独立调试窗口的数据请求 | Global listener for standalone debug window requests
+    useEffect(() => {
+        let broadcastInterval: ReturnType<typeof setInterval> | null = null;
+
+        const unlistenPromise = listen('render-debug-request-data', () => {
+            // 开始定时广播数据 | Start broadcasting data periodically
+            if (!broadcastInterval) {
+                const broadcast = () => {
+                    renderDebugService.setEnabled(true);
+                    const snap = renderDebugService.collectSnapshot();
+                    if (snap) {
+                        // 使用 emitTo 发送到独立窗口 | Use emitTo to send to standalone window
+                        emitTo('frame-debugger', 'render-debug-snapshot', snap).catch(() => {});
+                    }
+                };
+                broadcast(); // 立即广播一次 | Broadcast immediately
+                broadcastInterval = setInterval(broadcast, 500);
+            }
+        });
+
+        return () => {
+            unlistenPromise.then(unlisten => unlisten());
+            if (broadcastInterval) {
+                clearInterval(broadcastInterval);
+            }
+        };
+    }, []);
+
     useEffect(() => {
         // 禁用默认右键菜单
         const handleContextMenu = (e: MouseEvent) => {
@@ -483,6 +530,113 @@ function App() {
         };
     }, [initialized]);
 
+    // Handle external scene file changes
+    // 处理外部场景文件变更
+    useEffect(() => {
+        if (!initialized || !messageHubRef.current || !sceneManagerRef.current) return;
+        const hub = messageHubRef.current;
+        const sm = sceneManagerRef.current;
+
+        const unsubscribe = hub.subscribe('scene:external-change', (data: {
+            path: string;
+            sceneName: string;
+        }) => {
+            logger.info('Scene externally modified:', data.path);
+
+            // Show confirmation dialog to reload the scene
+            // 显示确认对话框以重新加载场景
+            setConfirmDialog({
+                title: t('scene.externalChange.title'),
+                message: t('scene.externalChange.message', { name: data.sceneName }),
+                confirmText: t('scene.externalChange.reload'),
+                cancelText: t('scene.externalChange.ignore'),
+                onConfirm: async () => {
+                    setConfirmDialog(null);
+                    try {
+                        await sm.openScene(data.path);
+                        showToast(t('scene.reloadedSuccess', { name: data.sceneName }), 'success');
+                    } catch (error) {
+                        console.error('Failed to reload scene:', error);
+                        showToast(t('scene.reloadFailed'), 'error');
+                    }
+                },
+                onCancel: () => {
+                    // User chose to ignore, do nothing
+                    // 用户选择忽略，不做任何操作
+                }
+            });
+        });
+
+        return () => unsubscribe?.();
+    }, [initialized, t, showToast]);
+
+    // Handle external modification when saving scene
+    // 处理保存场景时的外部修改检测
+    useEffect(() => {
+        if (!initialized || !messageHubRef.current || !sceneManagerRef.current) return;
+        const hub = messageHubRef.current;
+        const sm = sceneManagerRef.current;
+
+        const unsubscribe = hub.subscribe('scene:externalModification', (data: {
+            path: string;
+            sceneName: string;
+        }) => {
+            logger.info('Scene file externally modified during save:', data.path);
+
+            // Show external modification dialog with three options
+            // 显示外部修改对话框，提供三个选项
+            setExternalModificationDialog({
+                sceneName: data.sceneName,
+                onReload: async () => {
+                    setExternalModificationDialog(null);
+                    try {
+                        await sm.reloadScene();
+                        showToast(t('scene.reloadedSuccess', { name: data.sceneName }), 'success');
+                    } catch (error) {
+                        console.error('Failed to reload scene:', error);
+                        showToast(t('scene.reloadFailed'), 'error');
+                    }
+                },
+                onOverwrite: async () => {
+                    setExternalModificationDialog(null);
+                    try {
+                        await sm.saveScene(true); // Force save, overwriting external changes
+                        showToast(t('scene.savedSuccess', { name: data.sceneName }), 'success');
+                    } catch (error) {
+                        console.error('Failed to save scene:', error);
+                        showToast(t('scene.saveFailed'), 'error');
+                    }
+                }
+            });
+        });
+
+        return () => unsubscribe?.();
+    }, [initialized, t, showToast, setExternalModificationDialog]);
+
+    // Handle user code compilation results
+    // 处理用户代码编译结果
+    useEffect(() => {
+        if (!initialized || !messageHubRef.current) return;
+        const hub = messageHubRef.current;
+
+        const unsubscribe = hub.subscribe('usercode:compilation-result', (data: {
+            success: boolean;
+            exports: string[];
+            errors: string[];
+        }) => {
+            if (data.success) {
+                if (data.exports.length > 0) {
+                    showToast(t('usercode.compileSuccess', { count: data.exports.length }), 'success');
+                }
+            } else {
+                const errorMsg = data.errors[0] ?? t('usercode.compileError');
+                showToast(errorMsg, 'error');
+            }
+        });
+
+        return () => unsubscribe?.();
+    }, [initialized, t, showToast]);
+
     const handleOpenRecentProject = async (projectPath: string) => {
         try {
             setIsLoading(true, t('loading.step1'));
@@ -523,7 +677,6 @@ function App() {
                 const sceneFiles = await TauriAPI.scanDirectory(`${projectPath}/scenes`, '*.ecs');
                 const sceneNames = sceneFiles.map(f => `scenes/${f.split(/[\\/]/).pop()}`);
                 setAvailableScenes(sceneNames);
-                console.log('[App] Found scenes:', sceneNames);
             } catch (e) {
                 console.warn('[App] Failed to scan scenes:', e);
             }
@@ -545,12 +698,8 @@ function App() {
             // Load project plugin config and activate plugins (after engine init, before module system init)
             if (pluginManagerRef.current) {
                 const pluginSettings = projectService.getPluginSettings();
-                console.log('[App] Plugin settings from project:', pluginSettings);
                 if (pluginSettings && pluginSettings.enabledPlugins.length > 0) {
-                    console.log('[App] Loading plugin config:', pluginSettings.enabledPlugins);
                     await pluginManagerRef.current.loadConfig({ enabledPlugins: pluginSettings.enabledPlugins });
-                } else {
-                    console.log('[App] No plugin settings found in project config');
                 }
             }
 
@@ -566,6 +715,13 @@ function App() {
 
             setIsLoading(true, t('loading.step3'));
 
+            // Wait for user code to be compiled and registered before loading scenes
+            // 等待用户代码编译和注册完成后再加载场景
+            const userCodeService = Core.services.tryResolve(UserCodeService);
+            if (userCodeService) {
+                await userCodeService.waitForReady();
+            }
+
             const sceneManagerService = Core.services.resolve(SceneManagerService);
             if (sceneManagerService) {
                 await sceneManagerService.newScene();
@@ -696,6 +852,13 @@ function App() {
         }
 
         try {
+            // Wait for user code to be ready before loading scene
+            // 在加载场景前等待用户代码就绪
+            const userCodeService = Core.services.tryResolve(UserCodeService);
+            if (userCodeService) {
+                await userCodeService.waitForReady();
+            }
+
             await sceneManager.openScene();
             const sceneState = sceneManager.getSceneState();
             setStatus(t('scene.openedSuccess', { name: sceneState.sceneName }));
@@ -706,13 +869,25 @@ function App() {
     };
 
     const handleOpenSceneByPath = useCallback(async (scenePath: string) => {
+        console.log('[App] handleOpenSceneByPath called:', scenePath);
         if (!sceneManager) {
             console.error('SceneManagerService not available');
             return;
         }
 
         try {
+            // Wait for user code to be ready before loading scene
+            // 在加载场景前等待用户代码就绪
+            const userCodeService = Core.services.tryResolve(UserCodeService);
+            if (userCodeService) {
+                console.log('[App] Waiting for user code service...');
+                await userCodeService.waitForReady();
+                console.log('[App] User code service ready');
+            }
+
+            console.log('[App] Calling sceneManager.openScene...');
             await sceneManager.openScene(scenePath);
+            console.log('[App] Scene opened successfully');
             const sceneState = sceneManager.getSceneState();
             setStatus(t('scene.openedSuccess', { name: sceneState.sceneName }));
         } catch (error) {
@@ -1087,6 +1262,14 @@ function App() {
                         }}
                     />
                 )}
+                {externalModificationDialog && (
+                    <ExternalModificationDialog
+                        sceneName={externalModificationDialog.sceneName}
+                        onReload={externalModificationDialog.onReload}
+                        onOverwrite={externalModificationDialog.onOverwrite}
+                        onCancel={() => setExternalModificationDialog(null)}
+                    />
+                )}
             </>
         );
     }
@@ -1121,6 +1304,7 @@ function App() {
                         onCreatePlugin={handleCreatePlugin}
                         onReloadPlugins={handleReloadPlugins}
                         onOpenBuildSettings={() => setShowBuildSettings(true)}
+                        onOpenRenderDebug={() => setShowRenderDebug(true)}
                     />
                     <MainToolbar
                         messageHub={messageHub || undefined}
@@ -1226,6 +1410,12 @@ function App() {
                 />
             )}
 
+            {/* 渲染调试面板 | Render Debug Panel */}
+            <RenderDebugPanel
+                visible={showRenderDebug}
+                onClose={() => setShowRenderDebug(false)}
+            />
+
             {errorDialog && (
                 <ErrorDialog
                     title={errorDialog.title}
@@ -1252,6 +1442,15 @@ function App() {
                     }}
                 />
             )}
+
+            {externalModificationDialog && (
+                <ExternalModificationDialog
+                    sceneName={externalModificationDialog.sceneName}
+                    onReload={externalModificationDialog.onReload}
+                    onOverwrite={externalModificationDialog.onOverwrite}
+                    onCancel={() => setExternalModificationDialog(null)}
+                />
+            )}
         </div>
     );
 }