@kkarum/framework 2.3.17

package/manager/FWLayerManager.ts

@@ -0,0 +1,862 @@
+import { FWManager } from './FWManager';
+import { FWQueue } from '../utils/FWQueue';
+import { FrameworkBase } from '../FrameworkBase';
+import { PerformanceMonitor } from '../expand/FWDecorator';
+
+const ADD_EXTERNAL_REFERENCE: string = 'addExternalReference';
+
+export class FWLayerManager extends FWManager implements FW.LayerManager {
+  private resourceManager: FWLayerResourceManager;
+  private dataManager: FWLayerDataManager;
+  private createManager: FWLayerCreateManager;
+  private stackManager: FWLayerStackManager;
+  private stateManager: FWLayerStateManager;
+  private queueManager: FWLayerQueueManager;
+  private openManager: FWLayerOpenManager;
+  private debug: boolean;
+
+  public initialize(): void {
+    this.debug = false;
+    this.resourceManager = new FWLayerResourceManager();
+    this.dataManager = new FWLayerDataManager();
+    this.createManager = new FWLayerCreateManager();
+    this.stackManager = new FWLayerStackManager();
+    this.queueManager = new FWLayerQueueManager();
+    this.stateManager = new FWLayerStateManager();
+    this.openManager = new FWLayerOpenManager(
+      this.dataManager,
+      this.resourceManager,
+      this.createManager,
+      this.stackManager,
+      this.queueManager,
+      this.stateManager,
+    );
+  }
+
+  openDebug() {
+    this.debug = true;
+  }
+
+  isDebug() {
+    return this.debug;
+  }
+  /**
+   * 异步打开Layer
+   */
+  @PerformanceMonitor('openAsync')
+  async openAsync<Ctr extends FW.LayerController = FW.LayerController>(
+    data: FW.LayerOpenArgs,
+  ): Promise<Ctr> {
+    if (this.debug) {
+      FW.Log.error(`异步打开Layer ->`, cc.js.getClassName(data.type));
+    }
+    return this.openManager.openLayerAsync(data) as Promise<Ctr>;
+  }
+
+  /**
+   * 同步打开
+   */
+  openSync<Ctr extends FW.LayerController = FW.LayerController>(data: FW.LayerOpenArgs): Ctr {
+    if (this.debug) {
+      FW.Log.error(`同步打开Layer ->`, cc.js.getClassName(data.type));
+    }
+    return this.openManager.openLayerSync(data) as Ctr;
+  }
+
+  /**
+   * 显示layer并恢复所有节点事件
+   */
+  displayLayer<Ctr extends FW.LayerController = FW.LayerController>(ctr: Ctr): Ctr {
+    const layerData = ctr.layerData;
+
+    if (!this.dataManager.getLayerMap().has(ctr.layerData.controllerConstructor)) {
+      FW.Log.warn(`display layer failed,layer name : ${layerData.layerName}`);
+      return;
+    }
+    /** 非常驻layer不允许操作透明度显示 */
+    if (ctr.layerType != FW.SystemDefine.FWLayerType.PERMANENT) return;
+
+    const node = ctr.layer.node;
+    node.opacity = 255;
+    node.resumeSystemEvents(true);
+
+    FW.Entry.evtMgr.targetResume(ctr);
+    FW.Entry.timeMgr.resumeSchedule(ctr);
+
+    return ctr;
+  }
+
+  /**
+   * 隐藏layer并隐藏所有节点事件
+   */
+  hideLayer<Ctr extends FW.LayerController = FW.LayerController>(ctr: Ctr): Ctr {
+    const layerData = ctr.layerData;
+    if (!this.dataManager.getLayerMap().has(ctr.layerData.controllerConstructor)) {
+      FW.Log.warn(`hide layer failed,layer name : ${layerData.layerName}`);
+      return;
+    }
+
+    /** 非常驻layer不允许操作透明度 */
+    if (ctr.layerType != FW.SystemDefine.FWLayerType.PERMANENT) return;
+
+    const node = ctr.layer.node;
+    node.opacity = 0;
+    node.pauseSystemEvents(true);
+    FW.Entry.evtMgr.targetPause(ctr);
+    FW.Entry.timeMgr.pauseSchedule(ctr);
+
+    return ctr;
+  }
+
+  /**
+   * 通过layer名字关闭
+   */
+  closeFromLayerName(name: string | string[]): void {
+    this.dataManager.getLayerMap().forEach((v) => {
+      if (Array.isArray(name)) {
+        name.forEach((n) => {
+          if (n === v.layerName) {
+            this.close(v.controller);
+          }
+        });
+      } else {
+        if (v.layerName == name) {
+          this.close(v.controller);
+        }
+      }
+    });
+  }
+
+  /**
+   * 从栈关闭
+   */
+  closeFromStack(count?: number) {
+    count = count ? count : 1;
+    for (let i = 0; i < count; i++) {
+      let layerData = this.stackManager.pop();
+      let ctr = layerData.controller;
+      if (!this.dataManager.getLayerMap().has(layerData.controllerConstructor)) {
+        return;
+      }
+      if (cc.isValid(ctr.layer?.node)) {
+        ctr.layer.destroy?.();
+        if (ctr.autoRelease) {
+          FW.Entry.resMgr.releaseAsset(ctr.layerData.layerAssetProperty);
+        }
+        this.dataManager.notifyExternalRefUpdates(ctr.layerData);
+      }
+      this.dataManager.removeFromMap(layerData.controllerConstructor);
+    }
+  }
+  /**
+   * 移除指定Layer所有子Layer
+   * @param layer
+   * @returns
+   */
+  async removeAllChildren(node: cc.Node) {
+    if (!cc.isValid(node)) return;
+    const layers = node.getComponentsInChildren(FW.Layer);
+    layers.forEach((v) => {
+      if (cc.isValid(v?.node)) {
+        v?.ctr?.close();
+      }
+    });
+  }
+
+  /**
+   * 关闭layer
+   */
+  async close<Ctr extends FW.LayerController = FW.LayerController>(ctr: Ctr): Promise<Ctr> {
+    if (!ctr) return;
+
+    return FW.Entry.promiseMgr.execute(async (resolve, reject) => {
+      let layerData = ctr.layerData;
+
+      if (this.debug) {
+        FW.Log.error(`${cc.js.getClassName(layerData?.controllerConstructor)} ->关闭Layer`);
+      }
+
+      if (cc.isValid(ctr.layer?.node)) {
+        this.stateManager.setState(
+          ctr.layerData.controllerConstructor,
+          FW.SystemDefine.FWLayerState.CLOSING,
+        );
+
+        await ctr.onClose?.();
+
+        this.stateManager.setState(
+          ctr.layerData.controllerConstructor,
+          FW.SystemDefine.FWLayerState.CLOSED,
+        );
+
+        ctr.destroy?.();
+
+        if (ctr.autoRelease) {
+          FW.Entry.resMgr.releaseAsset(ctr.layerData.layerAssetProperty);
+        }
+        this.dataManager.notifyExternalRefUpdates(ctr.layerData);
+      }
+      this.stateManager.removeState(layerData?.controllerConstructor);
+      this.dataManager.removeFromMap(layerData?.controllerConstructor);
+      this.dataManager.removeFromRegistry(ctr.layerData?.controllerConstructor);
+
+      const index = this.stackManager.getStack().findIndex((v) => {
+        return v.controller == ctr;
+      });
+      if (index > -1) {
+        this.stackManager.getStack().splice(index, 1);
+      }
+
+      /** 如果队列中还有等待打开的layer */
+      if (!this.queueManager.isEmpty()) {
+        const nextLayerData = this.queueManager.getNextLayer();
+        /** 先尝试同步打开 */
+        const nextLayer = this.openSync({
+          parent: nextLayerData.layerParent,
+          position: nextLayerData.layerPosition,
+          type: nextLayerData.controllerConstructor,
+        });
+        /** 如果同步打开失败,再次尝试异步打开(可能由于资源所在bundle并未提前加载) */
+        if (!nextLayer) {
+          resolve(
+            this.openAsync({
+              parent: nextLayerData.layerParent,
+              position: nextLayerData.layerPosition,
+              type: nextLayerData.controllerConstructor,
+            }),
+          );
+        } else {
+          resolve(nextLayer as Ctr);
+        }
+      } else {
+        resolve(undefined);
+      }
+    }).promise;
+  }
+
+  getLayerMap(): Map<new () => FW.LayerController, FWLayerData> {
+    return this.dataManager.getLayerMap();
+  }
+
+  public clear() {
+    this.dataManager.getLayerMap().forEach((v) => this.close(v.controller));
+    this.queueManager.clear();
+    this.stackManager.clear();
+    this.stateManager.clear();
+    this.dataManager.clear();
+  }
+
+  public onDestroy(): void {
+    this.clear();
+  }
+}
+
+export class FWLayerData<T extends FW.LayerController = FW.LayerController>
+  implements FW.LayerData
+{
+  controllerConstructor: new () => T;
+  uuid: string;
+  layer: FW.Layer;
+  layerName: string;
+  layerAssetProperty: FW.AssetProperty;
+  layerRenderOrder: FW.SystemDefine.FWLayerRenderOrder;
+  layerType: FW.SystemDefine.FWLayerType;
+  layerParent?: cc.Node;
+  layerPosition?: FW.Vec3;
+  controllerName: string;
+  controller: FW.LayerController;
+  loaded: boolean;
+  controllerProxy: FW.LayerController;
+  externalReference?: Set<(ref: FW.LayerController | null) => void>;
+}
+
+class FWLayerDataManager {
+  private layerMap: Map<new () => FW.LayerController, FWLayerData> = new Map();
+  private layerRegistry: Set<new () => FW.LayerController> = new Set();
+  private layerControllerFactory: FWLayerControllerFactory = new FWLayerControllerFactory();
+  /**
+   * 获取已存在的Layer
+   */
+  getExistingLayer<Ctr extends FW.LayerController = FW.LayerController>(
+    type: new () => Ctr,
+  ): Ctr | undefined {
+    for (const [key, value] of this.layerMap) {
+      if (value.controllerConstructor === type) {
+        return value.controllerProxy as Ctr;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * 从类型创建Layer数据
+   */
+  createLayerData<Ctr extends FW.LayerController = FW.LayerController>(
+    type: new () => Ctr,
+  ): FW.LayerData {
+    const ctr = this.layerControllerFactory.createController(type);
+    const ctrName = cc.js.getClassName(ctr);
+    const layerData = this.generationData(ctr);
+
+    layerData.controllerConstructor = type;
+    layerData.controller = ctr;
+    layerData.controllerName = ctrName;
+
+    return layerData;
+  }
+
+  addLayerData(ctr: new () => FW.LayerController, layerData: FW.LayerData) {
+    if (!this.layerMap.has(ctr)) {
+      this.layerMap.set(ctr, layerData);
+    }
+  }
+
+  /**
+   * 生成数据
+   */
+  private generationData(ctr: FW.LayerController): FWLayerData {
+    const layerData = new FWLayerData();
+    const layerType = ctr.layerType;
+
+    layerData.layerRenderOrder = ctr.renderOrder;
+    layerData.layerAssetProperty = ctr.layerAssetProperty;
+    layerData.layerType = layerType;
+    layerData.controller = ctr;
+    layerData.loaded = false;
+    layerData.externalReference = new Set();
+
+    return layerData;
+  }
+
+  /**
+   * 状态表注册
+   */
+  addRegistry(type: new () => FW.LayerController): boolean {
+    if (this.layerRegistry.has(type)) {
+      return true;
+    }
+    this.layerRegistry.add(type);
+    return false;
+  }
+
+  /**
+   * 获取已存在的代理
+   */
+  getExistingProxy<Ctr extends FW.LayerController = FW.LayerController>(
+    type: new () => Ctr,
+  ): Ctr | undefined {
+    return this.layerMap.get(type)?.controllerProxy as Ctr;
+  }
+
+  /**
+   * 设置Layer数据
+   */
+  setupLayerData(
+    layerData: FWLayerData,
+    res: { asset: cc.Prefab; uuid: string },
+    layer: FW.Layer,
+    layerName: string,
+  ): void {
+    layerData.loaded = true;
+    layerData.layer = layer;
+    layerData.layerName = layerName;
+    layerData.uuid = res.uuid;
+
+    layerData.controller.layerData = layerData;
+    layerData.controller.layer = layer;
+    layerData.controller.uuid = res.uuid;
+
+    layer.ctr = layerData.controller;
+  }
+
+  /**
+   * 创建控制器代理
+   */
+  createControllerProxy(layerData: FWLayerData): FW.LayerController {
+    return new Proxy(layerData.controller, {
+      get: (target, prop) => {
+        if (prop === ADD_EXTERNAL_REFERENCE) {
+          return (cb: (ref: FW.LayerController | null) => void) => {
+            layerData.externalReference.add(cb);
+          };
+        }
+        return target[prop];
+      },
+    });
+  }
+
+  /**
+   * 清理失败的Layer
+   */
+  clearFailedLayer(layerData: FWLayerData): void {
+    this.layerMap.delete(layerData.controllerConstructor);
+    this.layerRegistry.delete(layerData.controllerConstructor);
+  }
+
+  /**
+   * 通知外部引用更新
+   */
+  notifyExternalRefUpdates(layerData: FWLayerData): void {
+    layerData.externalReference.forEach((cb) => {
+      try {
+        cb?.(null);
+      } catch (e) {
+        FW.Log.error('External ref update callback error:', e);
+      }
+    });
+    layerData.externalReference.clear();
+  }
+
+  getLayerMap(): Map<new () => FW.LayerController, FWLayerData> {
+    return this.layerMap;
+  }
+
+  removeFromRegistry(type: new () => FW.LayerController): void {
+    this.layerRegistry.delete(type);
+  }
+
+  removeFromMap(type: new () => FW.LayerController): void {
+    this.layerMap.delete(type);
+  }
+
+  clear(): void {
+    this.layerMap.clear();
+    this.layerRegistry.clear();
+  }
+}
+
+class FWLayerCreateManager {
+  private lifecycleManager: FWLayerLifecycleManager = new FWLayerLifecycleManager();
+
+  /**
+   * 创建Layer节点
+   */
+  createLayer(
+    prefab: cc.Prefab,
+    layerComponent: string,
+    renderOrder: number,
+    parent: cc.Node,
+    position: FW.Vec3,
+  ): FW.Layer {
+    parent = parent || FW.Entry.scene?.node;
+    position = position || cc.Vec3.ZERO;
+
+    if (!parent.activeInHierarchy || !cc.isValid(parent)) {
+      FW.Log.error(`createLayer failed , parent : ${parent}`);
+      return;
+    }
+
+    const node = cc.instantiate(prefab);
+    const p = cc.v3(position.x, position.y);
+    node.setParent(parent);
+    node.setPosition(p);
+    node.zIndex = renderOrder;
+
+    !node.getComponent(layerComponent) && node.addComponent(layerComponent);
+    return node.getComponent(layerComponent);
+  }
+
+  /**
+   * 设置Layer生命周期
+   */
+  setupLayerLifecycle(layer: FW.Layer, ctr: FW.LayerController): void {
+    this.lifecycleManager.setupLifecycleHooks(layer, ctr);
+  }
+
+  /**
+   * 初始化控制器
+   */
+  initializeController(ctr: FW.LayerController, data: any): void {
+    ctr.initialize();
+    ctr.onInit?.(data);
+  }
+}
+
+class FWLayerOpenManager {
+  constructor(
+    private dataManager: FWLayerDataManager,
+    private resourceManager: FWLayerResourceManager,
+    private createManager: FWLayerCreateManager,
+    private stackManager: FWLayerStackManager,
+    private queueManager: FWLayerQueueManager,
+    private stateManager: FWLayerStateManager,
+  ) {}
+
+  /**
+   * 统一的Layer打开方法
+   */
+  async openLayerAsync<Ctr extends FW.LayerController = FW.LayerController>(
+    data: FW.LayerOpenArgs,
+  ): Promise<Ctr> {
+    if (!this.validateOpenData(data)) {
+      return undefined;
+    }
+
+    const existingLayer = this.dataManager.getExistingLayer(data.type);
+    if (existingLayer) {
+      return existingLayer as Ctr;
+    }
+
+    const layerData = this.dataManager.createLayerData(data.type);
+
+    if (!layerData) {
+      return undefined;
+    }
+
+    if (this.dataManager.addRegistry(data.type)) {
+      const proxy = this.dataManager.getExistingProxy(data.type);
+      return proxy as Ctr;
+    }
+
+    if (this.queueManager.handlePopupQueue(layerData, this.dataManager.getLayerMap())) {
+      return undefined;
+    }
+
+    this.dataManager.addLayerData(data.type, layerData);
+
+    return this.asyncGenerationLayer(layerData, data);
+  }
+
+  openLayerSync<Ctr extends FW.LayerController = FW.LayerController>(data: FW.LayerOpenArgs): Ctr {
+    if (!this.validateOpenData(data)) {
+      return undefined;
+    }
+
+    const existingLayer = this.dataManager.getExistingLayer(data.type);
+    if (existingLayer) {
+      return existingLayer as Ctr;
+    }
+
+    const layerData = this.dataManager.createLayerData(data.type);
+
+    if (!layerData) {
+      return undefined;
+    }
+
+    if (this.dataManager.addRegistry(data.type)) {
+      const proxy = this.dataManager.getExistingProxy(data.type);
+      return proxy as Ctr;
+    }
+
+    if (this.queueManager.handlePopupQueue(layerData, this.dataManager.getLayerMap())) {
+      return undefined;
+    }
+
+    this.dataManager.addLayerData(data.type, layerData);
+
+    return this.syncGenerationLayer(layerData, data);
+  }
+
+  /**
+   * 验证打开数据
+   */
+  private validateOpenData(data: FW.LayerOpenArgs): boolean {
+    if (!data) {
+      FW.Log.error(`打开Layer失败:${data},请检查参数!`);
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * 异步生成Layer
+   */
+  private async asyncGenerationLayer<Ctr extends FW.LayerController = FW.LayerController>(
+    layerData: FWLayerData,
+    data: FW.LayerOpenArgs,
+  ): Promise<Ctr> {
+    try {
+      this.stateManager.setState(
+        layerData.controllerConstructor,
+        FW.SystemDefine.FWLayerState.LOADING,
+      );
+      const res = await this.resourceManager.loadLayerAsync(layerData);
+
+      this.stateManager.setState(
+        layerData.controllerConstructor,
+        FW.SystemDefine.FWLayerState.OPENING,
+      );
+      const ctr = this.createLayer(layerData, res, data) as Ctr;
+
+      this.dataManager.removeFromRegistry(layerData.controllerConstructor);
+
+      this.stateManager.setState(
+        layerData.controllerConstructor,
+        FW.SystemDefine.FWLayerState.OPENED,
+      );
+
+      return ctr;
+    } catch (e) {
+      FW.Log.error(`asyncGenerationLayer failed:`, e);
+      this.stateManager.removeState(layerData.controllerConstructor);
+      this.dataManager.clearFailedLayer(layerData);
+      throw e;
+    }
+  }
+
+  /**
+   * 同步创建Layer
+   */
+  private syncGenerationLayer<Ctr extends FW.LayerController = FW.LayerController>(
+    layerData: FWLayerData,
+    data: FW.LayerOpenArgs,
+  ): Ctr {
+    try {
+      this.stateManager.setState(
+        layerData.controllerConstructor,
+        FW.SystemDefine.FWLayerState.OPENING,
+      );
+      const res = this.resourceManager.loadLayerSync(layerData);
+      const ctr = this.createLayer(layerData, res, data) as Ctr;
+
+      this.stateManager.setState(
+        layerData.controllerConstructor,
+        FW.SystemDefine.FWLayerState.OPENED,
+      );
+
+      return ctr;
+    } catch (e) {
+      FW.Log.error(`syncGenerationLayer failed:`, e);
+      this.dataManager.removeFromRegistry(layerData.controllerConstructor);
+      this.dataManager.clearFailedLayer(layerData);
+      return undefined;
+    }
+  }
+
+  /**
+   * 创建Layer
+   */
+  private createLayer<Ctr extends FW.LayerController = FW.LayerController>(
+    layerData: FWLayerData,
+    res: { asset: cc.Prefab; uuid: string },
+    data: FW.LayerOpenArgs,
+  ): Ctr {
+    const layer = this.createManager.createLayer(
+      res.asset,
+      res.asset.name,
+      layerData.controller.renderOrder,
+      data.parent,
+      data.position,
+    );
+
+    if (!layer) {
+      this.dataManager.removeFromRegistry(layerData.controllerConstructor);
+      return;
+    }
+
+    const layerName = cc.js.getClassName(layer);
+
+    this.dataManager.setupLayerData(layerData, res, layer, layerName);
+
+    this.createManager.initializeController(layerData.controller, data.args);
+
+    this.createManager.setupLayerLifecycle(layer, layerData.controller);
+
+    if (layerData.controller.layerType !== FW.SystemDefine.FWLayerType.PERMANENT) {
+      this.stackManager.push(layerData);
+    }
+
+    this.dataManager.removeFromRegistry(layerData.controllerConstructor);
+
+    layerData.controllerProxy = this.dataManager.createControllerProxy(layerData);
+
+    return layerData.controllerProxy as Ctr;
+  }
+}
+
+class FWLayerResourceManager {
+  async loadLayerAsync(layerData: FWLayerData): Promise<{ asset: cc.Prefab; uuid: string }> {
+    try {
+      const res = await FW.Entry.resMgr.loadAssetData<cc.Prefab>(layerData.layerAssetProperty);
+      if (!res) return undefined;
+      res.user = layerData.layerName;
+      res.autoRelease = layerData.controller.autoRelease;
+      res.dependentBundle = layerData.controller.layerAssetProperty.bundle;
+      return { asset: res.asset as cc.Prefab, uuid: res.uuid };
+    } catch (e) {
+      FW.Log.error(`loadLayerAsync failed:`, e);
+      throw e;
+    }
+  }
+
+  loadLayerSync(layerData: FWLayerData): { asset: cc.Prefab; uuid: string } {
+    layerData.layerAssetProperty.bundle =
+      layerData.layerAssetProperty.bundle || FW.Entry.bundleName;
+    const res = FW.Entry.resMgr.getAssetData<cc.Prefab>(layerData.layerAssetProperty);
+    res.user = layerData.layerName;
+    res.autoRelease = layerData.controller.autoRelease;
+    res.dependentBundle = layerData.controller.layerAssetProperty.bundle;
+    return { asset: res.asset as cc.Prefab, uuid: res.uuid };
+  }
+}
+
+class FWLayerStackManager {
+  private layerStack: FWLayerData[] = [];
+
+  push(layerData: FWLayerData): void {
+    if (layerData.controller.layerType !== FW.SystemDefine.FWLayerType.PERMANENT) {
+      this.layerStack.push(layerData);
+    }
+  }
+
+  pop(): FWLayerData | undefined {
+    return this.layerStack.pop();
+  }
+
+  remove(layerData: FWLayerData): void {
+    const index = this.layerStack.findIndex((v) => v.controller === layerData.controller);
+    if (index > -1) {
+      this.layerStack.splice(index, 1);
+    }
+  }
+
+  getStack(): FWLayerData[] {
+    return [...this.layerStack];
+  }
+
+  clear(): void {
+    this.layerStack = [];
+  }
+}
+
+class FWLayerStateManager {
+  private layerStates = new Map<new () => FW.LayerController, FW.SystemDefine.FWLayerState>();
+  constructor() {}
+  setState(ctrType: new () => FW.LayerController, state: FW.SystemDefine.FWLayerState): void {
+    if (FW.Entry.layerMgr.isDebug()) {
+      FW.Log.debug(`${cc.js.getClassName(ctrType)}->更新状态${state}`);
+    }
+    this.layerStates.set(ctrType, state);
+  }
+
+  getState(ctrType: new () => FW.LayerController): FW.SystemDefine.FWLayerState {
+    return this.layerStates.get(ctrType) || FW.SystemDefine.FWLayerState.CLOSED;
+  }
+
+  isOpening(ctrType: new () => FW.LayerController): boolean {
+    return this.getState(ctrType) === FW.SystemDefine.FWLayerState.OPENING;
+  }
+
+  isOpened(ctrType: new () => FW.LayerController): boolean {
+    return this.getState(ctrType) === FW.SystemDefine.FWLayerState.OPENED;
+  }
+
+  isClosing(ctrType: new () => FW.LayerController): boolean {
+    return this.getState(ctrType) === FW.SystemDefine.FWLayerState.CLOSING;
+  }
+
+  removeState(ctrType: new () => FW.LayerController): void {
+    if (FW.Entry.layerMgr.isDebug()) {
+      FW.Log.debug(`${cc.js.getClassName(ctrType)}-> 移除状态`);
+    }
+    this.layerStates.delete(ctrType);
+  }
+
+  clear(): void {
+    this.layerStates.clear();
+  }
+}
+
+class FWLayerQueueManager {
+  private layerQueue: FWQueue<FWLayerData> = new FWQueue<FWLayerData>();
+
+  handlePopupQueue(
+    layerData: FWLayerData,
+    layerMap: Map<new () => FW.LayerController, FWLayerData>,
+  ): boolean {
+    if (layerData.controller.layerType === FW.SystemDefine.FWLayerType.POPUP_QUEUE) {
+      const hasNonPermanentLayers = Array.from(layerMap.values()).some(
+        (value) => value.layerType === FW.SystemDefine.FWLayerType.POPUP_QUEUE,
+      );
+
+      if (hasNonPermanentLayers) {
+        this.add(layerData);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  getNextLayer(): FWLayerData | undefined {
+    return this.shift();
+  }
+
+  add(layerData: FWLayerData): void {
+    this.layerQueue.add(layerData);
+  }
+
+  shift(): FWLayerData | undefined {
+    return this.layerQueue.shift();
+  }
+
+  isEmpty(): boolean {
+    return this.layerQueue.isEmpty();
+  }
+
+  clear(): void {
+    this.layerQueue.clear();
+  }
+
+  getQueue(): FWLayerData[] {
+    return this.layerQueue.getQueue();
+  }
+}
+
+class FWLayerLifecycleManager {
+  setupLifecycleHooks(layer: FW.Layer, ctr: FW.LayerController): void {
+    const originalOnLoad = layer['onLoad'];
+    layer['onLoad'] = function () {
+      originalOnLoad?.call(this);
+      ctr.onLoad?.();
+    };
+
+    const originalStart = layer['start'];
+    layer['start'] = function () {
+      originalStart?.call(this);
+      ctr.onStart?.();
+    };
+
+    const originalOnEnable = layer['onEnable'];
+    layer['onEnable'] = function () {
+      originalOnEnable?.call(this);
+      ctr.onEnable?.();
+    };
+
+    const originalOnDisable = layer['onDisable'];
+    layer['onDisable'] = function () {
+      originalOnDisable?.call(this);
+      ctr.onDisable?.();
+    };
+
+    const originalOnDestroy = layer['onDestroy'];
+    layer['onDestroy'] = function () {
+      originalOnDestroy?.call(this);
+      ctr.onDestroy?.();
+    };
+
+    const originalUpdate = layer['update'];
+    layer['update'] = function (dt: number) {
+      originalUpdate?.call(this, dt);
+      ctr.onUpdate?.(dt);
+    };
+
+    const originalLateUpdate = layer['lateUpdate'];
+    layer['lateUpdate'] = function () {
+      originalLateUpdate?.call(this);
+      ctr.onLateUpdate?.();
+    };
+  }
+}
+
+class FWLayerControllerFactory {
+  /**
+   * 创建并初始化 LayerController
+   */
+  createController<Ctr extends FW.LayerController = FW.LayerController>(type: new () => Ctr): Ctr {
+    const ctr = new type();
+
+    ctr.initializeDependencies?.();
+
+    return ctr;
+  }
+}