@ives_xxz/framework 1.0.0

package/manager/FWLayerManager.ts

@@ -0,0 +1,490 @@
+import { FWManager } from './FWManager';
+import { FWLayerController } from '../controller/FWLayerController';
+import { FWSystemDefine } from '../define/FWSystemDefine';
+import FWLayer from '../layer/FWLayer';
+import FWLog from '../log/FWLog';
+import { FWQueue } from '../utils/FWQueue';
+
+const ADD_EXTERNAL_REFERENCE: string = 'addExternalReference';
+
+export class FWLayerData<T extends FWLayerController = FWLayerController>
+  implements FW.LayerData<T>
+{
+  layerConstructor: new () => T;
+  uuid: string;
+  layer: FW.Layer;
+  layerName: string;
+  layerAssetProperty: FW.AssetProperty;
+  layerRenderOrder: FWSystemDefine.FWLayerRenderOrder;
+  layerType: FWSystemDefine.FWLayerType;
+  layerParent?: cc.Node;
+  layerPosition?: cc.Vec3;
+  controllerName: string;
+  controller: FWLayerController;
+  loaded: boolean;
+  externalReference?: Set<(ref: FW.LayerController | null) => void>;
+}
+
+export class FWLayerManager extends FWManager implements FW.LayerManager {
+  /**
+   * 当前待打开的layer队列
+   */
+  private layerQueue: FWQueue<FWLayerData>;
+  /**
+   * 当前已经打开的layer缓存容器
+   */
+  private layerMap: Map<string, FWLayerData>;
+  /**
+   * layer栈队列
+   */
+  private layerStack: FWLayerData[];
+
+  public initialize(): void {
+    this.layerQueue = new FWQueue<FWLayerData>();
+    this.layerMap = new Map<string, FWLayerData>();
+    this.layerStack = [];
+  }
+
+  /**
+   * 异步打开layer
+   * @param layerData
+   * @returns
+   */
+  protected async openLayerAsync(layerData: FWLayerData) {
+    try {
+      const res = await FW.Entry.resMgr.loadAssetData<cc.Prefab>(layerData.layerAssetProperty);
+
+      /** 保存资源数据 */
+      res.user = layerData.layerName;
+      res.autoRelease = layerData.controller.autoRelease;
+      res.dependentBundle = layerData.controller.layerAssetProperty.bundle;
+
+      return res;
+    } catch (e) {
+      FWLog.error(`openLayerAsync failed : `, e);
+    }
+  }
+  /**
+   * 同步打开layer
+   * @param layerData
+   * @returns
+   */
+  protected openLayerSync(layerData: FWLayerData) {
+    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;
+
+    layerData.uuid = res.uuid;
+
+    return res;
+  }
+
+  /**
+   * 创建layer数据
+   * @param ctr
+   * @returns
+   */
+  protected createLayerData(ctr: FWLayerController) {
+    const layerData = new FWLayerData();
+    const layerType = ctr.layerType;
+
+    /** 记录layer数据 */
+    layerData.layerRenderOrder = ctr.renderOrder;
+    layerData.layerAssetProperty = ctr.layerAssetProperty;
+    layerData.layerType = layerType;
+    layerData.controller = ctr;
+    layerData.loaded = false;
+    layerData.externalReference = new Set();
+
+    return layerData;
+  }
+
+  /**
+   * 异步打开layer
+   * @param data
+   * @returns
+   */
+  async openAsync<Ctr extends FWLayerController = FWLayerController>(
+    data: FW.LayerOpenArgs<Ctr>,
+  ): Promise<Ctr> {
+    if (!data) {
+      FWLog.error(`打开Layer失败:${data},请检查参数!`);
+      return undefined;
+    }
+
+    let ctr = new data.type();
+
+    if (!ctr.isRepeatOpen) {
+      for (const [key, value] of this.layerMap) {
+        if (value.layerAssetProperty.path == ctr.layerAssetProperty.path) {
+          return this.layerMap.get(value.uuid).controller as Ctr;
+        }
+      }
+    }
+
+    if (ctr.layerType == FWSystemDefine.FWLayerType.POPUP_QUEUE && !this.layerQueue.isEmpty()) {
+      this.layerQueue.add(ctr.layerData);
+      return;
+    }
+
+    ctr.initialize();
+
+    const layerData = this.createLayerData(ctr);
+
+    const res = await this.openLayerAsync(layerData);
+
+    const layer = await this.createLayer(
+      res.asset,
+      res.asset.name,
+      ctr.renderOrder,
+      data.parent,
+      data.position,
+    );
+
+    const layerName = cc.js.getClassName(layer);
+    const ctrName = cc.js.getClassName(ctr);
+
+    ctr.layerData = layerData;
+    ctr.layerData.loaded = true;
+    ctr.layer = layer;
+    ctr.layerData.layerName = layerName;
+    ctr.layerData.controllerName = ctrName;
+    ctr.layerData.uuid = res.uuid;
+    ctr.uuid = res.uuid;
+    ctr.onInit?.(data.args);
+
+    this.lifecycleProcessing(ctr);
+
+    this.layerMap.set(res.uuid, layerData);
+
+    if (ctr.layerType !== FWSystemDefine.FWLayerType.PERMANENT) {
+      this.layerStack.push(layerData);
+    }
+
+    const proxy = new Proxy(ctr, {
+      get: (target, prop) => {
+        if (prop === ADD_EXTERNAL_REFERENCE) {
+          return (cb: (ref: FW.LayerController | null) => void) => {
+            layerData.externalReference.add(cb);
+          };
+        }
+        return target[prop];
+      },
+    });
+    return proxy;
+  }
+
+  /**
+   * 同步打开
+   * @param data
+   * @returns
+   */
+  openSync<Ctr extends FWLayerController = FWLayerController>(data: FW.LayerOpenArgs<Ctr>): Ctr {
+    if (!data) {
+      FWLog.error(`open layer failed:${data},please check param!`);
+      return undefined;
+    }
+    let ctr = new data.type();
+
+    if (!ctr.isRepeatOpen) {
+      for (const [key, value] of this.layerMap) {
+        if (value.layerAssetProperty.path == ctr.layerAssetProperty.path) {
+          return this.layerMap.get(value.uuid).controller as Ctr;
+        }
+      }
+    }
+
+    if (ctr.layerType == FWSystemDefine.FWLayerType.POPUP_QUEUE && !this.layerQueue.isEmpty()) {
+      this.layerQueue.add(ctr.layerData);
+      return;
+    }
+
+    ctr.initialize();
+
+    const layerData = this.createLayerData(ctr);
+
+    if (
+      layerData.layerType == FWSystemDefine.FWLayerType.POPUP_QUEUE &&
+      !this.layerQueue.isEmpty()
+    ) {
+      this.layerQueue.add(layerData);
+    } else {
+      const res = this.openLayerSync(layerData);
+      const layer = this.createLayer(
+        res.asset,
+        res.asset.name,
+        layerData.layerRenderOrder,
+        layerData.layerParent,
+        layerData.layerPosition,
+      );
+      this.layerMap.set(res.uuid, layerData);
+      const layerName = cc.js.getClassName(layer);
+      const ctrName = cc.js.getClassName(ctr);
+
+      ctr.layerData = layerData;
+      ctr.layerData.loaded = true;
+      ctr.layer = layer;
+      ctr.layerData.layerName = layerName;
+      ctr.layerData.controllerName = ctrName;
+      ctr.layerData.uuid = res.uuid;
+      ctr.uuid = res.uuid;
+      ctr.onInit?.(data.args);
+
+      this.lifecycleProcessing(ctr);
+    }
+
+    if (ctr.layerType !== FWSystemDefine.FWLayerType.PERMANENT) {
+      this.layerStack.push(layerData);
+    }
+    const a = Symbol['addExternalReference'];
+
+    const proxy = new Proxy(ctr, {
+      get: (target, prop) => {
+        if (prop === 'addExternalReference') {
+          return (cb: (ref: FW.LayerController | null) => void) => {
+            layerData.externalReference.add(cb);
+          };
+        }
+        return target[prop];
+      },
+    });
+    return proxy;
+  }
+
+  /**
+   * 显示layer并恢复所有节点事件
+   * @param ctr
+   * @returns
+   */
+  displayLayer<Ctr extends FWLayerController = FWLayerController>(ctr: Ctr): Ctr {
+    const layerData = ctr.layerData;
+    if (!this.layerMap.has(layerData.uuid)) {
+      FWLog.warn(`display layer failed,layer name : ${layerData.layerName}`);
+      return;
+    }
+    /** 非常驻layer不允许操作透明度显示 */
+    if (ctr.layerType != FWSystemDefine.FWLayerType.PERMANENT) return;
+
+    const node = ctr.layer.node;
+    node.opacity = 255;
+    node.resumeSystemEvents(true);
+
+    FW.Entry.evtMgr.targetResume(ctr);
+  }
+
+  /**
+   * 隐藏layer并隐藏所有节点事件
+   * @param ctr
+   * @returns
+   */
+  hideLayer<Ctr extends FWLayerController = FWLayerController>(ctr: Ctr): Ctr {
+    const layerData = ctr.layerData;
+    if (!this.layerMap.has(layerData.uuid)) {
+      FWLog.warn(`hide layer failed,layer name : ${layerData.layerName}`);
+      return;
+    }
+
+    /** 非常驻layer不允许操作透明度 */
+    if (ctr.layerType != FWSystemDefine.FWLayerType.PERMANENT) return;
+
+    const node = ctr.layer.node;
+    node.opacity = 0;
+    node.pauseSystemEvents(true);
+    FW.Entry.evtMgr.targetPause(ctr);
+  }
+
+  /**
+   * 通过layer名字关闭
+   * @param name
+   */
+  closeFromLayerName(name: string | string[]): void {
+    this.layerMap.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.layerStack.pop();
+      let ctr = layerData.controller;
+      if (!this.layerMap.has(layerData.uuid)) {
+        return;
+      }
+      if (cc.isValid(ctr.layer?.node)) {
+        ctr.destroy?.();
+        if (ctr.autoRelease) {
+          FW.Entry.resMgr.releaseAsset(ctr.layerData.layerAssetProperty);
+        }
+        this.notifyExternalRefUpdates(ctr.layerData);
+      }
+      this.layerMap.delete(layerData.uuid);
+    }
+  }
+
+  /**
+   * 关闭layer
+   * @param ctr
+   */
+  async close<Ctr extends FWLayerController = FWLayerController>(
+    ctr: Ctr,
+  ): Promise<FWLayerController> {
+    if (!ctr) return;
+
+    let layerData = ctr.layerData;
+
+    if (!this.layerMap.has(layerData.uuid)) {
+      return;
+    }
+
+    if (cc.isValid(ctr.layer?.node)) {
+      ctr.destroy?.();
+      if (ctr.autoRelease) {
+        FW.Entry.resMgr.releaseAsset(ctr.layerData.layerAssetProperty);
+      }
+      this.notifyExternalRefUpdates(ctr.layerData);
+    }
+
+    this.layerMap.delete(layerData.uuid);
+    this.layerStack.pop();
+
+    const index = this.layerStack.findIndex((v) => {
+      v.controller == ctr;
+    });
+    this.layerStack.slice(index, 1);
+
+    /** 如果队列中还有等待打开的layer */
+    if (!this.layerQueue.isEmpty()) {
+      const nextLayerData = this.layerQueue.shift();
+      /** 先尝试同步打开 */
+      const nextLayer = this.openSync({
+        parent: nextLayerData.layerParent,
+        position: nextLayerData.layerPosition,
+        type: nextLayerData.layerConstructor,
+      });
+      /** 如果同步打开失败,再次尝试异步打开(可能由于资源所在bundle并未提前加载) */
+      if (!nextLayer) {
+        return this.openAsync({
+          parent: nextLayerData.layerParent,
+          position: nextLayerData.layerPosition,
+          type: nextLayerData.layerConstructor,
+        });
+      } else {
+        return nextLayer;
+      }
+    } else {
+      return undefined;
+    }
+  }
+
+  private notifyExternalRefUpdates(layerData: FWLayerData) {
+    layerData.externalReference.forEach((cb) => {
+      try {
+        cb?.(null);
+      } catch (e) {
+        FWLog.error('External ref update callback error:', e);
+      }
+    });
+    layerData.externalReference.clear();
+  }
+  /** 创建layer */
+  private createLayer(
+    prefab: cc.Prefab,
+    layerComponent: string,
+    renderOrder: number,
+    parent: cc.Node,
+    position: cc.Vec3,
+  ) {
+    parent = parent || FW.Entry.scene?.node;
+
+    position = position || cc.Vec3.ZERO;
+
+    if (!parent.activeInHierarchy || !cc.isValid(parent)) {
+      FWLog.error(`createLayer failed , parent : ${parent}`);
+      return;
+    }
+    const node = cc.instantiate(prefab);
+    node.setParent(parent);
+    node.setPosition(position);
+    node.zIndex = renderOrder;
+    !node.getComponent(layerComponent) && node.addComponent(layerComponent);
+    return node.getComponent(FWLayer);
+  }
+
+  private lifecycleProcessing(ctr: FWLayerController) {
+    const layer = ctr.layer;
+
+    const onLoad = layer['onLoad'];
+    layer['onLoad'] = () => {
+      onLoad?.call(layer);
+      ctr.onLoad?.();
+    };
+
+    const onStart = layer['start'];
+    layer['start'] = () => {
+      onStart?.call(layer);
+      ctr.onStart?.();
+    };
+
+    const onEnable = layer['onEnable'];
+    layer['onEnable'] = () => {
+      onEnable?.call(layer);
+      ctr.onEnable?.();
+    };
+
+    const onDisable = layer['onDisable'];
+    layer['onDisable'] = () => {
+      onDisable?.call(layer);
+      ctr.onDisable?.();
+    };
+
+    const onDestroy = layer['onDestroy'];
+    layer['onDestroy'] = () => {
+      onDestroy?.call(layer);
+      ctr.onDestroy?.();
+    };
+
+    const onUpdate = layer['update'];
+    layer['update'] = (dt?: number) => {
+      onUpdate?.call(layer);
+      ctr.onUpdate?.(dt);
+    };
+
+    const onLateUpdate = layer['lateUpdate'];
+    layer['lateUpdate'] = () => {
+      onLateUpdate?.call(layer);
+      ctr.onLateUpdate?.();
+    };
+  }
+
+  getLayerMap(): Map<string, FWLayerData> {
+    return this.layerMap;
+  }
+
+  public clear() {
+    this.layerMap.forEach((v) => this.close(v.controller));
+    this.layerMap.clear();
+  }
+
+  public onDestroy(): void {
+    this.layerMap.clear();
+    this.layerMap = null;
+    this.layerQueue = null;
+  }
+}

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,8 @@
+export abstract class FWManager {
+  public readonly entry: FW.Entry = FW.Entry;
+  constructor() {
+    this.initialize();
+  }
+  public abstract initialize(): void;
+  public abstract onDestroy(): void;
+}

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,91 @@
+import { FWSystemDefine } from '../define/FWSystemDefine';
+import Framework from '../Framework';
+import FWObject from '../utils/FWObject';
+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>();
+  }
+  public onDestroy(): void {}
+  private poolMap: Map<string, FWObjectPool>;
+
+  /** 创建一个对象池 */
+  async createObjectPool<T extends FWObject = FWObject>(
+    node: cc.Node,
+    parent: cc.Node,
+    tag?: string,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<T extends FWObject = FWObject>(
+    prefab: cc.Prefab,
+    parent: cc.Node,
+    tag?: string,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<T extends FWObject = FWObject>(
+    assetProperty: FW.AssetProperty,
+    parent: cc.Node,
+    tag?: string,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<T extends FWObject = FWObject>(
+    node: cc.Node,
+    parent: cc.Node,
+    type?: number,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<T extends FWObject = FWObject>(
+    prefab: cc.Prefab,
+    parent: cc.Node,
+    type?: number,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<T extends FWObject = FWObject>(
+    assetProperty: FW.AssetProperty,
+    parent: cc.Node,
+    type?: number,
+  ): Promise<FWObjectPool>;
+  async createObjectPool<T extends FWObject = FWObject>(): Promise<FWObjectPool> {
+    let objectNode: cc.Node = null;
+    let objectPrefab: cc.Prefab = null;
+    let objectAssetProperty: FW.AssetProperty = null;
+    let objectParent: cc.Node;
+    let objectTag: string;
+    let objectType: FWSystemDefine.FWObjectType;
+    if (arguments.length > 3) return;
+    if (arguments[0] instanceof cc.Node) {
+      objectNode = arguments[0];
+    } else if (arguments[0] instanceof cc.Prefab) {
+      objectPrefab = arguments[0];
+      objectNode = cc.instantiate(objectPrefab);
+    } else {
+      objectAssetProperty = arguments[0];
+      objectPrefab = await FW.Entry.resMgr.loadAsset<cc.Prefab>(objectAssetProperty);
+      objectNode = cc.instantiate(objectPrefab);
+    }
+    objectParent = arguments[1];
+    if (arguments[2] && typeof arguments[2] === 'string') {
+      objectTag = arguments[2];
+      objectType = FWSystemDefine.FWObjectType.OPACITY;
+    } else {
+      objectTag = this.poolMap.size?.toString() || '';
+      objectType = arguments[2];
+    }
+
+    const pool = new FWObjectPool<T>(objectNode, objectParent, objectType);
+
+    this.poolMap.set(objectTag, pool);
+
+    return pool;
+  }
+
+  /** 获取已经创建的对象池 */
+  getObjectPool(tag: string) {
+    if (!this.poolMap.has(tag)) return undefined;
+    return this.poolMap.get(tag);
+  }
+
+  /** 销毁一个对象池 */
+  destroyObjectPool(tag: string) {
+    if (!this.poolMap.has(tag)) return;
+    this.poolMap.get(tag).onDestroy();
+    this.poolMap.delete(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": {}
+}