@aibee/crc-bmap 0.0.106 → 0.0.108

package/lib/bmap.esm.js

@@ -2791,9 +2791,18 @@ var HoverHelper = class extends EventDispatcher5 {
     }
   };
   onPointerLevel = () => {
+    console.log("level");
     this.curGraphics.clear();
     this.handleHoverGraphicsChange();
   };
+  onBodyPointerMove = (e) => {
+    if (this.curGraphics.size) {
+      const rect = this.context.container.getBoundingClientRect();
+      if (e.clientX < rect.left || e.clientX > rect.right || e.clientY < rect.top || e.clientY > rect.bottom) {
+        this.onPointerLevel();
+      }
+    }
+  };
   handleHoverGraphicsChange(graphics = this.curGraphics) {
     this.dispatchEvent({ type: "hover-change", graphics: Array.from(graphics) });
   }
@@ -2801,11 +2810,13 @@ var HoverHelper = class extends EventDispatcher5 {
     this.context.addEventListener("pointer-over", this.onPointerMove);
     this.context.addEventListener("pointer-move", this.onPointerMove);
     this.context.addEventListener("pointer-level", this.onPointerLevel);
+    document.body.addEventListener("pointermove", this.onBodyPointerMove);
   }
   unRegistryEvent() {
     this.context.removeEventListener("pointer-over", this.onPointerMove);
     this.context.removeEventListener("pointer-move", this.onPointerMove);
     this.context.removeEventListener("pointer-level", this.onPointerLevel);
+    document.body.removeEventListener("pointermove", this.onBodyPointerMove);
   }
   dispose() {
     this.unRegistryEvent();
@@ -3219,7 +3230,8 @@ var Context = class extends EventDispatcher6 {
     const pois = this.getPoisByDeviceXy(e.offsetX, e.offsetY);
     this.dispatchEvent({ type: "pointer-move", e, graphics, pois, position });
   };
-  onPointerleave = () => {
+  onPointerleave = (e) => {
+    console.log(e.type);
     this.dispatchEvent({ type: "pointer-level" });
   };
   onSelectionSelect = ({ graphics, isMultipleSelect }) => {
@@ -3234,6 +3246,8 @@ var Context = class extends EventDispatcher6 {
     this.container.addEventListener("pointerover", this.onPointerover);
     this.container.addEventListener("pointermove", this.onPointermove);
     this.container.addEventListener("pointerleave", this.onPointerleave);
+    this.container.addEventListener("pointercancel", this.onPointerleave);
+    this.container.addEventListener("pointerout", this.onPointerleave);
     this.selection.addEventListener("select", this.onSelectionSelect);
     this.hoverHelper.addEventListener("hover-change", this.onHoverChange);
   }
@@ -3243,6 +3257,8 @@ var Context = class extends EventDispatcher6 {
     this.container.removeEventListener("pointerover", this.onPointerover);
     this.container.removeEventListener("pointermove", this.onPointermove);
     this.container.removeEventListener("pointerleave", this.onPointerleave);
+    this.container.removeEventListener("pointercancel", this.onPointerleave);
+    this.container.removeEventListener("pointerout", this.onPointerleave);
     this.selection.removeEventListener("select", this.onSelectionSelect);
     this.hoverHelper.removeEventListener("hover-change", this.onHoverChange);
   }
@@ -3285,12 +3301,21 @@ var Context = class extends EventDispatcher6 {
    * @param azimuthal 弧度
    */
   setAzimuthalAngle(azimuthal, duration = 500) {
+    const { maxAzimuthAngle, minAzimuthAngle } = this.control;
+    const disable = maxAzimuthAngle === minAzimuthAngle;
+    if (!disable) {
+      if (azimuthal > maxAzimuthAngle && azimuthal < minAzimuthAngle) {
+        return;
+      }
+    }
     if (duration === 0) {
       this.control.maxAzimuthAngle = azimuthal;
       this.control.minAzimuthAngle = azimuthal;
       this.control.update();
-      this.control.maxAzimuthAngle = Infinity;
-      this.control.minAzimuthAngle = Infinity;
+      if (!disable) {
+        this.control.maxAzimuthAngle = maxAzimuthAngle;
+        this.control.minAzimuthAngle = minAzimuthAngle;
+      }
       return;
     }
     return timeoutPromise(
@@ -3303,8 +3328,10 @@ var Context = class extends EventDispatcher6 {
           this.control.update();
         }).onComplete(() => {
           this.control.enabled = true;
-          this.control.maxAzimuthAngle = Infinity;
-          this.control.minAzimuthAngle = Infinity;
+          if (!disable) {
+            this.control.maxAzimuthAngle = maxAzimuthAngle;
+            this.control.minAzimuthAngle = minAzimuthAngle;
+          }
           this.tweenGroup.remove(tween);
           resolve(true);
         }).onStart(() => {
@@ -4047,9 +4074,7 @@ var BMap = class extends EventDispatcher7 {
   }
   rotateMap(radius = 0.1) {
     const azimuthal = this.context.control.getAzimuthalAngle();
-    this.context.control.maxAzimuthAngle = azimuthal + radius;
-    this.context.control.minAzimuthAngle = azimuthal + radius;
-    this.context.control.update();
+    this.context.setAzimuthalAngle(azimuthal + radius, 500);
   }
   /**
    * 测量距离
@@ -4944,7 +4969,7 @@ var arrow_default = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAAAQCAMAA
 // src/plugins/navigation/path.ts
 var defaultConfig2 = {
   texture_url: arrow_default,
-  lineWidth: 16,
+  lineWidth: 8,
   color: 16777215
 };
 var Path2 = class extends Object3D11 {
@@ -5047,7 +5072,7 @@ var Path2 = class extends Object3D11 {
       ),
       depthTest: true,
       sizeAttenuation: false,
-      lineWidth: this.config.lineWidth,
+      lineWidth: this.config.lineWidth * 2,
       map: this.texture,
       blending: NormalBlending,
       repeat: new Vector25(this.getRepeat(), 1)
@@ -5142,48 +5167,107 @@ function simplifyPath(path, ignoreFirst = false, smoothingOptimization = true, s
     const halfMidTailDist = tail.distanceTo(mid) / 2;
     const curveHead = mid.clone();
     const curveTail = mid.clone();
-    curveHead.add(head.clone().sub(mid).normalize().multiplyScalar(
-      halfHeadMidDist > smoothingDistance ? smoothingDistance / 2 : halfHeadMidDist
-    ));
-    curveTail.add(tail.clone().sub(mid).normalize().multiplyScalar(
-      halfMidTailDist > smoothingDistance ? smoothingDistance / 2 : halfMidTailDist
-    ));
+    curveHead.add(
+      head.clone().sub(mid).normalize().multiplyScalar(
+        halfHeadMidDist > smoothingDistance ? smoothingDistance / 2 : halfHeadMidDist
+      )
+    );
+    curveTail.add(
+      tail.clone().sub(mid).normalize().multiplyScalar(
+        halfMidTailDist > smoothingDistance ? smoothingDistance / 2 : halfMidTailDist
+      )
+    );
     const curveToSmooth = [
       [curveHead.x, curveHead.y],
       [mid.x, mid.y],
       [curveTail.x, curveTail.y]
     ];
-    simplifiedPath.push(
-      ...smoothPath(
-        curveToSmooth,
-        smoothingDistance / 25
-      )
-    );
+    simplifiedPath.push(...smoothPath(curveToSmooth, smoothingDistance / 25));
   }
   simplifiedPath.push(joints[joints.length - 1]);
+  return removeWeightPath(simplifiedPath);
+}
+function removeWeightPath(points) {
+  if (points.length <= 1) {
+    return points;
+  }
   const checkedPath = [];
   let lastCheckedPoint;
-  simplifiedPath.forEach(([x, y]) => {
+  points.forEach(([x, y]) => {
     if (!lastCheckedPoint) {
       lastCheckedPoint = [x, y];
       checkedPath.push([x, y]);
-    } else if (!(x === lastCheckedPoint[0] && y === lastCheckedPoint[0])) {
+    } else if (!(x === lastCheckedPoint[0] && y === lastCheckedPoint[1])) {
       lastCheckedPoint = [x, y];
       checkedPath.push([x, y]);
     }
   });
   return checkedPath;
 }
+function distancePointToSegment(point3, start, end) {
+  const segmentLength = Math.sqrt(
+    (end[0] - start[0]) ** 2 + (end[1] - start[1]) ** 2
+  );
+  if (segmentLength === 0) {
+    return {
+      distance: Math.sqrt((point3[0] - start[0]) ** 2 + (point3[1] - start[1]) ** 2),
+      closestPoint: start.slice(0)
+    };
+  }
+  const t = Math.max(
+    0,
+    Math.min(
+      1,
+      ((point3[0] - start[0]) * (end[0] - start[0]) + (point3[1] - start[1]) * (end[1] - start[1])) / segmentLength ** 2
+    )
+  );
+  const closestPoint = [
+    start[0] + t * (end[0] - start[0]),
+    start[1] + t * (end[1] - start[1])
+  ];
+  const distance = Math.sqrt(
+    (point3[0] - closestPoint[0]) ** 2 + (point3[1] - closestPoint[1]) ** 2
+  );
+  return { distance, closestPoint };
+}
+function moveOnRoute(startPoint, endPoint, distance) {
+  const [startX, startY] = startPoint;
+  const [endX, endY] = endPoint;
+  const routeLength = Math.sqrt(Math.pow(endX - startX, 2) + Math.pow(endY - startY, 2));
+  const ratio = distance / routeLength;
+  const newX = startX + (endX - startX) * ratio;
+  const newY = startY + (endY - startY) * ratio;
+  return [newX, newY];
+}
 
 // src/plugins/navigation/navigation.ts
+import { Group as TweenGroup2, Tween as Tween2 } from "@tweenjs/tween.js";
+var defaultConfig3 = {
+  path: {},
+  speed: 10,
+  cheapMaximumDistance: 20,
+  needStartPoi: false,
+  startPoi: {}
+};
 var Navigation = class extends Plugin {
   path = null;
   worker = Worker2();
   fetchRoadStatus = false;
   uniqueKey = new UniqueKey();
   paths = [];
-  constructor(bmap, project) {
+  options;
+  pathTween = new TweenGroup2();
+  startPoi = null;
+  // 处理路线动画
+  animationPathOptions = {
+    cPathIndex: 0
+    // 在平滑路线中的下标（平滑但是未做插值的数据，是做路线渲染的）
+  };
+  cPath = [];
+  // 当前楼层的平滑后的路线
+  constructor(bmap, project, options = {}) {
     super(bmap);
+    this.options = Object.assign({}, defaultConfig3, options);
     const {
       apiDomain,
       apiPath: { roadNetwork },
@@ -5201,18 +5285,35 @@ var Navigation = class extends Plugin {
         this.dispatchEvent({ type: "fetch-road-status", status: true });
       }
     });
+    this.registryEvent();
+  }
+  registryEvent() {
+    this.bmap.context.addEventListener("update", this.onUpdate);
     this.bmap.addEventListener(
       "switch_floor_after" /* SWITCH_FLOOR_AFTER */,
       this.onSwitchFloor
     );
   }
+  unRegistryEvent() {
+    this.bmap.context.removeEventListener("update", this.onUpdate);
+    this.bmap.removeEventListener(
+      "switch_floor_after" /* SWITCH_FLOOR_AFTER */,
+      this.onSwitchFloor
+    );
+  }
+  onUpdate = () => {
+    this.pathTween.update();
+  };
   triggerWorker(type, data) {
     this.worker.postMessage({ type, data });
   }
   clearPath() {
     if (this.path) {
       this.bmap.context.scene.remove(this.path);
+      this.path.dispose();
       this.path = null;
+      this.pathTween.getAll().forEach((item) => item.stop());
+      this.pathTween.removeAll();
     }
   }
   onSwitchFloor = ({ data: { curFloor } }) => {
@@ -5304,30 +5405,134 @@ var Navigation = class extends Plugin {
     });
   }
   renderPath(points) {
-    const cPath = this.catmullRomCurve3(points).map(([x, y]) => [
-      x,
-      y
-    ]);
+    const cPath = this.catmullRomCurve3(points);
+    this.cPath = cPath;
+    this.animationPathOptions = {
+      cPathIndex: 0
+    };
     if (this.path) {
       this.path.updatePoints(cPath);
     } else {
-      this.path = new Path2(this, {});
+      this.path = new Path2(this, this.options.path);
       this.path.create(cPath);
       this.path.position.z = this.bmap.context.currentFloor.groundMaxHeight + 0.1;
       this.bmap.context.scene.add(this.path);
     }
+    if (this.startPoi) {
+      this.startPoi.dispose();
+      this.startPoi = null;
+    }
+    if (this.options.needStartPoi) {
+      this.startPoi = this.bmap.context.currentFloor?.addPoi({
+        ...this.options.startPoi,
+        position: { x: cPath[0][0], y: cPath[0][1], z: 1e-4 },
+        collision_enable: false
+      }) || null;
+    }
   }
   catmullRomCurve3(points) {
-    return simplifyPath(points, true, true, 10, 150, 3);
+    return simplifyPath(points, false, true, 0.1, 150, 2.5);
+  }
+  /**
+   * 按照指定速度移动到目标位置
+   * @param point 目标位置
+   * @param speed 移动速度
+   */
+  async animationTo(point3, speed = this.options.speed) {
+    if (point3.floor !== this.bmap.context.currentFloor?.name || !this.path) {
+      return;
+    }
+    const {
+      animationPathOptions: { cPathIndex }
+    } = this;
+    const currentPath = [
+      this.path.points[0],
+      ...this.cPath.slice(cPathIndex + 1)
+    ];
+    const translatedPos = this.translatePoints([point3.pos])[0];
+    const { distance, pos, index } = currentPath.reduce(
+      (res, cur, index2, arr) => {
+        if (index2 === arr.length - 1) {
+          return res;
+        }
+        const { distance: distance2, closestPoint } = distancePointToSegment(
+          translatedPos,
+          cur,
+          arr[index2 + 1]
+        );
+        if (distance2 < res.distance) {
+          res.distance = distance2;
+          res.pos = closestPoint;
+          res.index = index2;
+        }
+        return res;
+      },
+      {
+        distance: Number.MAX_SAFE_INTEGER,
+        pos: point3.pos,
+        index: 0
+      }
+    );
+    if (distance > this.options.cheapMaximumDistance) {
+      return;
+    }
+    if (this.path.points[0][0] === pos[0] && this.path.points[0][1] === pos[1]) {
+      return;
+    }
+    let moveDistance = 0;
+    let moveDistanceArray = [];
+    if (index === 0) {
+      moveDistance = getLength(currentPath[0], pos);
+      moveDistanceArray = [moveDistance];
+    } else {
+      moveDistanceArray = [getLength(currentPath[0], currentPath[1])];
+      for (let i = 1; i < index; i++) {
+        moveDistanceArray.push(getLength(currentPath[i], currentPath[i + 1]));
+      }
+      moveDistanceArray.push(getLength(currentPath[index], pos));
+      moveDistance = moveDistanceArray.reduce((sum, cur) => sum + cur, 0);
+    }
+    const speedSecond = this.kmPerHourToMetersPerSecond(speed);
+    const timeSecond = moveDistance / speedSecond;
+    this.pathTween.getAll().forEach((item) => item.stop());
+    this.pathTween.removeAll();
+    const start = { distance: 0 };
+    return new Promise((resolve) => {
+      const tween = new Tween2(start, this.pathTween).to({ distance: moveDistance }, timeSecond * 1e3).onUpdate(() => {
+        for (let i = 0; i < moveDistanceArray.length; i++) {
+          const sumDistance = moveDistanceArray.slice(0, i + 1).reduce((sum, cur) => sum + cur, 0);
+          if (sumDistance >= start.distance) {
+            const prevDistance = sumDistance - moveDistanceArray[i];
+            const needDistance = start.distance - prevDistance;
+            const startPoint = currentPath[i];
+            const nextPoint = currentPath[i + 1];
+            const pos2 = moveOnRoute(startPoint, nextPoint, needDistance);
+            this.path?.updatePoints([pos2, ...currentPath.slice(i + 1)]);
+            this.animationPathOptions.cPathIndex += i;
+            if (this.startPoi) {
+              this.startPoi.position.setX(pos2[0]).setY(pos2[1]);
+            }
+            this.dispatchEvent({ type: "path-animation" });
+            return;
+          }
+        }
+      }).onComplete(() => {
+        this.pathTween.remove(tween);
+        this.dispatchEvent({ type: "path-animation-end" });
+        resolve(true);
+      }).start();
+    });
+  }
+  kmPerHourToMetersPerSecond(speedInKmPerHour) {
+    const speedInMetersPerSecond = speedInKmPerHour * 1e3 / 3600;
+    return speedInMetersPerSecond;
   }
   dispose() {
     this.worker.terminate();
-    this.bmap.removeEventListener(
-      "switch_floor_after" /* SWITCH_FLOOR_AFTER */,
-      this.onSwitchFloor
-    );
+    this.unRegistryEvent();
     this.path?.dispose();
     this.uniqueKey.dispose();
+    this.startPoi?.dispose();
   }
 };