@kkarum/framework 2.3.17

package/manager/FWLayerManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "763150db-103d-4078-9dab-48f9ced9015a",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWManager.ts

@@ -0,0 +1,9 @@
+export abstract class FWManager extends FW.FrameworkBase implements FW.Manager {
+  public abstract initialize(): void;
+  public abstract onDestroy(): void;
+
+  protected onRestart() {
+    this.onDestroy();
+    this.initialize();
+  }
+}

package/manager/FWManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "f2b4d729-7f2a-4065-823f-d998a5d4f449",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWObjectManager.ts

@@ -0,0 +1,161 @@
+import { FWObjectPool } from "../utils/FWObjectPool";
+import { FWManager } from "./FWManager";
+
+export default class FWObjectManager
+  extends FWManager
+  implements FW.ObjectManager
+{
+  public initialize(): void {
+    this.poolMap = new Map<string, FWObjectPool>();
+    this.poolIdCounter = 0;
+  }
+
+  public onDestroy(): void {
+    this.poolMap.forEach((pool, tag) => {
+      try {
+        pool.onDestroy();
+      } catch (error) {
+        FW.Log.error(`销毁对象池失败: ${tag}`, error);
+      }
+    });
+    this.poolMap.clear();
+  }
+
+  private poolMap: Map<string, FWObjectPool>;
+  private poolIdCounter: number = 0;
+
+  async createObjectPool<T extends FW.Object = FW.Object>(
+    node: cc.Node,
+    parent: cc.Node,
+    tag?: string,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<T extends FW.Object = FW.Object>(
+    prefab: cc.Prefab,
+    parent: cc.Node,
+    tag?: string,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<T extends FW.Object = FW.Object>(
+    assetProperty: FW.AssetProperty,
+    parent: cc.Node,
+    tag?: string,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<T extends FW.Object = FW.Object>(
+    node: cc.Node,
+    parent: cc.Node,
+    type?: number,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<T extends FW.Object = FW.Object>(
+    prefab: cc.Prefab,
+    parent: cc.Node,
+    type?: number,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<T extends FW.Object = FW.Object>(
+    assetProperty: FW.AssetProperty,
+    parent: cc.Node,
+    type?: number,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<
+    T extends FW.Object = FW.Object,
+  >(): Promise<FWObjectPool> {
+    if (arguments.length < 2 || arguments.length > 3) {
+      FW.Log.error("createObjectPool 参数数量错误,需要2-3个参数");
+      throw new Error("Invalid arguments count");
+    }
+
+    let objectNode: cc.Node = null;
+    let objectPrefab: cc.Prefab = null;
+    let objectAssetProperty: FW.AssetProperty = null;
+    let objectParent: cc.Node;
+    let objectTag: string;
+    let objectType: FW.SystemDefine.FWObjectType;
+
+    try {
+      const resources = arguments[0];
+      if (resources instanceof cc.Node) {
+        objectNode = resources;
+      } else if (resources instanceof cc.Prefab) {
+        objectPrefab = resources;
+        objectNode = cc.instantiate(objectPrefab);
+      } else {
+        objectAssetProperty = resources;
+        objectPrefab =
+          await FW.Entry.resMgr.loadAsset<cc.Prefab>(objectAssetProperty);
+        if (!objectPrefab) {
+          throw new Error(`加载预制体失败: ${objectAssetProperty.path}`);
+        }
+        objectNode = cc.instantiate(objectPrefab);
+      }
+
+      objectParent = arguments[1];
+      if (!(objectParent instanceof cc.Node)) {
+        throw new Error("第二个参数必须是 cc.Node 类型");
+      }
+
+      const arg = arguments[2];
+      if (typeof arg === "string") {
+        objectTag = arg;
+        objectType = FW.SystemDefine.FWObjectType.OPACITY;
+      } else if (typeof arg === "number") {
+        objectTag = `pool_${this.poolIdCounter++}`;
+        objectType = arg;
+      } else {
+        objectTag = `pool_${this.poolIdCounter++}`;
+        objectType = FW.SystemDefine.FWObjectType.OPACITY;
+      }
+
+      if (this.poolMap.has(objectTag)) {
+        this.destroyObjectPool(objectTag);
+      }
+
+      const pool = new FWObjectPool<T>(objectNode, objectParent, objectType);
+      this.poolMap.set(objectTag, pool);
+
+      return pool;
+    } catch (error) {
+      FW.Log.error("创建对象池失败:", error);
+
+      if (objectNode && objectNode.isValid) {
+        objectNode.destroy();
+      }
+
+      throw error;
+    }
+  }
+
+  getObjectPool(tag: string): FWObjectPool | undefined {
+    if (!this.poolMap.has(tag)) {
+      FW.Log.warn(`对象池不存在: ${tag}`);
+      return undefined;
+    }
+    return this.poolMap.get(tag);
+  }
+
+  destroyObjectPool(tag: string): boolean {
+    if (!this.poolMap.has(tag)) {
+      return false;
+    }
+
+    try {
+      const pool = this.poolMap.get(tag);
+      pool.onDestroy();
+      this.poolMap.delete(tag);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  getPoolStats(): { total: number; tags: string[] } {
+    return {
+      total: this.poolMap.size,
+      tags: Array.from(this.poolMap.keys()),
+    };
+  }
+
+  clearAllPools(): void {
+    const tags = Array.from(this.poolMap.keys());
+    tags.forEach((tag) => {
+      this.destroyObjectPool(tag);
+    });
+  }
+}

package/manager/FWObjectManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "a490a2b7-8487-4fe1-a3ce-fbb473a39530",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWPerformanceManager.ts

@@ -0,0 +1,198 @@
+import { FWManager } from './FWManager';
+
+/**
+ * 性能管理器
+ */
+export class FWPerformanceManager extends FWManager implements FW.PerformanceManager {
+  private metrics: FW.PerformanceMetric[] = [];
+  private moduleStats: Map<
+    string,
+    {
+      totalDuration: number;
+      operationCount: number;
+      minDuration: number;
+      maxDuration: number;
+    }
+  > = new Map();
+
+  private performanceOptions: FW.PerformanceModuleOptions;
+
+  public async initialize(): Promise<void> {
+    this.performanceOptions = {
+      autoCollect: true,
+      dataRetentionTime: 5 * 60 * 1000,
+      samplingRate: 1.0,
+      warningThreshold: 1000,
+    };
+    if (this.performanceOptions.autoCollect) {
+      this.autoClear();
+    }
+  }
+
+  public onDestroy(): void {
+    this.metrics = [];
+    this.moduleStats.clear();
+  }
+
+  protected onCleanup(): void {}
+
+  /**
+   * 记录操作性能指标
+   */
+  public recordOperationMetric(module: string, operation: string, duration: number): void {
+    if (Math.random() > this.performanceOptions.samplingRate!) {
+      return;
+    }
+    const metric: FW.PerformanceMetric = {
+      module,
+      operation,
+      duration,
+      timestamp: Date.now(),
+    };
+
+    this.metrics.push(metric);
+    this.updateModuleStats(module, duration);
+
+    if (duration > this.performanceOptions.warningThreshold!) {
+      FW.Log.warn(`Performance warning: ${module}.${operation} took ${duration}ms`);
+    }
+  }
+
+  /**
+   * 获取指定模块的性能报告
+   */
+  public getModuleReport(module: string): FW.PerformanceReport | null {
+    const stats = this.moduleStats.get(module);
+    if (!stats) {
+      return null;
+    }
+
+    const recentMetrics = this.metrics.filter((m) => m.module === module).slice(-500);
+
+    return {
+      module,
+      totalOperations: stats.operationCount,
+      averageDuration: stats.totalDuration / stats.operationCount,
+      minDuration: stats.minDuration,
+      maxDuration: stats.maxDuration,
+      recentMetrics,
+    };
+  }
+
+  /**
+   * 获取所有管理器的性能报告
+   */
+  public getAllReports(): Map<string, FW.PerformanceReport> {
+    const reports = new Map<string, FW.PerformanceReport>();
+
+    this.moduleStats.forEach((stats, module) => {
+      const recentMetrics = this.metrics.filter((m) => m.module === module).slice(-500);
+      reports.set(module, {
+        module,
+        totalOperations: stats.operationCount,
+        averageDuration: stats.totalDuration / stats.operationCount,
+        minDuration: stats.minDuration,
+        maxDuration: stats.maxDuration,
+        recentMetrics,
+      });
+    });
+
+    return reports;
+  }
+
+  /**
+   * 获取性能摘要
+   */
+  public getPerformanceSummary(): {
+    totalOperations: number;
+    averageOperationTime: number;
+    slowestModule: string;
+    mostActiveModule: string;
+  } {
+    let totalOperations = 0;
+    let totalDuration = 0;
+    let slowestModule = '';
+    let maxAvgDuration = 0;
+    let mostActiveModule = '';
+    let maxOperations = 0;
+
+    this.moduleStats.forEach((stats, module) => {
+      totalOperations += stats.operationCount;
+      totalDuration += stats.totalDuration;
+
+      const avgDuration = stats.totalDuration / stats.operationCount;
+      if (avgDuration > maxAvgDuration) {
+        maxAvgDuration = avgDuration;
+        slowestModule = module;
+      }
+
+      if (stats.operationCount > maxOperations) {
+        maxOperations = stats.operationCount;
+        mostActiveModule = module;
+      }
+    });
+
+    return {
+      totalOperations,
+      averageOperationTime: totalOperations > 0 ? totalDuration / totalOperations : 0,
+      slowestModule: slowestModule,
+      mostActiveModule: mostActiveModule,
+    };
+  }
+
+  /**
+   * 清理数据
+   */
+  public clearPerformanceData(
+    retentionTime: number = this.performanceOptions.dataRetentionTime!,
+  ): number {
+    const cutoffTime = Date.now() - retentionTime;
+    const initialLength = this.metrics.length;
+
+    this.metrics = this.metrics.filter((metric) => metric.timestamp > cutoffTime);
+
+    const removedCount = initialLength - this.metrics.length;
+    if (removedCount > 0) {
+      FW.Log.debug(`Cleaned up ${removedCount} old performance records`);
+    }
+
+    return removedCount;
+  }
+
+  /**
+   * 重置所有性能数据
+   */
+  public resetAllData(): void {
+    this.metrics = [];
+    this.moduleStats.clear();
+  }
+
+  /**
+   * 更新管理器统计信息
+   */
+  private updateModuleStats(module: string, duration: number): void {
+    if (!this.moduleStats.has(module)) {
+      this.moduleStats.set(module, {
+        totalDuration: 0,
+        operationCount: 0,
+        minDuration: Infinity,
+        maxDuration: -Infinity,
+      });
+    }
+
+    const stats = this.moduleStats.get(module)!;
+    stats.totalDuration += duration;
+    stats.operationCount++;
+    stats.minDuration = Math.min(stats.minDuration, duration);
+    stats.maxDuration = Math.max(stats.maxDuration, duration);
+  }
+
+  /**
+   * 启动自动清理任务
+   */
+  private autoClear(): void {
+    FW.Entry.timeMgr.schedule(() => {
+      this.clearPerformanceData();
+    }, 300);
+  }
+}

package/manager/FWPerformanceManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "a593b057-a7d5-4dd4-ac81-3c8a70694bd2",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}