@ives_xxz/framework 1.0.0

package/utils/FWMask.ts

@@ -0,0 +1,222 @@
+export enum FWMaskType {
+  /**
+   * !#en Rect mask.
+   * !#zh 使用矩形作为遮罩
+   * @property {Number} RECT
+   */
+  RECT = 0,
+  /**
+   * !#en Ellipse Mask.
+   * !#zh 使用椭圆作为遮罩
+   * @property {Number} ELLIPSE
+   */
+  ELLIPSE = 1,
+  /**
+   * !#en Image Stencil Mask.
+   * !#zh 使用图像模版作为遮罩
+   * @property {Number} IMAGE_STENCIL
+   */
+  IMAGE_STENCIL = 2,
+
+  /**
+   * 多边形遮罩
+   */
+  POLYGON = 3,
+}
+
+let _vec2_temp = new cc.Vec2();
+let _mat4_temp = new cc.Mat4();
+
+let _circlepoints = [];
+function _calculateCircle(center, radius, segements) {
+  _circlepoints.length = 0;
+  let anglePerStep = (Math.PI * 2) / segements;
+  for (let step = 0; step < segements; ++step) {
+    _circlepoints.push(
+      cc.v2(
+        radius.x * Math.cos(anglePerStep * step) + center.x,
+        radius.y * Math.sin(anglePerStep * step) + center.y,
+      ),
+    );
+  }
+
+  return _circlepoints;
+}
+
+class EllipseConfig {
+  center: cc.Vec2;
+  r: cc.Vec2;
+  segments: number;
+}
+
+/**
+ * 遮罩扩展
+ * 自定义多边形遮罩
+ */
+const { ccclass, property, executeInEditMode, menu, help, inspector } = cc._decorator;
+@ccclass
+@executeInEditMode
+@inspector('packages://maskplus/inspector.js')
+@menu('CustomComponent/FWMask')
+export default class FWMask extends cc.Mask {
+  static Type = FWMaskType;
+
+  @property({ type: cc.Enum(FWMaskType), override: true })
+  _type: FWMaskType = 0;
+  @property({ type: cc.Enum(FWMaskType), override: true })
+  // @ts-ignore
+  get type() {
+    return this._type;
+  }
+  // @ts-ignore
+  set type(value) {
+    if (this._type !== value) {
+      this['_resetAssembler']();
+    }
+
+    this._type = value;
+
+    if (this._type === FWMaskType.POLYGON) {
+      if (this._polygon.length === 0) {
+        let [x, y, width, height] = this.getNodeRect();
+        this._polygon.push(
+          cc.v2(x, y),
+          cc.v2(x + width, y),
+          cc.v2(x + width, y + height),
+          cc.v2(x, y + height),
+        );
+      }
+    }
+
+    if (this._type !== FWMaskType.IMAGE_STENCIL) {
+      this.spriteFrame = null;
+      this.alphaThreshold = 0;
+      this._updateGraphics();
+    }
+    this['_activateMaterial']();
+  }
+
+  @property({ type: [cc.Vec2], serializable: true })
+  _polygon: cc.Vec2[] = [];
+  @property({ type: [cc.Vec2], serializable: true })
+  public get polygon() {
+    return this._polygon;
+  }
+  public set polygon(points: cc.Vec2[]) {
+    this._polygon = points;
+    this._updateGraphics();
+  }
+
+  private ellipse: EllipseConfig = new EllipseConfig();
+  public setEllipse(center?: cc.Vec2, r?: cc.Vec2, segments?: number) {
+    this.ellipse.center = center;
+    this.ellipse.r = r;
+    this.ellipse.segments = segments || this.segements;
+  }
+
+  _updateGraphics() {
+    let node = this.node;
+    let graphics = this['_graphics'];
+    // Share render data with graphics content
+    graphics.clear(false);
+    let [x, y, width, height] = this.getNodeRect();
+    if (this['_type'] === FWMaskType.RECT) {
+      graphics.rect(x, y, width, height);
+    } else if (this['_type'] === FWMaskType.ELLIPSE) {
+      let center = this.ellipse.center || cc.v2(x + width / 2, y + height / 2);
+      let radius = this.ellipse.r || { x: width / 2, y: height / 2 };
+      let segments = this.ellipse.segments || this['_segments'];
+      let points = _calculateCircle(center, radius, segments);
+      for (let i = 0; i < points.length; ++i) {
+        let point = points[i];
+        if (i === 0) {
+          graphics.moveTo(point.x, point.y);
+        } else {
+          graphics.lineTo(point.x, point.y);
+        }
+      }
+      graphics.close();
+    } else if (this['_type'] === FWMaskType.POLYGON) {
+      if (this._polygon.length === 0) this._polygon.push(cc.v2(0, 0));
+      graphics.moveTo(this._polygon[0].x, this._polygon[0].y);
+      for (let i = 1; i < this._polygon.length; i++) {
+        graphics.lineTo(this._polygon[i].x, this._polygon[i].y);
+      }
+      graphics.lineTo(this._polygon[0].x, this._polygon[0].y);
+    }
+
+    if (cc.game.renderType === cc.game.RENDER_TYPE_CANVAS) {
+      graphics.stroke();
+    } else {
+      graphics.fill();
+    }
+  }
+
+  _hitTest(cameraPt: cc.Vec2) {
+    let node = this.node;
+    let size = node.getContentSize(),
+      w = size.width,
+      h = size.height,
+      testPt = _vec2_temp;
+
+    node['_updateWorldMatrix']();
+    if (!cc.Mat4.invert(_mat4_temp, node['_worldMatrix'])) {
+      return false;
+    }
+    let point = cc.v2(0, 0);
+    cc.Vec2.transformMat4(point, cameraPt, _mat4_temp);
+    testPt.x = point.x + node['_anchorPoint'].x * w;
+    testPt.y = point.y + node['_anchorPoint'].y * h;
+
+    let result = false;
+    if (this.type === FWMaskType.RECT || this.type === FWMaskType.IMAGE_STENCIL) {
+      result = testPt.x >= 0 && testPt.y >= 0 && testPt.x <= w && testPt.y <= h;
+    } else if (this.type === FWMaskType.ELLIPSE) {
+      let rx = w / 2,
+        ry = h / 2;
+      let px = testPt.x - 0.5 * w,
+        py = testPt.y - 0.5 * h;
+      result = (px * px) / (rx * rx) + (py * py) / (ry * ry) < 1;
+    } else if (this.type === FWMaskType.POLYGON) {
+      result = this.isInPolygon(point, this.polygon);
+    }
+    if (this.inverted) {
+      result = !result;
+    }
+    return result;
+  }
+
+  private getNodeRect() {
+    let width = this.node['_contentSize'].width;
+    let height = this.node['_contentSize'].height;
+    let x = -width * this.node['_anchorPoint'].x;
+    let y = -height * this.node['_anchorPoint'].y;
+    return [x, y, width, height];
+  }
+
+  public isInPolygon(checkPoint: cc.Vec2, polygonPoints: cc.Vec2[]) {
+    let counter = 0,
+      i: number,
+      xinters: number;
+    let p1: cc.Vec2, p2: cc.Vec2;
+    let pointCount = polygonPoints.length;
+    p1 = polygonPoints[0];
+
+    for (i = 1; i <= pointCount; i++) {
+      p2 = polygonPoints[i % pointCount];
+      if (checkPoint.x > Math.min(p1.x, p2.x) && checkPoint.x <= Math.max(p1.x, p2.x)) {
+        if (checkPoint.y <= Math.max(p1.y, p2.y)) {
+          if (p1.x != p2.x) {
+            xinters = ((checkPoint.x - p1.x) * (p2.y - p1.y)) / (p2.x - p1.x) + p1.y;
+            if (p1.y == p2.y || checkPoint.y <= xinters) {
+              counter++;
+            }
+          }
+        }
+      }
+      p1 = p2;
+    }
+    return (counter & 1) !== 0;
+  }
+}
+cc['FWMask'] = FWMask;

package/utils/FWMask.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "d23e2be0-c6e3-43f3-a7f3-fc08342960ac",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/utils/FWObject.ts

@@ -0,0 +1,22 @@
+export default abstract class FWObject extends cc.Component implements FW.Object {
+  /** 是否已经初始化 */
+  public initialize: boolean;
+  /** 对象唯一id */
+  public uniqueId: number;
+  /** 对象是否启用 */
+  public enable: boolean;
+
+  public readonly entry: FW.Entry = FW.Entry;
+
+  constructor() {
+    super();
+    this.initialize = false;
+    this.uniqueId = 0;
+    this.enable = false;
+  }
+
+  abstract onGet(args: any);
+  abstract onPut();
+  abstract onInit();
+  abstract onDestroy();
+}

package/utils/FWObject.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "9385d55e-5267-434f-b54c-6a98368a5985",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/utils/FWObjectPool.ts

@@ -0,0 +1,178 @@
+import { FWSystemDefine } from '../define/FWSystemDefine';
+import FWLog from '../log/FWLog';
+import FWObject from './FWObject';
+
+const POOL_DISABLE_POSITION: cc.Vec3 = cc.v3(50000, 50000);
+
+export class FWObjectPool<T extends FWObject = FWObject> implements FW.ObjectPool {
+  private uniqueId: number;
+  private type: FWSystemDefine.FWObjectType;
+  private enablePoolMap: Map<number, FW.ObjectProperty>;
+  private disablePoolMap: Map<number, FW.ObjectProperty>;
+
+  constructor(
+    protected node: cc.Node,
+    protected parent: cc.Node,
+    type?: FWSystemDefine.FWObjectType,
+  ) {
+    this.uniqueId = 0;
+    this.type = type !== undefined ? type : FWSystemDefine.FWObjectType.OPACITY;
+    this.enablePoolMap = new Map<number, FW.ObjectProperty>();
+    this.disablePoolMap = new Map<number, FW.ObjectProperty>();
+  }
+
+  /**
+   * 获取所有已经启用对象
+   */
+  public getEnableObjectMap() {
+    return this.enablePoolMap;
+  }
+  /**
+   * 获取未启用对象
+   * @returns
+   */
+  public getDisableObjectMap() {
+    return this.disablePoolMap;
+  }
+  /**
+   * 获取所有已经创建对象
+   */
+  public getAllObjectMap() {
+    return [...this.enablePoolMap, ...this.disablePoolMap];
+  }
+
+  findObjectProperty(node: cc.Node);
+  findObjectProperty(component: FW.Object);
+  findObjectProperty(uniqueId: number);
+  findObjectProperty() {
+    const map = new Map([...this.enablePoolMap, ...this.disablePoolMap]);
+
+    for (const [uniqueId, property] of map) {
+      if (arguments[0] instanceof cc.Node) {
+        const uuid = arguments[0].uuid;
+        if (property.node.uuid == uuid) {
+          return property;
+        }
+      } else if (arguments[0] instanceof FWObject) {
+        if (uniqueId == arguments[0]?.uniqueId) {
+          return property;
+        }
+      } else {
+        if (property?.uniqueId == arguments[0]) {
+          return property;
+        }
+      }
+    }
+    return undefined;
+  }
+
+  /** 是否禁用缓存池中存在剩余对象 */
+  private isEmpty() {
+    return this.disablePoolMap.size == 0;
+  }
+
+  get(...args: any): FW.ObjectProperty {
+    let node: cc.Node;
+    let element: T;
+    let ObjectProperty: FW.ObjectProperty = {
+      uniqueId: -1,
+    };
+    if (this.isEmpty()) {
+      node = cc.instantiate(this.node);
+      element = (node.getComponent(FWObject) as T) || undefined;
+      ObjectProperty.uniqueId = ++this.uniqueId;
+      ObjectProperty.node = node;
+      ObjectProperty.component = element;
+      if (ObjectProperty.component) {
+        ObjectProperty.component.uniqueId = ObjectProperty.uniqueId;
+      }
+    } else {
+      const entry = this.disablePoolMap.entries().next().value;
+      const key = entry[0];
+      ObjectProperty = entry[1] as FW.ObjectProperty;
+      node = ObjectProperty.node;
+      element = ObjectProperty.component as T;
+      this.disablePoolMap.delete(key);
+    }
+
+    if (!cc.isValid(node)) {
+      return;
+    }
+
+    ObjectProperty.enable = true;
+
+    this.enablePoolMap.set(ObjectProperty.uniqueId, ObjectProperty);
+    if (this.type == FWSystemDefine.FWObjectType.OPACITY) {
+      node.opacity = 255;
+    } else {
+      node.active = true;
+      node.setParent(this.parent);
+    }
+
+    if (element) {
+      if (!element.initialize) {
+        element.initialize = true;
+        element.onInit();
+      }
+      element.enable = true;
+      node.setParent(this.parent);
+      element.onGet(args);
+      FW.Entry.evtMgr?.targetResume(element);
+    } else {
+      node.setParent(this.parent);
+    }
+
+    node.resumeSystemEvents(true);
+
+    return ObjectProperty;
+  }
+
+  puts(nodes: cc.Node[]);
+  puts(components: cc.Component[]);
+  puts(uniqueId: number[]);
+  puts() {
+    const arr = (arguments[0] as any[]).concat();
+    for (let i = 0; i < arr.length; i++) {
+      this.put(arr[i]);
+    }
+  }
+
+  put(node: cc.Node);
+  put(component: FW.Object);
+  put(uniqueId: number);
+  put() {
+    let property: FW.ObjectProperty = this.findObjectProperty(arguments[0]);
+
+    const node: cc.Node = property.node;
+    const element = (node.getComponent(FWObject) as T) || undefined;
+
+    if (!cc.isValid(node)) {
+      return;
+    }
+
+    if (this.type == FWSystemDefine.FWObjectType.OPACITY) {
+      node.opacity = 0;
+    } else {
+      node.active = false;
+      node.removeFromParent(false);
+    }
+    node.pauseSystemEvents(true);
+    node.setPosition(POOL_DISABLE_POSITION);
+    this.disablePoolMap.set(property.uniqueId, property);
+    if (element) {
+      FW.Entry.evtMgr?.targetPause(element);
+      element.onPut();
+      element.enable = false;
+    }
+  }
+
+  onDestroy() {
+    const map = new Map([...this.enablePoolMap, ...this.disablePoolMap]);
+
+    for (const [uniqueId, property] of map) {
+      property.component?.onDestroy?.();
+    }
+    this.enablePoolMap.clear();
+    this.disablePoolMap.clear();
+  }
+}

package/utils/FWObjectPool.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "570aed3c-115a-4f80-91e7-7c26e4f8f1f4",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/utils/FWQueue.ts

@@ -0,0 +1,47 @@
+export class FWQueue<T> {
+  private queue: T[];
+  constructor() {
+    this.queue = [];
+  }
+
+  /**
+   * 添加元素进入队列末尾
+   * @param element
+   */
+  public add(element: T) {
+    this.queue.push(element);
+  }
+
+  /**
+   * 删除并返回元素第一个元素
+   * */
+  public shift() {
+    return this.queue.shift();
+  }
+
+  /**
+   * 查看并返回元素第一个元素
+   * */
+  public peek() {
+    if (!this.isEmpty()) {
+      return undefined;
+    }
+    return this.queue[0];
+  }
+
+  /**
+   * 队列是否为空
+   * @returns
+   */
+  public isEmpty() {
+    return this.size() == 0;
+  }
+
+  /**
+   * 队列剩余数量
+   * @returns
+   */
+  public size() {
+    return this.queue.length;
+  }
+}

package/utils/FWQueue.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "8739c994-9649-44c8-87f3-1d766fff1f54",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}