740 lines
25 KiB
TypeScript
740 lines
25 KiB
TypeScript
import { Entity } from '../../ECS/Entity';
|
||
import { Component } from '../../ECS/Component';
|
||
import { ISnapshotable, SceneSnapshot, EntitySnapshot, ComponentSnapshot, SnapshotConfig } from './ISnapshotable';
|
||
import { ProtobufSerializer, SerializedData } from '../Serialization/ProtobufSerializer';
|
||
import { isProtoSerializable } from '../Serialization/ProtobufDecorators';
|
||
|
||
/**
|
||
* 快照管理器
|
||
*
|
||
* 负责创建和管理ECS系统的快照，支持完整快照和增量快照
|
||
* 现在支持protobuf和JSON混合序列化
|
||
*/
|
||
export class SnapshotManager {
|
||
/** 默认快照配置 */
|
||
private static readonly DEFAULT_CONFIG: SnapshotConfig = {
|
||
includeInSnapshot: true,
|
||
compressionLevel: 0,
|
||
syncPriority: 5,
|
||
enableIncremental: true
|
||
};
|
||
|
||
/** 框架版本 */
|
||
private readonly version: string = '1.0.0';
|
||
|
||
/** 最后快照时间戳 */
|
||
private lastSnapshotTime: number = 0;
|
||
|
||
/** 快照缓存 */
|
||
private snapshotCache = new Map<string, SceneSnapshot>();
|
||
|
||
/** 最大缓存数量 */
|
||
private maxCacheSize: number = 10;
|
||
|
||
/** Protobuf序列化器 */
|
||
private protobufSerializer: ProtobufSerializer;
|
||
|
||
/**
|
||
* 构造函数
|
||
*/
|
||
constructor() {
|
||
this.protobufSerializer = ProtobufSerializer.getInstance();
|
||
}
|
||
|
||
/**
|
||
* 创建场景快照
|
||
*
|
||
* @param entities - 实体列表
|
||
* @param type - 快照类型
|
||
* @returns 场景快照
|
||
*/
|
||
public createSceneSnapshot(entities: Entity[], type: 'full' | 'incremental' = 'full'): SceneSnapshot {
|
||
const entitySnapshots: EntitySnapshot[] = [];
|
||
|
||
const sortedEntities = entities.sort((a, b) => a.id - b.id);
|
||
|
||
for (const entity of sortedEntities) {
|
||
if (entity.isDestroyed) continue;
|
||
|
||
const entitySnapshot = this.createEntitySnapshot(entity);
|
||
if (entitySnapshot) {
|
||
entitySnapshots.push(entitySnapshot);
|
||
}
|
||
}
|
||
|
||
const snapshot: SceneSnapshot = {
|
||
entities: entitySnapshots,
|
||
timestamp: Date.now(),
|
||
version: this.version,
|
||
type: type
|
||
};
|
||
|
||
this.lastSnapshotTime = snapshot.timestamp;
|
||
|
||
return snapshot;
|
||
}
|
||
|
||
/**
|
||
* 从快照恢复场景
|
||
*
|
||
* @param snapshot - 场景快照
|
||
* @param targetEntities - 目标实体列表（用于增量恢复）
|
||
* @param createMissingEntities - 是否创建缺失的实体
|
||
*/
|
||
public restoreFromSnapshot(snapshot: SceneSnapshot, targetEntities?: Entity[], createMissingEntities: boolean = false): Entity[] {
|
||
if (snapshot.type === 'incremental' && targetEntities) {
|
||
return this.restoreIncrementalSnapshot(snapshot, targetEntities);
|
||
} else {
|
||
return this.restoreFullSnapshot(snapshot, targetEntities, createMissingEntities);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 从快照恢复实体列表
|
||
*
|
||
* @param snapshot - 场景快照
|
||
* @param targetEntities - 目标实体列表
|
||
* @param createMissingEntities - 是否创建缺失的实体
|
||
*/
|
||
public restoreEntitiesFromSnapshot(snapshot: SceneSnapshot, targetEntities: Entity[], createMissingEntities: boolean = false): Entity[] {
|
||
const restoredEntities: Entity[] = [];
|
||
const targetEntityMap = new Map<number, Entity>();
|
||
|
||
for (const entity of targetEntities) {
|
||
targetEntityMap.set(entity.id, entity);
|
||
}
|
||
|
||
for (const entitySnapshot of snapshot.entities) {
|
||
let targetEntity = targetEntityMap.get(entitySnapshot.id);
|
||
|
||
if (!targetEntity && createMissingEntities) {
|
||
// 创建缺失的实体
|
||
const newEntity = this.createEntityFromSnapshot(entitySnapshot);
|
||
if (newEntity) {
|
||
restoredEntities.push(newEntity);
|
||
}
|
||
} else if (targetEntity) {
|
||
// 恢复现有实体
|
||
this.restoreEntityFromSnapshot(targetEntity, entitySnapshot);
|
||
restoredEntities.push(targetEntity);
|
||
}
|
||
}
|
||
|
||
return restoredEntities;
|
||
}
|
||
|
||
/**
|
||
* 从快照创建实体
|
||
*/
|
||
private createEntityFromSnapshot(entitySnapshot: EntitySnapshot): Entity | null {
|
||
try {
|
||
const entity = new Entity(entitySnapshot.name, entitySnapshot.id);
|
||
|
||
// 设置基本属性
|
||
entity.enabled = entitySnapshot.enabled;
|
||
entity.active = entitySnapshot.active;
|
||
entity.tag = entitySnapshot.tag;
|
||
entity.updateOrder = entitySnapshot.updateOrder;
|
||
|
||
// 创建组件
|
||
for (const componentSnapshot of entitySnapshot.components) {
|
||
this.createComponentFromSnapshot(entity, componentSnapshot);
|
||
}
|
||
|
||
return entity;
|
||
} catch (error) {
|
||
console.error(`[SnapshotManager] 创建实体失败: ${entitySnapshot.name}`, error);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 从快照创建组件
|
||
*/
|
||
private createComponentFromSnapshot(entity: Entity, componentSnapshot: ComponentSnapshot): void {
|
||
try {
|
||
// 尝试获取组件构造函数
|
||
const componentType = this.getComponentType(componentSnapshot.type);
|
||
if (!componentType) {
|
||
console.warn(`[SnapshotManager] 未知组件类型: ${componentSnapshot.type}`);
|
||
return;
|
||
}
|
||
|
||
// 创建组件实例
|
||
const component = entity.createComponent(componentType);
|
||
|
||
// 恢复组件启用状态
|
||
component.enabled = componentSnapshot.enabled;
|
||
|
||
// 恢复组件数据
|
||
if (this.hasSerializeMethod(component)) {
|
||
try {
|
||
(component as any).deserialize(componentSnapshot.data);
|
||
} catch (error) {
|
||
console.warn(`[SnapshotManager] 组件 ${componentSnapshot.type} 反序列化失败:`, error);
|
||
}
|
||
} else {
|
||
this.defaultDeserializeComponent(component, componentSnapshot.data);
|
||
}
|
||
} catch (error) {
|
||
console.error(`[SnapshotManager] 创建组件失败: ${componentSnapshot.type}`, error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取组件类型
|
||
*/
|
||
private getComponentType(typeName: string): any {
|
||
// 这里需要与组件注册系统集成
|
||
// 暂时返回null，实际实现需要组件类型管理器
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 创建快速快照（跳过变化检测）
|
||
*
|
||
* @param entities - 实体列表
|
||
* @returns 场景快照
|
||
*/
|
||
public createQuickSnapshot(entities: Entity[]): SceneSnapshot {
|
||
return this.createSceneSnapshot(entities, 'full');
|
||
}
|
||
|
||
/**
|
||
* 创建增量快照
|
||
*
|
||
* @param entities - 实体列表
|
||
* @param baseSnapshot - 基础快照
|
||
* @param enableChangeDetection - 是否启用变化检测
|
||
* @returns 增量快照
|
||
*/
|
||
public createIncrementalSnapshot(entities: Entity[], baseSnapshot: SceneSnapshot, enableChangeDetection: boolean = true): SceneSnapshot {
|
||
const incrementalEntities: EntitySnapshot[] = [];
|
||
|
||
const baseEntityMap = new Map<number, EntitySnapshot>();
|
||
for (const entity of baseSnapshot.entities) {
|
||
baseEntityMap.set(entity.id, entity);
|
||
}
|
||
|
||
for (const entity of entities) {
|
||
if (entity.isDestroyed) continue;
|
||
|
||
const baseEntity = baseEntityMap.get(entity.id);
|
||
if (!baseEntity) {
|
||
const entitySnapshot = this.createEntitySnapshot(entity);
|
||
if (entitySnapshot) {
|
||
incrementalEntities.push(entitySnapshot);
|
||
}
|
||
} else if (enableChangeDetection) {
|
||
const changedComponents = this.getChangedComponents(entity, baseEntity);
|
||
if (this.hasEntityStructureChanged(entity, baseEntity) || changedComponents.length > 0) {
|
||
const incrementalEntitySnapshot = this.createIncrementalEntitySnapshot(entity, baseEntity, changedComponents);
|
||
if (incrementalEntitySnapshot) {
|
||
incrementalEntities.push(incrementalEntitySnapshot);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
entities: incrementalEntities,
|
||
timestamp: Date.now(),
|
||
version: this.version,
|
||
type: 'incremental',
|
||
baseSnapshotId: this.generateSnapshotId(baseSnapshot)
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 缓存快照
|
||
*
|
||
* @param id - 快照ID
|
||
* @param snapshot - 快照数据
|
||
*/
|
||
public cacheSnapshot(id: string, snapshot: SceneSnapshot): void {
|
||
// 清理过期缓存
|
||
if (this.snapshotCache.size >= this.maxCacheSize) {
|
||
const oldestKey = this.snapshotCache.keys().next().value;
|
||
if (oldestKey) {
|
||
this.snapshotCache.delete(oldestKey);
|
||
}
|
||
}
|
||
|
||
this.snapshotCache.set(id, snapshot);
|
||
}
|
||
|
||
/**
|
||
* 获取缓存的快照
|
||
*
|
||
* @param id - 快照ID
|
||
* @returns 快照数据或undefined
|
||
*/
|
||
public getCachedSnapshot(id: string): SceneSnapshot | undefined {
|
||
return this.snapshotCache.get(id);
|
||
}
|
||
|
||
/**
|
||
* 清空快照缓存
|
||
*/
|
||
public clearCache(): void {
|
||
this.snapshotCache.clear();
|
||
}
|
||
|
||
/**
|
||
* 清空所有缓存
|
||
*/
|
||
public clearAllCaches(): void {
|
||
this.snapshotCache.clear();
|
||
}
|
||
|
||
/**
|
||
* 获取缓存统计信息
|
||
*/
|
||
public getCacheStats(): {
|
||
snapshotCacheSize: number;
|
||
protobufStats?: {
|
||
registeredComponents: number;
|
||
protobufAvailable: boolean;
|
||
};
|
||
} {
|
||
const stats: any = {
|
||
snapshotCacheSize: this.snapshotCache.size
|
||
};
|
||
|
||
if (this.protobufSerializer) {
|
||
stats.protobufStats = this.protobufSerializer.getStats();
|
||
}
|
||
|
||
return stats;
|
||
}
|
||
|
||
/**
|
||
* 手动初始化protobuf支持（可选，通常会自动初始化）
|
||
*
|
||
* @param protobufJs - protobuf.js库实例
|
||
*/
|
||
public initializeProtobuf(protobufJs: any): void {
|
||
if (this.protobufSerializer) {
|
||
this.protobufSerializer.initialize(protobufJs);
|
||
console.log('[SnapshotManager] Protobuf支持已手动启用');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 创建实体快照
|
||
*/
|
||
private createEntitySnapshot(entity: Entity): EntitySnapshot | null {
|
||
const componentSnapshots: ComponentSnapshot[] = [];
|
||
|
||
for (const component of entity.components) {
|
||
const componentSnapshot = this.createComponentSnapshot(component);
|
||
if (componentSnapshot) {
|
||
componentSnapshots.push(componentSnapshot);
|
||
}
|
||
}
|
||
|
||
return {
|
||
id: entity.id,
|
||
name: entity.name,
|
||
enabled: entity.enabled,
|
||
active: entity.active,
|
||
tag: entity.tag,
|
||
updateOrder: entity.updateOrder,
|
||
components: componentSnapshots,
|
||
children: entity.children.map(child => child.id),
|
||
parent: entity.parent?.id || undefined,
|
||
timestamp: Date.now()
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 创建组件快照
|
||
*
|
||
* 现在支持protobuf和JSON混合序列化
|
||
*/
|
||
private createComponentSnapshot(component: Component): ComponentSnapshot | null {
|
||
if (!this.isComponentSnapshotable(component)) {
|
||
return null;
|
||
}
|
||
|
||
let serializedData: SerializedData;
|
||
|
||
// 优先尝试protobuf序列化
|
||
if (isProtoSerializable(component) && this.protobufSerializer.canSerialize(component)) {
|
||
try {
|
||
serializedData = this.protobufSerializer.serialize(component);
|
||
} catch (error) {
|
||
console.warn(`[SnapshotManager] Protobuf序列化失败，回退到传统方式: ${component.constructor.name}`, error);
|
||
serializedData = this.createLegacySerializedData(component);
|
||
}
|
||
} else {
|
||
// 使用传统序列化方式
|
||
serializedData = this.createLegacySerializedData(component);
|
||
}
|
||
|
||
return {
|
||
type: component.constructor.name,
|
||
id: component.id,
|
||
data: serializedData,
|
||
enabled: component.enabled,
|
||
config: this.getComponentSnapshotConfig(component)
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 创建传统序列化数据
|
||
*/
|
||
private createLegacySerializedData(component: Component): SerializedData {
|
||
let data: any;
|
||
|
||
if (this.hasSerializeMethod(component)) {
|
||
try {
|
||
data = (component as any).serialize();
|
||
} catch (error) {
|
||
console.warn(`[SnapshotManager] 组件序列化失败: ${component.constructor.name}`, error);
|
||
data = this.defaultSerializeComponent(component);
|
||
}
|
||
} else {
|
||
data = this.defaultSerializeComponent(component);
|
||
}
|
||
|
||
const jsonString = JSON.stringify(data);
|
||
return {
|
||
type: 'json',
|
||
componentType: component.constructor.name,
|
||
data: data,
|
||
size: new Blob([jsonString]).size
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 默认组件序列化
|
||
*/
|
||
private defaultSerializeComponent(component: Component): any {
|
||
const data: any = {};
|
||
|
||
// 只序列化公共属性
|
||
for (const key in component) {
|
||
if (component.hasOwnProperty(key) &&
|
||
typeof (component as any)[key] !== 'function' &&
|
||
key !== 'id' &&
|
||
key !== 'entity' &&
|
||
key !== '_enabled' &&
|
||
key !== '_updateOrder') {
|
||
|
||
const value = (component as any)[key];
|
||
if (this.isSerializableValue(value)) {
|
||
data[key] = value;
|
||
}
|
||
}
|
||
}
|
||
|
||
return data;
|
||
}
|
||
|
||
/**
|
||
* 检查值是否可序列化
|
||
*/
|
||
private isSerializableValue(value: any): boolean {
|
||
if (value === null || value === undefined) return true;
|
||
if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return true;
|
||
if (Array.isArray(value)) return value.every(v => this.isSerializableValue(v));
|
||
if (typeof value === 'object') {
|
||
// 简单对象检查，避免循环引用
|
||
try {
|
||
JSON.stringify(value);
|
||
return true;
|
||
} catch {
|
||
return false;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 检查组件是否支持快照
|
||
*/
|
||
private isComponentSnapshotable(component: Component): boolean {
|
||
// 检查是否有快照配置
|
||
const config = this.getComponentSnapshotConfig(component);
|
||
return config.includeInSnapshot;
|
||
}
|
||
|
||
/**
|
||
* 获取组件快照配置
|
||
*/
|
||
private getComponentSnapshotConfig(component: Component): SnapshotConfig {
|
||
// 检查组件是否有自定义配置
|
||
if ((component as any).snapshotConfig) {
|
||
return { ...SnapshotManager.DEFAULT_CONFIG, ...(component as any).snapshotConfig };
|
||
}
|
||
|
||
return SnapshotManager.DEFAULT_CONFIG;
|
||
}
|
||
|
||
/**
|
||
* 检查组件是否有序列化方法
|
||
*/
|
||
private hasSerializeMethod(component: Component): boolean {
|
||
return typeof (component as any).serialize === 'function';
|
||
}
|
||
|
||
/**
|
||
* 恢复完整快照
|
||
*/
|
||
private restoreFullSnapshot(snapshot: SceneSnapshot, targetEntities?: Entity[], createMissingEntities: boolean = false): Entity[] {
|
||
if (targetEntities && createMissingEntities) {
|
||
return this.restoreEntitiesFromSnapshot(snapshot, targetEntities, true);
|
||
} else if (targetEntities) {
|
||
return this.restoreEntitiesFromSnapshot(snapshot, targetEntities, false);
|
||
} else {
|
||
const restoredEntities: Entity[] = [];
|
||
for (const entitySnapshot of snapshot.entities) {
|
||
const entity = this.createEntityFromSnapshot(entitySnapshot);
|
||
if (entity) {
|
||
restoredEntities.push(entity);
|
||
}
|
||
}
|
||
return restoredEntities;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 恢复增量快照
|
||
*/
|
||
private restoreIncrementalSnapshot(snapshot: SceneSnapshot, targetEntities: Entity[]): Entity[] {
|
||
const restoredEntities: Entity[] = [];
|
||
const targetEntityMap = new Map<number, Entity>();
|
||
|
||
for (const entity of targetEntities) {
|
||
targetEntityMap.set(entity.id, entity);
|
||
}
|
||
|
||
for (const entitySnapshot of snapshot.entities) {
|
||
const targetEntity = targetEntityMap.get(entitySnapshot.id);
|
||
if (targetEntity) {
|
||
this.restoreEntityFromSnapshot(targetEntity, entitySnapshot);
|
||
restoredEntities.push(targetEntity);
|
||
}
|
||
}
|
||
|
||
return restoredEntities;
|
||
}
|
||
|
||
/**
|
||
* 从快照恢复实体
|
||
*/
|
||
private restoreEntityFromSnapshot(entity: Entity, entitySnapshot: EntitySnapshot): void {
|
||
// 恢复实体基本属性
|
||
entity.enabled = entitySnapshot.enabled;
|
||
entity.active = entitySnapshot.active;
|
||
entity.tag = entitySnapshot.tag;
|
||
entity.updateOrder = entitySnapshot.updateOrder;
|
||
|
||
// 恢复组件
|
||
for (const componentSnapshot of entitySnapshot.components) {
|
||
this.restoreComponentFromSnapshot(entity, componentSnapshot);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 从快照恢复组件
|
||
*
|
||
* 现在支持protobuf和JSON混合反序列化
|
||
*/
|
||
private restoreComponentFromSnapshot(entity: Entity, componentSnapshot: ComponentSnapshot): void {
|
||
// 查找现有组件
|
||
let component = entity.getComponent(componentSnapshot.type as any);
|
||
|
||
if (!component) {
|
||
// 组件不存在，需要创建
|
||
console.warn(`[SnapshotManager] 组件 ${componentSnapshot.type} 不存在于实体 ${entity.name}，无法恢复`);
|
||
return;
|
||
}
|
||
|
||
// 恢复组件启用状态
|
||
component.enabled = componentSnapshot.enabled;
|
||
|
||
// 恢复组件数据
|
||
const serializedData = componentSnapshot.data as SerializedData;
|
||
|
||
// 检查数据是否为新的SerializedData格式
|
||
if (serializedData && typeof serializedData === 'object' && 'type' in serializedData) {
|
||
// 使用新的序列化格式
|
||
if (serializedData.type === 'protobuf' && isProtoSerializable(component)) {
|
||
try {
|
||
this.protobufSerializer.deserialize(component, serializedData);
|
||
} catch (error) {
|
||
console.warn(`[SnapshotManager] Protobuf反序列化失败: ${componentSnapshot.type}`, error);
|
||
}
|
||
} else if (serializedData.type === 'json') {
|
||
// JSON格式反序列化
|
||
this.deserializeLegacyData(component, serializedData.data);
|
||
}
|
||
} else {
|
||
// 兼容旧格式数据
|
||
this.deserializeLegacyData(component, componentSnapshot.data);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 反序列化传统格式数据
|
||
*/
|
||
private deserializeLegacyData(component: Component, data: any): void {
|
||
if (this.hasSerializeMethod(component)) {
|
||
try {
|
||
(component as any).deserialize(data);
|
||
} catch (error) {
|
||
console.warn(`[SnapshotManager] 组件 ${component.constructor.name} 反序列化失败:`, error);
|
||
}
|
||
} else {
|
||
// 使用默认反序列化
|
||
this.defaultDeserializeComponent(component, data);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 默认组件反序列化
|
||
*/
|
||
private defaultDeserializeComponent(component: Component, data: any): void {
|
||
for (const key in data) {
|
||
if (component.hasOwnProperty(key) &&
|
||
typeof (component as any)[key] !== 'function' &&
|
||
key !== 'id' &&
|
||
key !== 'entity' &&
|
||
key !== '_enabled' &&
|
||
key !== '_updateOrder') {
|
||
|
||
(component as any)[key] = data[key];
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检查实体结构是否发生变化（组件数量、类型等）
|
||
*/
|
||
private hasEntityStructureChanged(entity: Entity, baseSnapshot: EntitySnapshot): boolean {
|
||
// 检查基本属性变化
|
||
if (entity.enabled !== baseSnapshot.enabled ||
|
||
entity.active !== baseSnapshot.active ||
|
||
entity.tag !== baseSnapshot.tag ||
|
||
entity.updateOrder !== baseSnapshot.updateOrder) {
|
||
return true;
|
||
}
|
||
|
||
// 检查组件数量变化
|
||
if (entity.components.length !== baseSnapshot.components.length) {
|
||
return true;
|
||
}
|
||
|
||
// 检查组件类型变化
|
||
const currentComponentTypes = new Set(entity.components.map(c => c.constructor.name));
|
||
const baseComponentTypes = new Set(baseSnapshot.components.map(c => c.type));
|
||
|
||
if (currentComponentTypes.size !== baseComponentTypes.size) {
|
||
return true;
|
||
}
|
||
|
||
for (const type of currentComponentTypes) {
|
||
if (!baseComponentTypes.has(type)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 获取发生变化的组件列表
|
||
*/
|
||
private getChangedComponents(entity: Entity, baseSnapshot: EntitySnapshot): ComponentSnapshot[] {
|
||
const changedComponents: ComponentSnapshot[] = [];
|
||
|
||
const baseComponentMap = new Map<string, ComponentSnapshot>();
|
||
for (const comp of baseSnapshot.components) {
|
||
baseComponentMap.set(comp.type, comp);
|
||
}
|
||
|
||
for (const component of entity.components) {
|
||
const baseComponent = baseComponentMap.get(component.constructor.name);
|
||
|
||
if (!baseComponent) {
|
||
const componentSnapshot = this.createComponentSnapshot(component);
|
||
if (componentSnapshot) {
|
||
changedComponents.push(componentSnapshot);
|
||
}
|
||
} else {
|
||
if (this.hasComponentDataChanged(component, baseComponent)) {
|
||
const componentSnapshot = this.createComponentSnapshot(component);
|
||
if (componentSnapshot) {
|
||
changedComponents.push(componentSnapshot);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return changedComponents;
|
||
}
|
||
|
||
/**
|
||
* 检查组件数据是否发生变化
|
||
*/
|
||
private hasComponentDataChanged(component: Component, baseComponent: ComponentSnapshot): boolean {
|
||
if (component.enabled !== baseComponent.enabled) {
|
||
return true;
|
||
}
|
||
|
||
if (this.hasChangeDetectionMethod(component)) {
|
||
try {
|
||
return (component as any).hasChanged(baseComponent.data);
|
||
} catch {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 检查组件是否有变化检测方法
|
||
*/
|
||
private hasChangeDetectionMethod(component: Component): boolean {
|
||
return typeof (component as any).hasChanged === 'function';
|
||
}
|
||
|
||
/**
|
||
* 创建增量实体快照（只包含变化的组件）
|
||
*/
|
||
private createIncrementalEntitySnapshot(entity: Entity, baseSnapshot: EntitySnapshot, changedComponents: ComponentSnapshot[]): EntitySnapshot | null {
|
||
// 检查实体基本属性是否变化
|
||
const hasBasicChanges = entity.enabled !== baseSnapshot.enabled ||
|
||
entity.active !== baseSnapshot.active ||
|
||
entity.tag !== baseSnapshot.tag ||
|
||
entity.updateOrder !== baseSnapshot.updateOrder;
|
||
|
||
// 如果没有基本变化且没有组件变化，返回null
|
||
if (!hasBasicChanges && changedComponents.length === 0) {
|
||
return null;
|
||
}
|
||
|
||
return {
|
||
id: entity.id,
|
||
name: entity.name,
|
||
enabled: entity.enabled,
|
||
active: entity.active,
|
||
tag: entity.tag,
|
||
updateOrder: entity.updateOrder,
|
||
components: changedComponents, // 只包含变化的组件
|
||
children: entity.children.map(child => child.id),
|
||
parent: entity.parent?.id || undefined,
|
||
timestamp: Date.now()
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 生成快照ID
|
||
*/
|
||
private generateSnapshotId(snapshot: SceneSnapshot): string {
|
||
return `${snapshot.timestamp}_${snapshot.entities.length}`;
|
||
}
|
||
}
|