CocosPlugin/esengine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
* 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
This commit is contained in:
YHH
2025-12-16 12:46:14 +08:00
committed by GitHub
parent d834ca5e77
commit ed8f6e283b
107 changed files with 7399 additions and 847 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
packages/particle/src/systems/ClickFxSystem.ts
View File

@@ -8,10 +8,8 @@
import { EntitySystem, Matcher, Entity, ECSSystem, PluginServiceRegistry, createServiceToken } from '@esengine/ecs-framework';
import { Input, MouseButton, TransformComponent, SortingLayers } from '@esengine/engine-core';
import type { IAssetManager } from '@esengine/asset-system';
import { ClickFxComponent, ClickFxTriggerMode } from '../ClickFxComponent';
import { ParticleSystemComponent, RenderSpace } from '../ParticleSystemComponent';
import type { IParticleAsset } from '../loaders/ParticleLoader';
// ============================================================================
// 本地服务令牌定义 | Local Service Token Definitions
@@ -66,7 +64,6 @@ const RenderSystemToken = createServiceToken<IEngineRenderSystem>('renderSystem'
export class ClickFxSystem extends EntitySystem {
private _engineBridge: IEngineBridge | null = null;
private _renderSystem: IEngineRenderSystem | null = null;
private _assetManager: IAssetManager | null = null;
private _entitiesToDestroy: Entity[] = [];
private _canvas: HTMLCanvasElement | null = null;
@@ -74,14 +71,6 @@ export class ClickFxSystem extends EntitySystem {
super(Matcher.empty().all(ClickFxComponent));
}
/**
* 设置资产管理器
* Set asset manager
*/
setAssetManager(assetManager: IAssetManager | null): void {
this._assetManager = assetManager;
}
/**
* 设置服务注册表（用于获取 EngineBridge 和 RenderSystem）
* Set service registry (for getting EngineBridge and RenderSystem)
@@ -339,8 +328,11 @@ export class ClickFxSystem extends EntitySystem {
const transform = effectEntity.addComponent(new TransformComponent(screenSpaceX, screenSpaceY));
transform.setScale(clickFx.scale, clickFx.scale, 1);
// 添加 ParticleSystem | Add ParticleSystem
const particleSystem = effectEntity.addComponent(new ParticleSystemComponent());
// 创建 ParticleSystemComponent 并预先设置 GUID（在添加到实体前）
// Create ParticleSystemComponent and set GUID before adding to entity
// 这样 ParticleUpdateSystem.onAdded 触发时已经有 GUID 了
// So ParticleUpdateSystem.onAdded has the GUID when triggered
const particleSystem = new ParticleSystemComponent();
particleSystem.particleAssetGuid = particleGuid;
particleSystem.autoPlay = true;
// 使用 ScreenOverlay 层和屏幕空间渲染
@@ -349,31 +341,12 @@ export class ClickFxSystem extends EntitySystem {
particleSystem.orderInLayer = 0;
particleSystem.renderSpace = RenderSpace.Screen;
// 添加组件到实体（触发 ParticleUpdateSystem 的初始化和资产加载）
// Add component to entity (triggers ParticleUpdateSystem initialization and asset loading)
effectEntity.addComponent(particleSystem);
// 记录活跃特效 | Record active effect
clickFx.addActiveEffect(effectEntity.id);
// 异步加载并播放 | Async load and play
if (this._assetManager) {
this._assetManager.loadAsset<IParticleAsset>(particleGuid).then(result => {
if (result?.asset) {
particleSystem.setAssetData(result.asset);
// 应用资产的排序属性 | Apply sorting properties from asset
if (result.asset.sortingLayer) {
particleSystem.sortingLayer = result.asset.sortingLayer;
}
if (result.asset.orderInLayer !== undefined) {
particleSystem.orderInLayer = result.asset.orderInLayer;
}
particleSystem.play();
} else {
console.warn(`[ClickFxSystem] Failed to load particle asset: ${particleGuid}`);
}
}).catch(error => {
console.error(`[ClickFxSystem] Error loading particle asset ${particleGuid}:`, error);
});
} else {
console.warn('[ClickFxSystem] AssetManager not set, cannot load particle asset');
}
}
/**

180
packages/particle/src/systems/ParticleSystem.ts
View File

@@ -185,6 +185,11 @@ export class ParticleUpdateSystem extends EntitySystem {
}
}
// 如果正在初始化中，跳过处理 | Skip processing if initializing
if (this._loadingComponents.has(particle)) {
continue;
}
// 检测资产 GUID 变化并重新加载 | Detect asset GUID change and reload
// 这使得编辑器中选择新的粒子资产时能够立即切换
// This allows immediate switching when selecting a new particle asset in the editor
@@ -205,8 +210,9 @@ export class ParticleUpdateSystem extends EntitySystem {
particle.update(deltaTime, worldX, worldY, worldRotation, worldScaleX, worldScaleY);
}
// 尝试加载纹理（如果还没有加载）| Try to load texture if not loaded yet
if (particle.textureId === 0) {
// 尝试加载纹理（如果还没有加载且不在初始化中）
// Try to load texture if not loaded yet and not initializing
if (particle.textureId === 0 && !this._loadingComponents.has(particle)) {
this.loadParticleTexture(particle);
}
@@ -262,56 +268,65 @@ export class ParticleUpdateSystem extends EntitySystem {
* Async initialize particle system
*/
private async _initializeParticle(entity: Entity, particle: ParticleSystemComponent): Promise<void> {
// 如果有资产 GUID，先加载资产 | Load asset first if GUID is set
if (particle.particleAssetGuid) {
const asset = await this._loadParticleAsset(particle.particleAssetGuid);
if (asset) {
particle.setAssetData(asset);
// 应用资产的排序属性 | Apply sorting properties from asset
if (asset.sortingLayer) {
particle.sortingLayer = asset.sortingLayer;
}
if (asset.orderInLayer !== undefined) {
particle.orderInLayer = asset.orderInLayer;
// 标记为正在初始化，防止 process 中重复调用 loadParticleTexture
// Mark as initializing to prevent duplicate loadParticleTexture calls in process
this._loadingComponents.add(particle);
try {
// 如果有资产 GUID，先加载资产 | Load asset first if GUID is set
if (particle.particleAssetGuid) {
const asset = await this._loadParticleAsset(particle.particleAssetGuid);
if (asset) {
particle.setAssetData(asset);
// 应用资产的排序属性 | Apply sorting properties from asset
if (asset.sortingLayer) {
particle.sortingLayer = asset.sortingLayer;
}
if (asset.orderInLayer !== undefined) {
particle.orderInLayer = asset.orderInLayer;
}
}
}
}
// 初始化粒子系统（不自动播放，由下面的逻辑控制）
// Initialize particle system (don't auto play, controlled by logic below)
particle.ensureBuilt();
// 初始化粒子系统（不自动播放，由下面的逻辑控制）
// Initialize particle system (don't auto play, controlled by logic below)
particle.ensureBuilt();
// 加载纹理 | Load texture
await this.loadParticleTexture(particle);
// 加载纹理 | Load texture
await this.loadParticleTexture(particle);
// 注册到渲染数据提供者 | Register to render data provider
// 尝试获取 Transform，如果没有则使用默认位置 | Try to get Transform, use default position if not available
let transform: ITransformComponent | null = null;
if (this._transformType) {
transform = entity.getComponent(this._transformType);
}
// 即使没有 Transform，也要注册粒子系统（使用原点位置） | Register particle system even without Transform (use origin position)
if (transform) {
this._renderDataProvider.register(particle, transform);
} else {
this._renderDataProvider.register(particle, { position: { x: 0, y: 0 } });
}
// 记录已加载的资产 GUID | Record loaded asset GUID
this._lastLoadedGuids.set(particle, particle.particleAssetGuid);
// 决定是否自动播放 | Decide whether to auto play
// 编辑器模式：有资产时自动播放预览 | Editor mode: auto play preview if has asset
// 运行时模式：根据 autoPlay 设置 | Runtime mode: based on autoPlay setting
const isEditorMode = this.scene?.isEditorMode ?? false;
if (particle.particleAssetGuid && particle.loadedAsset) {
if (isEditorMode) {
// 编辑器模式：始终播放预览 | Editor mode: always play preview
particle.play();
} else if (particle.autoPlay) {
// 运行时模式：根据 autoPlay 设置 | Runtime mode: based on autoPlay
particle.play();
// 注册到渲染数据提供者 | Register to render data provider
// 尝试获取 Transform，如果没有则使用默认位置 | Try to get Transform, use default position if not available
let transform: ITransformComponent | null = null;
if (this._transformType) {
transform = entity.getComponent(this._transformType);
}
// 即使没有 Transform，也要注册粒子系统（使用原点位置） | Register particle system even without Transform (use origin position)
if (transform) {
this._renderDataProvider.register(particle, transform);
} else {
this._renderDataProvider.register(particle, { position: { x: 0, y: 0 } });
}
// 记录已加载的资产 GUID | Record loaded asset GUID
this._lastLoadedGuids.set(particle, particle.particleAssetGuid);
// 决定是否自动播放 | Decide whether to auto play
// 编辑器模式：有资产时自动播放预览 | Editor mode: auto play preview if has asset
// 运行时模式：根据 autoPlay 设置 | Runtime mode: based on autoPlay setting
const isEditorMode = this.scene?.isEditorMode ?? false;
if (particle.particleAssetGuid && particle.loadedAsset) {
if (isEditorMode) {
// 编辑器模式：始终播放预览 | Editor mode: always play preview
particle.play();
} else if (particle.autoPlay) {
// 运行时模式：根据 autoPlay 设置 | Runtime mode: based on autoPlay
particle.play();
}
}
} finally {
// 初始化完成，移除加载标记 | Initialization complete, remove loading mark
this._loadingComponents.delete(particle);
}
}
@@ -329,9 +344,25 @@ export class ParticleUpdateSystem extends EntitySystem {
const currentGuid = particle.particleAssetGuid;
const lastGuid = this._lastLoadedGuids.get(particle);
// 如果 GUID 没有变化，或者正在加载中，跳过
// Skip if GUID hasn't changed or already loading
if (currentGuid === lastGuid || this._loadingComponents.has(particle)) {
// 如果正在加载中，跳过
// Skip if already loading
if (this._loadingComponents.has(particle)) {
return;
}
// 检查是否需要重新加载：
// 1. GUID 变化了
// 2. 或者 GUID 相同但资产数据丢失（场景恢复后）
// 3. 或者 GUID 相同但纹理 ID 无效（纹理被清除后）
// Check if reload is needed:
// 1. GUID changed
// 2. Or GUID is same but asset data is lost (after scene restore)
// 3. Or GUID is same but texture ID is invalid (after texture clear)
const needsReload = currentGuid !== lastGuid ||
(currentGuid && !particle.loadedAsset) ||
(currentGuid && particle.textureId === 0);
if (!needsReload) {
return;
}
@@ -410,35 +441,70 @@ export class ParticleUpdateSystem extends EntitySystem {
} catch (error) {
console.error('[ParticleUpdateSystem] Failed to load texture by GUID:', textureGuid, error);
// 加载失败时使用默认纹理 | Use default texture on load failure
await this._ensureDefaultTexture();
particle.textureId = DEFAULT_PARTICLE_TEXTURE_ID;
const loaded = await this._ensureDefaultTexture();
if (loaded) {
particle.textureId = DEFAULT_PARTICLE_TEXTURE_ID;
}
}
} else {
// 没有纹理 GUID 时使用默认粒子纹理 | Use default particle texture when no GUID
await this._ensureDefaultTexture();
particle.textureId = DEFAULT_PARTICLE_TEXTURE_ID;
const loaded = await this._ensureDefaultTexture();
if (loaded) {
particle.textureId = DEFAULT_PARTICLE_TEXTURE_ID;
}
}
}
/**
* 确保默认粒子纹理已加载
* Ensure default particle texture is loaded
*
* 使用 loadTextureAsync API 等待纹理实际加载完成，
* 避免显示灰色占位符的问题。
* Uses loadTextureAsync API to wait for actual texture completion,
* avoiding the gray placeholder issue.
*
* @returns 是否成功加载 | Whether successfully loaded
*/
private async _ensureDefaultTexture(): Promise<void> {
if (this._defaultTextureLoaded || this._defaultTextureLoading) return;
if (!this._engineBridge) return;
private async _ensureDefaultTexture(): Promise<boolean> {
// 已加载过 | Already loaded
if (this._defaultTextureLoaded) return true;
// 正在加载中，等待完成 | Loading in progress, wait for completion
if (this._defaultTextureLoading) {
// 轮询等待加载完成 | Poll until loading completes
while (this._defaultTextureLoading) {
await new Promise(resolve => setTimeout(resolve, 10));
}
return this._defaultTextureLoaded;
}
// 没有引擎桥接，无法加载 | No engine bridge, cannot load
if (!this._engineBridge) {
console.warn('[ParticleUpdateSystem] EngineBridge not set, cannot load default texture');
return false;
}
this._defaultTextureLoading = true;
try {
const dataUrl = generateDefaultParticleTextureDataURL();
if (dataUrl) {
await this._engineBridge.loadTexture(DEFAULT_PARTICLE_TEXTURE_ID, dataUrl);
// 优先使用 loadTextureAsync（等待纹理就绪）
// Prefer loadTextureAsync (waits for texture ready)
if (this._engineBridge.loadTextureAsync) {
await this._engineBridge.loadTextureAsync(DEFAULT_PARTICLE_TEXTURE_ID, dataUrl);
} else {
// 回退到旧 API（可能显示灰色占位符）
// Fallback to old API (may show gray placeholder)
await this._engineBridge.loadTexture(DEFAULT_PARTICLE_TEXTURE_ID, dataUrl);
}
this._defaultTextureLoaded = true;
}
} catch (error) {
console.error('[ParticleUpdateSystem] Failed to create default particle texture:', error);
}
this._defaultTextureLoading = false;
return this._defaultTextureLoaded;
}
protected override onRemoved(entity: Entity): void {