@aibee/owlly 1.0.25

package/src/owlly/utils/basic-calc.ts

@@ -0,0 +1,141 @@
+/* eslint-disable @typescript-eslint/camelcase */
+
+interface Coord2d {
+  x: number;
+  y: number;
+}
+interface TurningInfo {
+  point: number[];
+  angle: number;
+  startTPoint: number[];
+  endTPoint: number[];
+  startIndex: number;
+  endIndex: number;
+}
+class BasicCalcTool {
+  static getLineCross(line1_p1: Coord2d, line1_p2: Coord2d, line2_p1: Coord2d, line2_p2: Coord2d): boolean {
+    // step1 利用投影快速排斥
+    const ifL2R = Math.min(line2_p1.x, line2_p2.x) > Math.max(line1_p1.x, line1_p2.x);
+    const ifL2T = Math.min(line2_p1.y, line2_p2.y) > Math.max(line1_p1.y, line1_p2.y);
+    const ifL1R = Math.min(line1_p1.x, line1_p2.x) > Math.max(line2_p1.x, line2_p2.x);
+    const ifL1T = Math.min(line1_p1.y, line1_p2.y) > Math.max(line2_p1.y, line2_p2.y);
+    if (ifL2R || ifL2T || ifL1R || ifL1T) return false;
+    // step2 投影快速排斥不成立 证明两个点分别在一条直线的两边
+
+    const crossMul = (v1: Coord2d, v2: Coord2d): number => v1.x * v2.y - v1.y * v2.x;
+    // eslint-disable-next-line no-shadow
+    const checkCross = (line1_p1: Coord2d, line1_p2: Coord2d, line2_p1: Coord2d, line2_p2: Coord2d): boolean => {
+      let v1 = { x: line1_p1.x - line2_p1.x, y: line2_p1.y - line1_p1.y };
+      let v2 = { x: line1_p2.x - line2_p1.x, y: line1_p2.y - line2_p1.y };
+      let v3 = { x: line2_p2.x - line2_p1.x, y: line2_p2.y - line2_p1.y };
+      const v = crossMul(v1, v3) * crossMul(v2, v3);
+      v1 = { x: line2_p1.x - line1_p1.x, y: line2_p1.y - line1_p1.y };
+      v2 = { x: line2_p2.x - line1_p1.x, y: line2_p2.y - line1_p1.y };
+      v3 = { x: line1_p2.x - line1_p1.x, y: line1_p2.y - line1_p1.y };
+      return !!((v <= 0 && crossMul(v1, v3) * crossMul(v2, v3) <= 0));
+    };
+    const ifCross = checkCross(line1_p1, line1_p2, line2_p1, line2_p2);
+    return ifCross;
+  }
+
+  // 拐角范围内的判定为 [2, 20] [340, 358] 平滑后的路径角度在此范围内, 未经平滑的路径返回 []
+  static calcTurning(linePoints: [number, number][], turningStandard = [2, 20]): TurningInfo [] { // 求一条线中的拐点, 其中每两条线段无法确定有无夹角
+    const len = linePoints.length;
+    if (len < 2) return [];
+    const crds = [];
+    const getAngle = (p1: Coord2d, p2: Coord2d): number => {
+      const { x: x1, y: y1 } = p1;
+      const { x: x2, y: y2 } = p2;
+      const dot = x1 * x2 + y1 * y2;
+      const det = x1 * y2 - y1 * x2;
+      const angle = Math.atan2(det, dot) / Math.PI * 180;
+      return Math.round(angle + 360) % 360;
+    };
+    let isCrossing = false;
+    let curAngle = 0;
+    let curPoint = [0, 0];
+    let startTPoint = [0, 0];
+    let endTPoint = [0, 0];
+    let startIndex = 0;
+    let endIndex = 0;
+    // 经过平滑处理的线, 一个夹角90度可能由n个小夹角组成
+    for (let i = 1; i < len - 1; i++) {
+      const prev = linePoints[i - 1];
+      const cur = linePoints[i];
+      const next = linePoints[i + 1];
+      const angle = getAngle({
+        x: next[0] - cur[0],
+        y: next[1] - cur[1],
+      }, {
+        x: cur[0] - prev[0],
+        y: cur[1] - prev[1],
+      });
+      const isAngleWithinStand = (angle >= turningStandard[0] && angle <= turningStandard[1])
+       || (angle >= (360 - turningStandard[1]) && angle <= (360 - turningStandard[0]));
+      if (!isCrossing && isAngleWithinStand) { // 首次进入夹角
+        isCrossing = true;
+        startTPoint = cur;
+        curAngle += angle;
+        startIndex = i;
+      } else if (isCrossing && isAngleWithinStand) { // 夹角中并夹角依然在增大
+        curAngle += angle;
+      } else if (isCrossing && !isAngleWithinStand) { // 夹角中并夹角停止增大趋势
+        curAngle += angle;
+        endIndex = i;
+        endTPoint = cur;
+        // curPoint 取 夹角范围内最靠近中心的点
+        curPoint = [
+          (startTPoint[0] + endTPoint[0]) / 2,
+          (startTPoint[1] + endTPoint[1]) / 2,
+        ];
+        crds.push({
+          point: curPoint,
+          angle: curAngle % 360,
+          startTPoint,
+          endTPoint,
+          startIndex,
+          endIndex,
+        });
+        isCrossing = false;
+      } else if (!isCrossing && !isAngleWithinStand) { // 直行中
+        startIndex = endIndex = 0;
+        curAngle = 0;
+        curPoint = [0, 0];
+        startTPoint = [0, 0];
+        endTPoint = [0, 0];
+      }
+    }
+    // 最后一个点依然在拐角内
+    if (isCrossing) {
+      endTPoint = linePoints[len - 1];
+      curPoint = [
+        (startTPoint[0] + endTPoint[0]) / 2,
+        (startTPoint[1] + endTPoint[1]) / 2,
+      ];
+      crds.push({
+        point: curPoint,
+        angle: curAngle % 360,
+        startTPoint,
+        endTPoint,
+        startIndex,
+        endIndex,
+      });
+      isCrossing = false;
+    }
+    return crds;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static chunk(items: any[], size: number): any[][] {
+    if (items.length <= 0 || size <= 0) {
+      return items;
+    }
+    const chunks = [];
+    for (let i = 0; i < items.length; i += size) {
+      chunks.push(items.slice(i, i + size));
+    }
+    return chunks;
+  }
+}
+
+export { BasicCalcTool, TurningInfo };

package/src/owlly/utils/basic-tools.ts

@@ -0,0 +1,286 @@
+import { Externals, NS_THREE } from '../stage/externals';
+import { Element } from '../element/element';
+import { View } from '../view/view';
+
+class BasicTools {
+  /**
+   * 销毁工具
+   * @param o 对象
+   * @param recursive 递归销毁
+   */
+  static dispose(o: NS_THREE.Object3D, recursive?: boolean): void {
+    if (recursive && o.children && o.children.length) {
+      o.children.forEach((child) => {
+        BasicTools.dispose(child, recursive);
+      });
+    }
+    if ((o as NS_THREE.Mesh).isMesh) {
+      const m = o as NS_THREE.Mesh;
+      if (m.geometry) m.geometry.dispose();
+      if (m.material) {
+        if (Array.isArray(m.material)) {
+          m.material.forEach((mat) => {
+            mat.dispose();
+          });
+        } else {
+          m.material.dispose();
+        }
+      }
+    }
+  }
+
+  /**
+   * 鼠标碰撞工具函数
+   * @param objects 需要检测碰撞的 Element
+   * @param param1 鼠标点击坐标
+   * @param camera 使用的相机
+   * @param candidates 候选者, candidate 存在于 object 中
+   * @param maxWorldDistance 世界中点击时的距离
+   * @returns 碰撞对象
+   */
+  static getMouseIntersection(
+    objects: Element[],
+    { x, y }: { x: number; y: number },
+    camera: NS_THREE.Camera,
+    candidates?: Element[],
+    maxWorldDistance = -1,
+  ): NS_THREE.Intersection | null {
+    const { THREE } = Externals.getInstance();
+    const maxWorldDistanceSquared = maxWorldDistance < 0 ? Number.MAX_SAFE_INTEGER : maxWorldDistance ** 2;
+    const rayCaster = new THREE.Raycaster();
+    rayCaster.setFromCamera({ x, y }, camera);
+    const cameraPosition = camera.position.clone();
+    const filteredObjects = objects.filter(
+      (o) => o.visible
+        && cameraPosition.distanceToSquared(o.getWorldPosition(new THREE.Vector3())) < maxWorldDistanceSquared,
+    );
+    const intersections = rayCaster.intersectObjects(filteredObjects, true).filter((i) => (!!i.face));
+    const candidateSet = new Set<Element>(candidates);
+    for (let i = 0; i < intersections.length; i++) {
+      let target = intersections[i].object;
+      const parentElements = [];
+      while (!(target instanceof Element) && target.parent) target = target.parent;
+      while (target) {
+        if (target instanceof Element) {
+          parentElements.push(target);
+        }
+        if (!target.parent) break;
+        target = target.parent;
+      }
+      for (let j = 0; j < parentElements.length; j++) {
+        if (parentElements[j] instanceof Element) {
+          if (candidates) {
+            if (candidateSet.has(parentElements[j])) {
+              const ret = intersections[i];
+              ret.object = parentElements[j];
+              return ret;
+            }
+          } else {
+            const ret = intersections[i];
+            ret.object = parentElements[j];
+            return ret;
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 获取屏幕空间的点击碰撞
+   * @param objects 需要检查的对象
+   * @param param1 点击坐标
+   * @param param2 屏幕尺寸
+   * @param maxDistance 最大检测距离
+   * @param camera 相机
+   * @param candidates 候选对象, 可能在 object 内
+   * @param maxWorldDistance 最大世界空间坐标检测距离
+   * @param boundingBoxes 候选的碰撞盒, 可选
+   * @returns 碰撞到的对象
+   */
+  static getMouseIntersectionOnScreen(
+    objects: NS_THREE.Object3D[] | Element[],
+    { x, y }: { x: number; y: number },
+    { screenWidth, screenHeight }: { screenWidth: number; screenHeight: number },
+    maxDistance: number,
+    camera: NS_THREE.Camera,
+    candidates?: NS_THREE.Object3D[] | Element[],
+    maxWorldDistance = 13,
+    boundingBoxes?: Map<NS_THREE.Object3D | Element, [number, number]>,
+  ): NS_THREE.Object3D | Element | null {
+    const { THREE } = Externals.getInstance();
+    const intersections: { e: NS_THREE.Object3D | Element; d: number }[] = [];
+    const screenPoint = new THREE.Vector2(x, y);
+
+    const frustum = new THREE.Frustum();
+    frustum.setFromProjectionMatrix(new THREE.Matrix4().multiplyMatrices(
+      camera.projectionMatrix,
+      camera.matrixWorldInverse,
+    ));
+
+    const cameraPos = camera.position.clone();
+    const maxWorldDistanceSquared = maxWorldDistance < 0 ? Number.MAX_SAFE_INTEGER : maxWorldDistance ** 2;
+
+    objects.forEach((obj: NS_THREE.Object3D | Element) => {
+      const v3 = obj.position.clone().project(camera);
+      const dist = new THREE.Vector2(
+        (v3.x + 1) / 2 * screenWidth,
+        (1 - v3.y) / 2 * screenHeight,
+      ).distanceTo(screenPoint);
+
+      const mesh = this.getMesh(obj);
+      if (!mesh) return;
+
+      let hasBoundingBox = false;
+      let bboxCollision = false;
+
+      if (boundingBoxes) {
+        const value = boundingBoxes.get(obj);
+        if (value) {
+          hasBoundingBox = true;
+          const center = new THREE.Vector2(
+            (v3.x + 1) / 2 * screenWidth,
+            (1 - v3.y) / 2 * screenHeight,
+          );
+          const leftX = center.x - value[0] / 2;
+          const rightX = center.x + value[0] / 2;
+          const topY = center.y - value[1] / 2;
+          const bottomY = center.y + value[1] / 2;
+          if (
+            Math.abs(v3.z) <= 1
+            && screenPoint.x <= rightX && screenPoint.x >= leftX
+            && screenPoint.y >= topY && screenPoint.y <= bottomY
+          ) {
+            bboxCollision = true;
+          }
+        }
+      }
+
+      if ((hasBoundingBox ? bboxCollision : dist <= maxDistance)
+        && cameraPos.distanceToSquared(mesh.getWorldPosition(new THREE.Vector3())) < maxWorldDistanceSquared
+        && frustum.intersectsObject(mesh)
+        && mesh.visible
+        && obj.visible
+      ) {
+        intersections.push({
+          e: obj,
+          d: dist,
+        });
+      }
+    });
+    intersections.sort((a, b) => a.d - b.d);
+    const candidateSet = new Set<NS_THREE.Object3D>(candidates);
+    for (let i = 0; i < intersections.length; i++) {
+      const target = intersections[i].e;
+      if (candidates) {
+        if (candidateSet.has(target)) return target;
+      } else return target;
+    }
+    return null;
+  }
+
+  /**
+   * 转换俯视图屏幕坐标为三维坐标
+   * @param {x, y} 屏幕坐标
+   * @param view 视图
+   * @param camera 相机
+   */
+  static getHorizontalPlaneCoordinate(
+    { x, y }: { x: number; y: number },
+    view: View,
+    camera: NS_THREE.Camera | undefined,
+  ): NS_THREE.Vector2 | null {
+    if (!camera) {
+      return null;
+    }
+    const { THREE } = Externals.getInstance();
+    const { clientWidth, clientHeight } = view.renderer!.domElement;
+    if (clientWidth <= 0 || clientHeight <= 0) {
+      return null;
+    }
+    const nx = x / clientWidth * 2 - 1;
+    const ny = 1 - y / clientHeight * 2;
+
+    const v = new THREE.Vector3(nx, ny, 0);
+    const coordinate3 = v.unproject(camera!);
+
+    return new THREE.Vector2(coordinate3.x, coordinate3.y);
+  }
+
+  static getHorizontalPlaneCoordinate3(
+    { x, y }: { x: number; y: number },
+    view: View,
+    camera: NS_THREE.Camera | undefined,
+  ): NS_THREE.Vector3 | null {
+    if (!camera) {
+      return null;
+    }
+    const { THREE } = Externals.getInstance();
+    const { clientWidth, clientHeight } = view.renderer!.domElement;
+    if (clientWidth <= 0 || clientHeight <= 0) {
+      return null;
+    }
+    const nx = x / clientWidth * 2 - 1;
+    const ny = 1 - y / clientHeight * 2;
+
+    const v = new THREE.Vector3(nx, ny, 0);
+    const coordinate3 = v.unproject(camera!);
+
+    return coordinate3;
+  }
+
+  /**
+   * 将坐标投影到屏幕空间
+   * @param position 世界坐标
+   * @param view 视图
+   * @param camera 相机
+   * @returns 转换后的屏幕坐标
+   */
+  static projectToScreenCoordinate(
+    position: NS_THREE.Vector3,
+    view: View,
+    camera: NS_THREE.Camera | undefined,
+  ): { x: number; y: number } | null {
+    if (!camera) {
+      return null;
+    }
+    const { clientWidth, clientHeight } = view.renderer!.domElement;
+    if (clientWidth <= 0 || clientHeight <= 0) {
+      return null;
+    }
+    const coordinate2 = position.clone().project(camera!);
+    const x = (coordinate2.x + 1) * 0.5 * clientWidth;
+    const y = (1 - coordinate2.y) * 0.5 * clientHeight;
+    return { x, y };
+  }
+
+  private static getMesh(obj: NS_THREE.Object3D): NS_THREE.Mesh | null {
+    const { THREE } = Externals.getInstance();
+    const target = obj instanceof THREE.Mesh ? obj : null;
+    if (!target && obj.children.length) {
+      for (let i = 0; i < obj.children.length; i += 1) {
+        const t = this.getMesh(obj.children[i]);
+        if (t) return t;
+      }
+    }
+    return target;
+  }
+
+  static debounce(fn: Function, delay: number): Function {
+    let timer: ReturnType<typeof setTimeout>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return function debounceFn(force: boolean, ...args: Array<any>): void {
+      if (force) {
+        fn.bind(null, ...args);
+      }
+      if (timer) {
+        clearTimeout(timer);
+        timer = setTimeout(fn.bind(null, ...args), delay);
+      } else {
+        timer = setTimeout(fn.bind(null, ...args), delay);
+      }
+    };
+  }
+}
+
+export { BasicTools };