编辑器核心框架

packages/editor-core/src/Plugins/EditorPluginManager.ts

@@ -0,0 +1,315 @@
+import { PluginManager } from '@esengine/ecs-framework';
+import type { Core, ServiceContainer } from '@esengine/ecs-framework';
+import { Injectable } from '@esengine/ecs-framework';
+import { createLogger } from '@esengine/ecs-framework';
+import type { IEditorPlugin, IEditorPluginMetadata } from './IEditorPlugin';
+import { EditorPluginCategory } from './IEditorPlugin';
+import { UIRegistry } from '../Services/UIRegistry';
+import { MessageHub } from '../Services/MessageHub';
+import { SerializerRegistry } from '../Services/SerializerRegistry';
+
+const logger = createLogger('EditorPluginManager');
+
+/**
+ * 编辑器插件管理器
+ *
+ * 扩展运行时插件管理器，提供编辑器特定的插件管理功能。
+ */
+@Injectable()
+export class EditorPluginManager extends PluginManager {
+    private editorPlugins: Map<string, IEditorPlugin> = new Map();
+    private pluginMetadata: Map<string, IEditorPluginMetadata> = new Map();
+    private uiRegistry: UIRegistry | null = null;
+    private messageHub: MessageHub | null = null;
+    private serializerRegistry: SerializerRegistry | null = null;
+
+    /**
+     * 初始化编辑器插件管理器
+     */
+    public override initialize(core: Core, services: ServiceContainer): void {
+        super.initialize(core, services);
+
+        this.uiRegistry = services.resolve(UIRegistry);
+        this.messageHub = services.resolve(MessageHub);
+        this.serializerRegistry = services.resolve(SerializerRegistry);
+
+        logger.info('EditorPluginManager initialized');
+    }
+
+    /**
+     * 安装编辑器插件
+     */
+    public async installEditor(plugin: IEditorPlugin): Promise<void> {
+        if (!this.uiRegistry || !this.messageHub || !this.serializerRegistry) {
+            throw new Error('EditorPluginManager not initialized. Call initialize() first.');
+        }
+
+        logger.info(`Installing editor plugin: ${plugin.name} (${plugin.displayName})`);
+
+        await super.install(plugin);
+
+        this.editorPlugins.set(plugin.name, plugin);
+
+        const metadata: IEditorPluginMetadata = {
+            name: plugin.name,
+            displayName: plugin.displayName,
+            version: plugin.version,
+            category: plugin.category,
+            description: plugin.description,
+            icon: plugin.icon,
+            enabled: true,
+            installedAt: Date.now()
+        };
+        this.pluginMetadata.set(plugin.name, metadata);
+
+        try {
+            if (plugin.registerMenuItems) {
+                const menuItems = plugin.registerMenuItems();
+                this.uiRegistry.registerMenus(menuItems);
+                logger.debug(`Registered ${menuItems.length} menu items for ${plugin.name}`);
+            }
+
+            if (plugin.registerToolbar) {
+                const toolbarItems = plugin.registerToolbar();
+                this.uiRegistry.registerToolbarItems(toolbarItems);
+                logger.debug(`Registered ${toolbarItems.length} toolbar items for ${plugin.name}`);
+            }
+
+            if (plugin.registerPanels) {
+                const panels = plugin.registerPanels();
+                this.uiRegistry.registerPanels(panels);
+                logger.debug(`Registered ${panels.length} panels for ${plugin.name}`);
+            }
+
+            if (plugin.getSerializers) {
+                const serializers = plugin.getSerializers();
+                this.serializerRegistry.registerMultiple(plugin.name, serializers);
+                logger.debug(`Registered ${serializers.length} serializers for ${plugin.name}`);
+            }
+
+            if (plugin.onEditorReady) {
+                await plugin.onEditorReady();
+            }
+
+            await this.messageHub.publish('plugin:installed', {
+                name: plugin.name,
+                displayName: plugin.displayName,
+                category: plugin.category
+            });
+
+            logger.info(`Editor plugin ${plugin.name} installed successfully`);
+        } catch (error) {
+            logger.error(`Failed to install editor plugin ${plugin.name}:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * 卸载编辑器插件
+     */
+    public async uninstallEditor(name: string): Promise<void> {
+        const plugin = this.editorPlugins.get(name);
+        if (!plugin) {
+            throw new Error(`Editor plugin ${name} is not installed`);
+        }
+
+        logger.info(`Uninstalling editor plugin: ${name}`);
+
+        try {
+            if (plugin.registerMenuItems) {
+                const menuItems = plugin.registerMenuItems();
+                for (const item of menuItems) {
+                    this.uiRegistry?.unregisterMenu(item.id);
+                }
+            }
+
+            if (plugin.registerToolbar) {
+                const toolbarItems = plugin.registerToolbar();
+                for (const item of toolbarItems) {
+                    this.uiRegistry?.unregisterToolbarItem(item.id);
+                }
+            }
+
+            if (plugin.registerPanels) {
+                const panels = plugin.registerPanels();
+                for (const panel of panels) {
+                    this.uiRegistry?.unregisterPanel(panel.id);
+                }
+            }
+
+            this.serializerRegistry?.unregisterAll(name);
+
+            await super.uninstall(name);
+
+            this.editorPlugins.delete(name);
+            this.pluginMetadata.delete(name);
+
+            await this.messageHub?.publish('plugin:uninstalled', { name });
+
+            logger.info(`Editor plugin ${name} uninstalled successfully`);
+        } catch (error) {
+            logger.error(`Failed to uninstall editor plugin ${name}:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * 获取编辑器插件
+     */
+    public getEditorPlugin(name: string): IEditorPlugin | undefined {
+        return this.editorPlugins.get(name);
+    }
+
+    /**
+     * 获取所有编辑器插件
+     */
+    public getAllEditorPlugins(): IEditorPlugin[] {
+        return Array.from(this.editorPlugins.values());
+    }
+
+    /**
+     * 获取插件元数据
+     */
+    public getPluginMetadata(name: string): IEditorPluginMetadata | undefined {
+        return this.pluginMetadata.get(name);
+    }
+
+    /**
+     * 获取所有插件元数据
+     */
+    public getAllPluginMetadata(): IEditorPluginMetadata[] {
+        return Array.from(this.pluginMetadata.values());
+    }
+
+    /**
+     * 按类别获取插件
+     */
+    public getPluginsByCategory(category: EditorPluginCategory): IEditorPlugin[] {
+        return this.getAllEditorPlugins().filter(plugin => plugin.category === category);
+    }
+
+    /**
+     * 启用插件
+     */
+    public async enablePlugin(name: string): Promise<void> {
+        const metadata = this.pluginMetadata.get(name);
+        if (!metadata) {
+            throw new Error(`Plugin ${name} not found`);
+        }
+
+        if (metadata.enabled) {
+            logger.warn(`Plugin ${name} is already enabled`);
+            return;
+        }
+
+        metadata.enabled = true;
+        await this.messageHub?.publish('plugin:enabled', { name });
+        logger.info(`Plugin ${name} enabled`);
+    }
+
+    /**
+     * 禁用插件
+     */
+    public async disablePlugin(name: string): Promise<void> {
+        const metadata = this.pluginMetadata.get(name);
+        if (!metadata) {
+            throw new Error(`Plugin ${name} not found`);
+        }
+
+        if (!metadata.enabled) {
+            logger.warn(`Plugin ${name} is already disabled`);
+            return;
+        }
+
+        metadata.enabled = false;
+        await this.messageHub?.publish('plugin:disabled', { name });
+        logger.info(`Plugin ${name} disabled`);
+    }
+
+    /**
+     * 项目打开通知
+     */
+    public async notifyProjectOpen(projectPath: string): Promise<void> {
+        logger.info(`Notifying plugins of project open: ${projectPath}`);
+
+        for (const plugin of this.editorPlugins.values()) {
+            if (plugin.onProjectOpen) {
+                try {
+                    await plugin.onProjectOpen(projectPath);
+                } catch (error) {
+                    logger.error(`Error in ${plugin.name}.onProjectOpen:`, error);
+                }
+            }
+        }
+
+        await this.messageHub?.publish('project:opened', { path: projectPath });
+    }
+
+    /**
+     * 项目关闭通知
+     */
+    public async notifyProjectClose(): Promise<void> {
+        logger.info('Notifying plugins of project close');
+
+        for (const plugin of this.editorPlugins.values()) {
+            if (plugin.onProjectClose) {
+                try {
+                    await plugin.onProjectClose();
+                } catch (error) {
+                    logger.error(`Error in ${plugin.name}.onProjectClose:`, error);
+                }
+            }
+        }
+
+        await this.messageHub?.publish('project:closed', {});
+    }
+
+    /**
+     * 文件保存前通知
+     */
+    public async notifyBeforeSave(filePath: string, data: any): Promise<void> {
+        for (const plugin of this.editorPlugins.values()) {
+            if (plugin.onBeforeSave) {
+                try {
+                    await plugin.onBeforeSave(filePath, data);
+                } catch (error) {
+                    logger.error(`Error in ${plugin.name}.onBeforeSave:`, error);
+                }
+            }
+        }
+
+        await this.messageHub?.publish('file:beforeSave', { path: filePath, data });
+    }
+
+    /**
+     * 文件保存后通知
+     */
+    public async notifyAfterSave(filePath: string): Promise<void> {
+        for (const plugin of this.editorPlugins.values()) {
+            if (plugin.onAfterSave) {
+                try {
+                    await plugin.onAfterSave(filePath);
+                } catch (error) {
+                    logger.error(`Error in ${plugin.name}.onAfterSave:`, error);
+                }
+            }
+        }
+
+        await this.messageHub?.publish('file:afterSave', { path: filePath });
+    }
+
+    /**
+     * 释放资源
+     */
+    public override dispose(): void {
+        super.dispose();
+
+        this.editorPlugins.clear();
+        this.pluginMetadata.clear();
+        this.uiRegistry = null;
+        this.messageHub = null;
+        this.serializerRegistry = null;
+
+        logger.info('EditorPluginManager disposed');
+    }
+}

packages/editor-core/src/Plugins/IEditorPlugin.ts

@@ -0,0 +1,169 @@
+import type { IPlugin } from '@esengine/ecs-framework';
+import type { MenuItem, ToolbarItem, PanelDescriptor } from '../Types/UITypes';
+
+/**
+ * 编辑器插件类别
+ */
+export enum EditorPluginCategory {
+    /**
+     * 工具插件
+     */
+    Tool = 'tool',
+
+    /**
+     * 窗口插件
+     */
+    Window = 'window',
+
+    /**
+     * 检视器插件
+     */
+    Inspector = 'inspector',
+
+    /**
+     * 系统插件
+     */
+    System = 'system',
+
+    /**
+     * 导入导出插件
+     */
+    ImportExport = 'import-export'
+}
+
+/**
+ * 序列化器接口
+ */
+export interface ISerializer<T = any> {
+    /**
+     * 序列化为二进制数据
+     */
+    serialize(data: T): Uint8Array;
+
+    /**
+     * 从二进制数据反序列化
+     */
+    deserialize(data: Uint8Array): T;
+
+    /**
+     * 获取序列化器支持的数据类型
+     */
+    getSupportedType(): string;
+}
+
+/**
+ * 编辑器插件接口
+ *
+ * 扩展了运行时插件接口，添加了编辑器特定的功能。
+ */
+export interface IEditorPlugin extends IPlugin {
+    /**
+     * 插件显示名称
+     */
+    readonly displayName: string;
+
+    /**
+     * 插件类别
+     */
+    readonly category: EditorPluginCategory;
+
+    /**
+     * 插件描述
+     */
+    readonly description?: string;
+
+    /**
+     * 插件图标
+     */
+    readonly icon?: string;
+
+    /**
+     * 注册菜单项
+     */
+    registerMenuItems?(): MenuItem[];
+
+    /**
+     * 注册工具栏项
+     */
+    registerToolbar?(): ToolbarItem[];
+
+    /**
+     * 注册面板
+     */
+    registerPanels?(): PanelDescriptor[];
+
+    /**
+     * 提供序列化器
+     */
+    getSerializers?(): ISerializer[];
+
+    /**
+     * 编辑器就绪回调
+     */
+    onEditorReady?(): void | Promise<void>;
+
+    /**
+     * 项目打开回调
+     */
+    onProjectOpen?(projectPath: string): void | Promise<void>;
+
+    /**
+     * 项目关闭回调
+     */
+    onProjectClose?(): void | Promise<void>;
+
+    /**
+     * 文件保存前回调
+     */
+    onBeforeSave?(filePath: string, data: any): void | Promise<void>;
+
+    /**
+     * 文件保存后回调
+     */
+    onAfterSave?(filePath: string): void | Promise<void>;
+}
+
+/**
+ * 编辑器插件元数据
+ */
+export interface IEditorPluginMetadata {
+    /**
+     * 插件名称
+     */
+    name: string;
+
+    /**
+     * 显示名称
+     */
+    displayName: string;
+
+    /**
+     * 版本
+     */
+    version: string;
+
+    /**
+     * 类别
+     */
+    category: EditorPluginCategory;
+
+    /**
+     * 描述
+     */
+    description?: string;
+
+    /**
+     * 图标
+     */
+    icon?: string;
+
+    /**
+     * 是否已启用
+     */
+    enabled: boolean;
+
+    /**
+     * 安装时间戳
+     */
+    installedAt?: number;
+}

packages/editor-core/src/Services/MessageHub.ts

@@ -0,0 +1,217 @@
+import type { IService } from '@esengine/ecs-framework';
+import { Injectable } from '@esengine/ecs-framework';
+import { createLogger } from '@esengine/ecs-framework';
+
+const logger = createLogger('MessageHub');
+
+/**
+ * 消息处理器类型
+ */
+export type MessageHandler<T = any> = (data: T) => void | Promise<void>;
+
+/**
+ * 消息订阅
+ */
+interface MessageSubscription {
+    topic: string;
+    handler: MessageHandler;
+    once: boolean;
+}
+
+/**
+ * 消息总线
+ *
+ * 提供插件间的事件通信机制，支持订阅/发布模式。
+ */
+@Injectable()
+export class MessageHub implements IService {
+    private subscriptions: Map<string, MessageSubscription[]> = new Map();
+    private subscriptionId: number = 0;
+
+    /**
+     * 订阅消息
+     *
+     * @param topic - 消息主题
+     * @param handler - 消息处理器
+     * @returns 取消订阅的函数
+     */
+    public subscribe<T = any>(topic: string, handler: MessageHandler<T>): () => void {
+        return this.addSubscription(topic, handler, false);
+    }
+
+    /**
+     * 订阅一次性消息
+     *
+     * @param topic - 消息主题
+     * @param handler - 消息处理器
+     * @returns 取消订阅的函数
+     */
+    public subscribeOnce<T = any>(topic: string, handler: MessageHandler<T>): () => void {
+        return this.addSubscription(topic, handler, true);
+    }
+
+    /**
+     * 添加订阅
+     */
+    private addSubscription(topic: string, handler: MessageHandler, once: boolean): () => void {
+        const subscription: MessageSubscription = {
+            topic,
+            handler,
+            once
+        };
+
+        let subs = this.subscriptions.get(topic);
+        if (!subs) {
+            subs = [];
+            this.subscriptions.set(topic, subs);
+        }
+        subs.push(subscription);
+
+        const subId = ++this.subscriptionId;
+        logger.debug(`Subscribed to topic: ${topic} (id: ${subId}, once: ${once})`);
+
+        return () => {
+            this.unsubscribe(topic, subscription);
+            logger.debug(`Unsubscribed from topic: ${topic} (id: ${subId})`);
+        };
+    }
+
+    /**
+     * 取消订阅
+     */
+    private unsubscribe(topic: string, subscription: MessageSubscription): void {
+        const subs = this.subscriptions.get(topic);
+        if (!subs) {
+            return;
+        }
+
+        const index = subs.indexOf(subscription);
+        if (index !== -1) {
+            subs.splice(index, 1);
+        }
+
+        if (subs.length === 0) {
+            this.subscriptions.delete(topic);
+        }
+    }
+
+    /**
+     * 发布消息
+     *
+     * @param topic - 消息主题
+     * @param data - 消息数据
+     */
+    public async publish<T = any>(topic: string, data?: T): Promise<void> {
+        const subs = this.subscriptions.get(topic);
+        if (!subs || subs.length === 0) {
+            logger.debug(`No subscribers for topic: ${topic}`);
+            return;
+        }
+
+        logger.debug(`Publishing message to topic: ${topic} (${subs.length} subscribers)`);
+
+        const onceSubscriptions: MessageSubscription[] = [];
+
+        for (const sub of subs) {
+            try {
+                await sub.handler(data);
+                if (sub.once) {
+                    onceSubscriptions.push(sub);
+                }
+            } catch (error) {
+                logger.error(`Error in message handler for topic ${topic}:`, error);
+            }
+        }
+
+        for (const sub of onceSubscriptions) {
+            this.unsubscribe(topic, sub);
+        }
+    }
+
+    /**
+     * 同步发布消息
+     *
+     * @param topic - 消息主题
+     * @param data - 消息数据
+     */
+    public publishSync<T = any>(topic: string, data?: T): void {
+        const subs = this.subscriptions.get(topic);
+        if (!subs || subs.length === 0) {
+            logger.debug(`No subscribers for topic: ${topic}`);
+            return;
+        }
+
+        logger.debug(`Publishing sync message to topic: ${topic} (${subs.length} subscribers)`);
+
+        const onceSubscriptions: MessageSubscription[] = [];
+
+        for (const sub of subs) {
+            try {
+                const result = sub.handler(data);
+                if (result instanceof Promise) {
+                    logger.warn(`Async handler used with publishSync for topic: ${topic}`);
+                }
+                if (sub.once) {
+                    onceSubscriptions.push(sub);
+                }
+            } catch (error) {
+                logger.error(`Error in message handler for topic ${topic}:`, error);
+            }
+        }
+
+        for (const sub of onceSubscriptions) {
+            this.unsubscribe(topic, sub);
+        }
+    }
+
+    /**
+     * 取消所有指定主题的订阅
+     *
+     * @param topic - 消息主题
+     */
+    public unsubscribeAll(topic: string): void {
+        const deleted = this.subscriptions.delete(topic);
+        if (deleted) {
+            logger.debug(`Unsubscribed all from topic: ${topic}`);
+        }
+    }
+
+    /**
+     * 检查主题是否有订阅者
+     *
+     * @param topic - 消息主题
+     * @returns 是否有订阅者
+     */
+    public hasSubscribers(topic: string): boolean {
+        const subs = this.subscriptions.get(topic);
+        return subs !== undefined && subs.length > 0;
+    }
+
+    /**
+     * 获取所有主题
+     *
+     * @returns 主题列表
+     */
+    public getTopics(): string[] {
+        return Array.from(this.subscriptions.keys());
+    }
+
+    /**
+     * 获取主题的订阅者数量
+     *
+     * @param topic - 消息主题
+     * @returns 订阅者数量
+     */
+    public getSubscriberCount(topic: string): number {
+        const subs = this.subscriptions.get(topic);
+        return subs ? subs.length : 0;
+    }
+
+    /**
+     * 释放资源
+     */
+    public dispose(): void {
+        this.subscriptions.clear();
+        logger.info('MessageHub disposed');
+    }
+}

packages/editor-core/src/Services/SerializerRegistry.ts

@@ -0,0 +1,181 @@
+import type { IService } from '@esengine/ecs-framework';
+import { Injectable } from '@esengine/ecs-framework';
+import { createLogger } from '@esengine/ecs-framework';
+import type { ISerializer } from '../Plugins/IEditorPlugin';
+
+const logger = createLogger('SerializerRegistry');
+
+/**
+ * 序列化器注册表
+ *
+ * 管理所有数据序列化器的注册和查询。
+ */
+@Injectable()
+export class SerializerRegistry implements IService {
+    private serializers: Map<string, ISerializer> = new Map();
+
+    /**
+     * 注册序列化器
+     *
+     * @param pluginName - 插件名称
+     * @param serializer - 序列化器实例
+     */
+    public register(pluginName: string, serializer: ISerializer): void {
+        const type = serializer.getSupportedType();
+        const key = `${pluginName}:${type}`;
+
+        if (this.serializers.has(key)) {
+            logger.warn(`Serializer for ${key} is already registered`);
+            return;
+        }
+
+        this.serializers.set(key, serializer);
+        logger.info(`Registered serializer: ${key}`);
+    }
+
+    /**
+     * 批量注册序列化器
+     *
+     * @param pluginName - 插件名称
+     * @param serializers - 序列化器实例数组
+     */
+    public registerMultiple(pluginName: string, serializers: ISerializer[]): void {
+        for (const serializer of serializers) {
+            this.register(pluginName, serializer);
+        }
+    }
+
+    /**
+     * 注销序列化器
+     *
+     * @param pluginName - 插件名称
+     * @param type - 数据类型
+     * @returns 是否成功注销
+     */
+    public unregister(pluginName: string, type: string): boolean {
+        const key = `${pluginName}:${type}`;
+        const result = this.serializers.delete(key);
+
+        if (result) {
+            logger.info(`Unregistered serializer: ${key}`);
+        }
+
+        return result;
+    }
+
+    /**
+     * 注销插件的所有序列化器
+     *
+     * @param pluginName - 插件名称
+     */
+    public unregisterAll(pluginName: string): void {
+        const prefix = `${pluginName}:`;
+        const keysToDelete: string[] = [];
+
+        for (const key of this.serializers.keys()) {
+            if (key.startsWith(prefix)) {
+                keysToDelete.push(key);
+            }
+        }
+
+        for (const key of keysToDelete) {
+            this.serializers.delete(key);
+            logger.info(`Unregistered serializer: ${key}`);
+        }
+    }
+
+    /**
+     * 获取序列化器
+     *
+     * @param pluginName - 插件名称
+     * @param type - 数据类型
+     * @returns 序列化器实例，如果未找到则返回 undefined
+     */
+    public get(pluginName: string, type: string): ISerializer | undefined {
+        const key = `${pluginName}:${type}`;
+        return this.serializers.get(key);
+    }
+
+    /**
+     * 查找支持指定类型的序列化器
+     *
+     * @param type - 数据类型
+     * @returns 序列化器实例数组
+     */
+    public findByType(type: string): ISerializer[] {
+        const result: ISerializer[] = [];
+
+        for (const [key, serializer] of this.serializers) {
+            if (key.endsWith(`:${type}`)) {
+                result.push(serializer);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * 获取所有序列化器
+     *
+     * @returns 序列化器映射表
+     */
+    public getAll(): Map<string, ISerializer> {
+        return new Map(this.serializers);
+    }
+
+    /**
+     * 检查序列化器是否已注册
+     *
+     * @param pluginName - 插件名称
+     * @param type - 数据类型
+     * @returns 是否已注册
+     */
+    public has(pluginName: string, type: string): boolean {
+        const key = `${pluginName}:${type}`;
+        return this.serializers.has(key);
+    }
+
+    /**
+     * 序列化数据
+     *
+     * @param pluginName - 插件名称
+     * @param type - 数据类型
+     * @param data - 要序列化的数据
+     * @returns 二进制数据
+     * @throws 如果序列化器未注册
+     */
+    public serialize<T = any>(pluginName: string, type: string, data: T): Uint8Array {
+        const serializer = this.get(pluginName, type);
+        if (!serializer) {
+            throw new Error(`Serializer not found: ${pluginName}:${type}`);
+        }
+
+        return serializer.serialize(data);
+    }
+
+    /**
+     * 反序列化数据
+     *
+     * @param pluginName - 插件名称
+     * @param type - 数据类型
+     * @param data - 二进制数据
+     * @returns 反序列化后的数据
+     * @throws 如果序列化器未注册
+     */
+    public deserialize<T = any>(pluginName: string, type: string, data: Uint8Array): T {
+        const serializer = this.get(pluginName, type);
+        if (!serializer) {
+            throw new Error(`Serializer not found: ${pluginName}:${type}`);
+        }
+
+        return serializer.deserialize(data);
+    }
+
+    /**
+     * 释放资源
+     */
+    public dispose(): void {
+        this.serializers.clear();
+        logger.info('SerializerRegistry disposed');
+    }
+}

packages/editor-core/src/Services/UIRegistry.ts

@@ -0,0 +1,202 @@
+import type { IService } from '@esengine/ecs-framework';
+import { Injectable } from '@esengine/ecs-framework';
+import { createLogger } from '@esengine/ecs-framework';
+import type { MenuItem, ToolbarItem, PanelDescriptor } from '../Types/UITypes';
+
+const logger = createLogger('UIRegistry');
+
+/**
+ * UI 注册表
+ *
+ * 管理所有编辑器 UI 扩展点的注册和查询。
+ */
+@Injectable()
+export class UIRegistry implements IService {
+    private menus: Map<string, MenuItem> = new Map();
+    private toolbarItems: Map<string, ToolbarItem> = new Map();
+    private panels: Map<string, PanelDescriptor> = new Map();
+
+    /**
+     * 注册菜单项
+     */
+    public registerMenu(item: MenuItem): void {
+        if (this.menus.has(item.id)) {
+            logger.warn(`Menu item ${item.id} is already registered`);
+            return;
+        }
+
+        this.menus.set(item.id, item);
+        logger.debug(`Registered menu item: ${item.id}`);
+    }
+
+    /**
+     * 批量注册菜单项
+     */
+    public registerMenus(items: MenuItem[]): void {
+        for (const item of items) {
+            this.registerMenu(item);
+        }
+    }
+
+    /**
+     * 注销菜单项
+     */
+    public unregisterMenu(id: string): boolean {
+        const result = this.menus.delete(id);
+        if (result) {
+            logger.debug(`Unregistered menu item: ${id}`);
+        }
+        return result;
+    }
+
+    /**
+     * 获取菜单项
+     */
+    public getMenu(id: string): MenuItem | undefined {
+        return this.menus.get(id);
+    }
+
+    /**
+     * 获取所有菜单项
+     */
+    public getAllMenus(): MenuItem[] {
+        return Array.from(this.menus.values()).sort((a, b) => {
+            return (a.order ?? 0) - (b.order ?? 0);
+        });
+    }
+
+    /**
+     * 获取指定父菜单的子菜单
+     */
+    public getChildMenus(parentId: string): MenuItem[] {
+        return this.getAllMenus()
+            .filter(item => item.parentId === parentId)
+            .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    }
+
+    /**
+     * 注册工具栏项
+     */
+    public registerToolbarItem(item: ToolbarItem): void {
+        if (this.toolbarItems.has(item.id)) {
+            logger.warn(`Toolbar item ${item.id} is already registered`);
+            return;
+        }
+
+        this.toolbarItems.set(item.id, item);
+        logger.debug(`Registered toolbar item: ${item.id}`);
+    }
+
+    /**
+     * 批量注册工具栏项
+     */
+    public registerToolbarItems(items: ToolbarItem[]): void {
+        for (const item of items) {
+            this.registerToolbarItem(item);
+        }
+    }
+
+    /**
+     * 注销工具栏项
+     */
+    public unregisterToolbarItem(id: string): boolean {
+        const result = this.toolbarItems.delete(id);
+        if (result) {
+            logger.debug(`Unregistered toolbar item: ${id}`);
+        }
+        return result;
+    }
+
+    /**
+     * 获取工具栏项
+     */
+    public getToolbarItem(id: string): ToolbarItem | undefined {
+        return this.toolbarItems.get(id);
+    }
+
+    /**
+     * 获取所有工具栏项
+     */
+    public getAllToolbarItems(): ToolbarItem[] {
+        return Array.from(this.toolbarItems.values()).sort((a, b) => {
+            return (a.order ?? 0) - (b.order ?? 0);
+        });
+    }
+
+    /**
+     * 获取指定组的工具栏项
+     */
+    public getToolbarItemsByGroup(groupId: string): ToolbarItem[] {
+        return this.getAllToolbarItems()
+            .filter(item => item.groupId === groupId)
+            .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    }
+
+    /**
+     * 注册面板
+     */
+    public registerPanel(panel: PanelDescriptor): void {
+        if (this.panels.has(panel.id)) {
+            logger.warn(`Panel ${panel.id} is already registered`);
+            return;
+        }
+
+        this.panels.set(panel.id, panel);
+        logger.debug(`Registered panel: ${panel.id}`);
+    }
+
+    /**
+     * 批量注册面板
+     */
+    public registerPanels(panels: PanelDescriptor[]): void {
+        for (const panel of panels) {
+            this.registerPanel(panel);
+        }
+    }
+
+    /**
+     * 注销面板
+     */
+    public unregisterPanel(id: string): boolean {
+        const result = this.panels.delete(id);
+        if (result) {
+            logger.debug(`Unregistered panel: ${id}`);
+        }
+        return result;
+    }
+
+    /**
+     * 获取面板
+     */
+    public getPanel(id: string): PanelDescriptor | undefined {
+        return this.panels.get(id);
+    }
+
+    /**
+     * 获取所有面板
+     */
+    public getAllPanels(): PanelDescriptor[] {
+        return Array.from(this.panels.values()).sort((a, b) => {
+            return (a.order ?? 0) - (b.order ?? 0);
+        });
+    }
+
+    /**
+     * 获取指定位置的面板
+     */
+    public getPanelsByPosition(position: string): PanelDescriptor[] {
+        return this.getAllPanels()
+            .filter(panel => panel.position === position)
+            .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    }
+
+    /**
+     * 释放资源
+     */
+    public dispose(): void {
+        this.menus.clear();
+        this.toolbarItems.clear();
+        this.panels.clear();
+        logger.info('UIRegistry disposed');
+    }
+}

packages/editor-core/src/Types/UITypes.ts

@@ -0,0 +1,160 @@
+/**
+ * 菜单项配置
+ */
+export interface MenuItem {
+    /**
+     * 菜单项唯一标识
+     */
+    id: string;
+
+    /**
+     * 显示文本
+     */
+    label: string;
+
+    /**
+     * 父菜单ID，用于构建层级菜单
+     */
+    parentId?: string;
+
+    /**
+     * 点击回调
+     */
+    onClick?: () => void;
+
+    /**
+     * 键盘快捷键
+     */
+    shortcut?: string;
+
+    /**
+     * 图标
+     */
+    icon?: string;
+
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+
+    /**
+     * 分隔符
+     */
+    separator?: boolean;
+
+    /**
+     * 排序权重
+     */
+    order?: number;
+}
+
+/**
+ * 工具栏项配置
+ */
+export interface ToolbarItem {
+    /**
+     * 工具栏项唯一标识
+     */
+    id: string;
+
+    /**
+     * 显示文本
+     */
+    label: string;
+
+    /**
+     * 工具栏组ID
+     */
+    groupId: string;
+
+    /**
+     * 点击回调
+     */
+    onClick?: () => void;
+
+    /**
+     * 图标
+     */
+    icon?: string;
+
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+
+    /**
+     * 排序权重
+     */
+    order?: number;
+}
+
+/**
+ * 面板位置
+ */
+export enum PanelPosition {
+    Left = 'left',
+    Right = 'right',
+    Bottom = 'bottom',
+    Center = 'center'
+}
+
+/**
+ * 面板描述符
+ */
+export interface PanelDescriptor {
+    /**
+     * 面板唯一标识
+     */
+    id: string;
+
+    /**
+     * 显示标题
+     */
+    title: string;
+
+    /**
+     * 面板位置
+     */
+    position: PanelPosition;
+
+    /**
+     * 渲染组件或HTML
+     */
+    component?: any;
+
+    /**
+     * 默认宽度/高度（像素）
+     */
+    defaultSize?: number;
+
+    /**
+     * 是否可调整大小
+     */
+    resizable?: boolean;
+
+    /**
+     * 是否可关闭
+     */
+    closable?: boolean;
+
+    /**
+     * 图标
+     */
+    icon?: string;
+
+    /**
+     * 排序权重
+     */
+    order?: number;
+}
+
+/**
+ * UI 扩展点类型
+ */
+export enum UIExtensionType {
+    Menu = 'menu',
+    Toolbar = 'toolbar',
+    Panel = 'panel',
+    Inspector = 'inspector',
+    StatusBar = 'statusbar'
+}

packages/editor-core/src/index.ts

@@ -0,0 +1,14 @@
+/**
+ * ECS Framework Editor Core
+ *
+ * Plugin-based editor framework for ECS Framework
+ */
+
+export * from './Plugins/IEditorPlugin';
+export * from './Plugins/EditorPluginManager';
+
+export * from './Services/UIRegistry';
+export * from './Services/MessageHub';
+export * from './Services/SerializerRegistry';
+
+export * from './Types/UITypes';