@aibee/crc-bmap 0.1.2 → 0.1.3

package/lib/bmap.esm.js

@@ -838,6 +838,9 @@ function hexToRgb(hex, opacity) {
 
 // src/utils/os.ts
 var isMac = navigator.userAgent.toUpperCase().indexOf("MAC") >= 0;
+var UA = (window.navigator.userAgent || "").toLocaleLowerCase();
+var isIphone = /ios|iphone/i.test(UA);
+var isAndroid = /android|adr|linux/gi.test(UA);
 
 // src/utils/keyboard.ts
 function isControl(key) {
@@ -1146,6 +1149,49 @@ function getDirectPath(points) {
   });
   return arr;
 }
+function getDistanceByPathPos(path, pos) {
+  if (path.length < 2) {
+    return -1;
+  }
+  let distance = 0;
+  for (let i = 1; i < path.length; i++) {
+    const prev = path[i - 1];
+    const curr = path[i];
+    const v1 = [pos[0] - prev[0], pos[1] - prev[1]];
+    const v2 = [curr[0] - prev[0], curr[1] - prev[1]];
+    const withinX = Math.min(curr[0], prev[0]) <= pos[0] && pos[0] <= Math.max(curr[0], prev[0]);
+    const withinY = Math.min(curr[1], prev[1]) <= pos[1] && pos[1] <= Math.max(curr[1], prev[1]);
+    console.log(withinX, withinY);
+    if (withinX && withinY) {
+      const crossProduct = v1[0] * v2[1] - v1[1] * v2[0];
+      if (Math.abs(crossProduct) < 1e-6) {
+        const segmentDistance = Math.sqrt((pos[0] - prev[0]) ** 2 + (pos[1] - prev[1]) ** 2);
+        return distance + segmentDistance;
+      }
+    }
+    distance += Math.sqrt((curr[0] - prev[0]) ** 2 + (curr[1] - prev[1]) ** 2);
+  }
+  return -1;
+}
+function getPosByPathDistance(path, distance) {
+  if (path.length < 2) {
+    return path[0] ?? null;
+  }
+  let accumulatedDistance = 0;
+  for (let i = 1; i < path.length; i++) {
+    const prev = path[i - 1];
+    const curr = path[i];
+    const segmentLength = Math.sqrt((curr[0] - prev[0]) ** 2 + (curr[1] - prev[1]) ** 2);
+    accumulatedDistance += segmentLength;
+    if (accumulatedDistance >= distance) {
+      const ratio = (distance - (accumulatedDistance - segmentLength)) / segmentLength;
+      const x = prev[0] + (curr[0] - prev[0]) * ratio;
+      const y = prev[1] + (curr[1] - prev[1]) * ratio;
+      return [x, y];
+    }
+  }
+  return null;
+}
 
 // src/utils/road.ts
 var import_node_dijkstra = __toESM(require_Graph(), 1);
@@ -2119,7 +2165,7 @@ function toWebWorker(obj) {
 }
 
 // src/utils/create.ts
-import { BufferGeometry, Line, LineBasicMaterial } from "three";
+import { BoxGeometry, BufferGeometry, Line, LineBasicMaterial, Mesh } from "three";
 function createThreeLine(points, color = 16711680) {
   const material = new LineBasicMaterial({
     color
@@ -2128,6 +2174,15 @@ function createThreeLine(points, color = 16711680) {
   const line = new Line(geometry, material);
   return line;
 }
+function createThreeBox(pos, color = 16711680) {
+  const material = new LineBasicMaterial({
+    color
+  });
+  const geometry = new BoxGeometry(1, 1, 1);
+  const mesh = new Mesh(geometry, material);
+  mesh.position.copy(pos);
+  return mesh;
+}
 
 // src/utils/translate.ts
 function transformGraphicData(data, center2, baseIndex = 0) {
@@ -2165,6 +2220,51 @@ function translatePosToCenter(cds, center2) {
   return [cds[0] - center2[0], cds[1] - center2[1]];
 }
 
+// src/utils/tween.ts
+import { Group as Group2 } from "@tweenjs/tween.js";
+var TweenUtil = class {
+  pauseTween = false;
+  // 暂停动画
+  tweenStore = /* @__PURE__ */ new Set();
+  // 暂存的动画  在暂停的时候存入，在继续的时候清空
+  group = new Group2();
+  constructor() {
+  }
+  update() {
+    this.group.update();
+  }
+  pause() {
+    this.pauseTween = true;
+    this.getAll().forEach((item) => {
+      this.tweenStore.add(item);
+      item.pause();
+    });
+  }
+  continue() {
+    if (!this.pauseTween) {
+      return;
+    }
+    this.tweenStore.forEach((item) => {
+      item.resume();
+    });
+    this.tweenStore.clear();
+    this.pauseTween = false;
+  }
+  remove(tween) {
+    this.group.remove(tween);
+  }
+  getAll() {
+    return this.group.getAll();
+  }
+  clear() {
+    this.getAll().forEach((item) => item.stop());
+    this.group.removeAll();
+  }
+  dispose() {
+    this.clear();
+  }
+};
+
 // src/context/context.ts
 import {
   EventDispatcher as EventDispatcher7,
@@ -2184,7 +2284,7 @@ import { EventDispatcher as EventDispatcher4 } from "three";
 import {
   Object3D,
   ExtrudeGeometry,
-  Mesh,
+  Mesh as Mesh2,
   Box3,
   Vector3 as Vector34,
   BufferGeometry as BufferGeometry2,
@@ -2771,21 +2871,6 @@ var Graphic = class extends Object3D {
     this.material = [material, material1];
     return [material, material1];
   }
-  // createMesh(pos: Vector3, color = 0xff0000) {
-  //   const geometry = new BoxGeometry(1, 1, 1)
-  //   const material = new MeshBasicMaterial({ color })
-  //   const mesh = new Mesh(geometry, material)
-  //   mesh.position.copy(pos)
-  //   this.context.scene.add(mesh)
-  // }
-  // createLine(points: Vector3[], color = 0xff0000) {
-  //   const material = new LineBasicMaterial({
-  //     color: color
-  //   });
-  //   const geometry = new BufferGeometry().setFromPoints(points);
-  //   const line = new Line( geometry, material );
-  //   this.context.scene.add(line)
-  // }
   getMaxAndMin(pos, dir) {
     const box = new Box3().setFromObject(this);
     const minOrigin = pos.clone().add(dir.clone().multiplyScalar(1e3));
@@ -2858,7 +2943,7 @@ var Graphic = class extends Object3D {
     if (this.mesh) {
       this.remove(this.mesh);
     }
-    this.mesh = new Mesh(this.geometry, this.material);
+    this.mesh = new Mesh2(this.geometry, this.material);
     this.add(this.mesh);
   }
   getBorderPoints() {
@@ -2920,7 +3005,7 @@ var Graphic = class extends Object3D {
 import {
   Object3D as Object3D2,
   PlaneGeometry,
-  Mesh as Mesh2,
+  Mesh as Mesh3,
   ShadowMaterial,
   Color as Color2,
   DoubleSide as DoubleSide2
@@ -2966,7 +3051,7 @@ var Shadow = class extends Object3D2 {
       opacity: 0,
       side: DoubleSide2
     });
-    const mesh = new Mesh2(geometry, material);
+    const mesh = new Mesh3(geometry, material);
     mesh.receiveShadow = true;
     mesh.position.z = -10;
     this.add(mesh);
@@ -3572,7 +3657,7 @@ import {
   PlaneGeometry as PlaneGeometry2,
   Texture as Texture2,
   DoubleSide as DoubleSide3,
-  Mesh as Mesh3,
+  Mesh as Mesh4,
   Matrix3 as Matrix32,
   Vector2 as Vector26
 } from "three";
@@ -3619,7 +3704,7 @@ var HeatmapElement = class extends Object3D5 {
       map: texture
     });
     material.needsUpdate = true;
-    this.plane = new Mesh3(geometry, material);
+    this.plane = new Mesh4(geometry, material);
     this.add(this.plane);
   }
   getTransMatrix({ x, y }) {
@@ -4605,7 +4690,7 @@ import {
   Color as Color3,
   ExtrudeGeometry as ExtrudeGeometry2,
   LineSegments as LineSegments2,
-  Mesh as Mesh4,
+  Mesh as Mesh5,
   Object3D as Object3D9,
   ShaderMaterial as ShaderMaterial3,
   Vector3 as Vector313
@@ -4761,7 +4846,7 @@ var Wall = class extends Object3D9 {
   init() {
     this.initGeometry();
     this.initMaterial();
-    const mesh = new Mesh4(this.geometry, this.material);
+    const mesh = new Mesh5(this.geometry, this.material);
     this.add(mesh);
     if (this.options[0].strokeOpacity !== 0) {
       this.initLineMaterial();
@@ -4781,7 +4866,7 @@ var Wall = class extends Object3D9 {
 import {
   DoubleSide as DoubleSide4,
   Float32BufferAttribute,
-  Mesh as Mesh5,
+  Mesh as Mesh6,
   MeshBasicMaterial as MeshBasicMaterial4,
   Object3D as Object3D10,
   ShapeGeometry
@@ -4839,7 +4924,7 @@ var GroundTexture = class extends Object3D10 {
       });
       return material;
     }));
-    const mesh = new Mesh5(geometry, materials);
+    const mesh = new Mesh6(geometry, materials);
     this.mesh = mesh;
     this.position.z += 4e-3;
     this.add(mesh);
@@ -4852,7 +4937,7 @@ var GroundTexture = class extends Object3D10 {
 };
 
 // src/elements/glb-model.ts
-import { Box3 as Box37, Mesh as Mesh6, Object3D as Object3D11, Vector3 as Vector314 } from "three";
+import { Box3 as Box37, Mesh as Mesh7, Object3D as Object3D11, Vector3 as Vector314 } from "three";
 var defaultGlbOptions = {
   url: "",
   geometry: { type: "polygon", cds: [], coords: [], curveCpt: [], curveIndex: [] },
@@ -4889,7 +4974,7 @@ var GlbModel = class extends Object3D11 {
     this.rotateZ(this.options.rotate);
   }
   meshSetMaterial(object) {
-    if (object instanceof Mesh6) {
+    if (object instanceof Mesh7) {
       object.frustumCulled = false;
       object.castShadow = true;
       object.material.emissiveIntensity *= 0.95;
@@ -4908,7 +4993,7 @@ var GlbModel = class extends Object3D11 {
 };
 
 // src/elements/lane.ts
-import { BufferGeometry as BufferGeometry4, LineSegments as LineSegments3, Mesh as Mesh7, Object3D as Object3D12, ShapeGeometry as ShapeGeometry2, Vector2 as Vector28, Vector3 as Vector315 } from "three";
+import { BufferGeometry as BufferGeometry4, LineSegments as LineSegments3, Mesh as Mesh8, Object3D as Object3D12, ShapeGeometry as ShapeGeometry2, Vector2 as Vector28, Vector3 as Vector315 } from "three";
 import { mergeGeometries as mergeGeometries3 } from "three/examples/jsm/utils/BufferGeometryUtils";
 import { Line2 as Line22 } from "three/examples/jsm/lines/Line2";
 import { LineGeometry } from "three/examples/jsm/lines/LineGeometry";
@@ -5029,7 +5114,7 @@ var Lane = class extends Object3D12 {
   init() {
     this.initGeometry();
     this.initMaterial();
-    const mesh = new Mesh7(this.geometry, this.material);
+    const mesh = new Mesh8(this.geometry, this.material);
     this.add(mesh);
     if (this.options[0].strokeOpacity !== 0) {
       this.initLineMaterial();
@@ -5051,7 +5136,7 @@ var Lane = class extends Object3D12 {
 import {
   Object3D as Object3D13,
   ExtrudeGeometry as ExtrudeGeometry3,
-  Mesh as Mesh8,
+  Mesh as Mesh9,
   Vector3 as Vector316,
   BufferGeometry as BufferGeometry5,
   LineSegments as LineSegments4,
@@ -5170,7 +5255,7 @@ var MergeGraphic = class extends Object3D13 {
     if (this.mesh) {
       this.remove(this.mesh);
     }
-    this.mesh = new Mesh8(this.geometry, this.material);
+    this.mesh = new Mesh9(this.geometry, this.material);
     this.add(this.mesh);
   }
   getBorderPoints() {
@@ -5276,10 +5361,7 @@ var Poi2 = class extends Object3D14 {
     return this.options.text ? this.options.text_font_size : 0;
   }
   get deltaZ() {
-    const { offset, iconHeight, durIconAndText, textHeight } = this;
-    let dz = offset * (iconHeight + durIconAndText + textHeight) / this.context.camera.zoom;
-    dz += 0.1;
-    return dz;
+    return 0.1;
   }
   get canSelect() {
     return this.visible && (this.spriteIcon ? this.spriteIcon.visible : true) && (this.spriteText ? this.spriteText.visible : true);
@@ -5423,9 +5505,9 @@ var Poi2 = class extends Object3D14 {
     if (!this.boxHelper) {
       const div = document.createElement("div");
       div.style.position = "fixed";
-      this.boxHelper = div;
       div.style.border = "1px solid red";
       div.style.pointerEvents = "none";
+      this.boxHelper = div;
       this.context.container.appendChild(div);
     }
     this.boxHelper.style.left = this.box.min.x + "px";
@@ -5455,7 +5537,7 @@ var Poi2 = class extends Object3D14 {
 import {
   DoubleSide as DoubleSide5,
   Matrix4 as Matrix42,
-  Mesh as Mesh9,
+  Mesh as Mesh10,
   MeshBasicMaterial as MeshBasicMaterial6,
   Object3D as Object3D15,
   PlaneGeometry as PlaneGeometry3
@@ -5521,7 +5603,7 @@ var TextTexture = class extends Object3D15 {
       texture.needsUpdate = true;
       return material;
     });
-    const mesh = new Mesh9(geometry, materials);
+    const mesh = new Mesh10(geometry, materials);
     this.mesh = mesh;
     this.position.z += 4e-3;
     this.add(mesh);
@@ -5998,7 +6080,7 @@ var CameraBound = class {
 // src/context/control.ts
 import { Vector3 as Vector320 } from "three";
 import { MapControls } from "three/examples/jsm/controls/MapControls";
-import { Tween, Group as TweenGroup } from "@tweenjs/tween.js";
+import { Tween as Tween2, Group as TweenGroup } from "@tweenjs/tween.js";
 var Control = class extends MapControls {
   constructor(context, camera, domElement) {
     super(camera, domElement);
@@ -6051,7 +6133,7 @@ var Control = class extends MapControls {
       new Promise((resolve) => {
         const start = { polar: this.getPolarAngle() };
         const end = { polar };
-        const tween = new Tween(start, this.tweenGroup).to(end, duration).onUpdate(() => {
+        const tween = new Tween2(start, this.tweenGroup).to(end, duration).onUpdate(() => {
           this.setPolarAngle(start.polar, force);
         }).onComplete(() => {
           this.enabled = true;
@@ -6090,7 +6172,7 @@ var Control = class extends MapControls {
       new Promise((resolve) => {
         const start = { azimuthal: this.getAzimuthalAngle() };
         const end = { azimuthal };
-        const tween = new Tween(start, this.tweenGroup).to(end, duration).onUpdate(() => {
+        const tween = new Tween2(start, this.tweenGroup).to(end, duration).onUpdate(() => {
           this.setAzimuthalAngle(start.azimuthal, force);
         }).onComplete(() => {
           this.enabled = true;
@@ -6122,7 +6204,7 @@ var Control = class extends MapControls {
     }
     return timeoutPromise(
       new Promise((resolve) => {
-        const tween = new Tween(start, this.tweenGroup).to(newTarget, duration).onUpdate(() => {
+        const tween = new Tween2(start, this.tweenGroup).to(newTarget, duration).onUpdate(() => {
           this.camera.position.copy(start.clone().sub(lookAtVector));
           this.target.copy(start.clone());
           this.update();
@@ -6166,7 +6248,7 @@ var Control = class extends MapControls {
     }
     return timeoutPromise(
       new Promise((resolve) => {
-        const tween = new Tween(start, this.tweenGroup).to(
+        const tween = new Tween2(start, this.tweenGroup).to(
           {
             zoom,
             target: center2
@@ -7174,7 +7256,7 @@ var Equipment = class extends Plugin {
 
 // src/plugins/navigation/path.ts
 import {
-  Mesh as Mesh10,
+  Mesh as Mesh11,
   Object3D as Object3D18,
   TextureLoader as TextureLoader2,
   Color as Color8,
@@ -7853,7 +7935,6 @@ var Path2 = class extends Object3D18 {
   texture = null;
   config = defaultConfig2;
   points = [];
-  pathDistance = 0;
   basicRepeat = 1;
   prevCameraZoom = 0;
   registryEvent() {
@@ -7921,18 +8002,16 @@ var Path2 = class extends Object3D18 {
   }
   updatePoints(points) {
     this.points = points;
-    this.pathDistance = getPathLength(points);
     this.changeRepeat();
     const _points = this.transformPoints(points);
     if (this.geometry) {
       this.geometry.setPoints(_points);
     }
   }
-  movePath(distance) {
-    if (!this.material || !this.pathDistance) {
+  movePath(ratio) {
+    if (!this.material) {
       return;
     }
-    const ratio = distance / this.pathDistance;
     this.material.thresholdRatio = ratio;
   }
   async create(points) {
@@ -7959,7 +8038,7 @@ var Path2 = class extends Object3D18 {
       blending: NormalBlending,
       repeat: new Vector213(this.getRepeat(), 1)
     });
-    const mesh = this.mesh = new Mesh10(lineGeometry, material);
+    const mesh = this.mesh = new Mesh11(lineGeometry, material);
     mesh.renderOrder = 9;
     this.add(mesh);
     return mesh;
@@ -7974,25 +8053,36 @@ var Path2 = class extends Object3D18 {
 };
 
 // src/plugins/navigation/navigation.ts
-import { Group as TweenGroup2, Tween as Tween2, Easing } from "@tweenjs/tween.js";
+import { Tween as Tween3, Easing } from "@tweenjs/tween.js";
 import { Vector3 as Vector325 } from "three";
 var defaultConfig3 = {
   path: {},
-  speed: 10,
   cheapMaximumDistance: 20,
   needStartPoi: false,
   startPoi: {},
-  offsetY: 150
+  offsetY: 150,
+  directionEmitThreshold: 5,
+  disablePathAnimation: false
 };
 var Navigation = class extends Plugin {
   path = null;
   fetchRoadStatus = false;
   paths = [];
+  // 原始坐标路线
+  curPathIndex = 0;
+  // 当前展示的路线所在的下标
+  curFloorPath = null;
+  // 当前楼层原始坐标路线
+  translatePath = null;
+  // 对原始坐标做完平移路线，只有当前楼层
+  currentPathPosition = null;
+  // 起点所在的当前位置，平移前坐标
   options;
-  pathTween = new TweenGroup2();
+  pathTween = null;
   startPoi = null;
   movedDistance = 0;
   pathStart = [0, 0];
+  tweenUtil = new TweenUtil();
   // 处理路线动画
   animationPathOptions = {
     cPathIndex: 0
@@ -8000,8 +8090,11 @@ var Navigation = class extends Plugin {
   };
   cPath = [];
   // 当前楼层的平滑后的路线
-  constructor(bmap, project, options = {}) {
+  constructor(bmap, project = {}, options) {
     super(bmap);
+    if (!options && typeof project === "object") {
+      options = project;
+    }
     this.options = Object.assign({}, defaultConfig3, options);
     const {
       apiDomain,
@@ -8010,6 +8103,12 @@ var Navigation = class extends Plugin {
     } = this.bmap.config;
     this.registryEvent();
   }
+  get curFloorPathLength() {
+    return this.curFloorPath?.distance ?? 0;
+  }
+  get curFloorPathPoints() {
+    return this.curFloorPath?.points ?? [];
+  }
   registryEvent() {
     this.bmap.context.addEventListener("update", this.onUpdate);
     this.bmap.addEventListener(
@@ -8017,6 +8116,12 @@ var Navigation = class extends Plugin {
       this.onSwitchFloor
     );
   }
+  pauseAnimation() {
+    this.tweenUtil.pause();
+  }
+  continueAnimation() {
+    this.tweenUtil.continue();
+  }
   unRegistryEvent() {
     this.bmap.context.removeEventListener("update", this.onUpdate);
     this.bmap.removeEventListener(
@@ -8025,26 +8130,44 @@ var Navigation = class extends Plugin {
     );
   }
   onUpdate = () => {
-    this.pathTween.update();
+    this.tweenUtil.update();
   };
   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();
+      this.tweenUtil.clear();
     }
     if (this.startPoi) {
       this.bmap.context.currentFloor?.poiLayer2.removePoi(this.startPoi);
       this.startPoi = null;
     }
+    this.translatePath = null;
+  }
+  setCurFloorPath(path) {
+    if (path === null) {
+      this.curFloorPath = null;
+      this.currentPathPosition = null;
+    } else {
+      this.curFloorPath = path;
+      this.currentPathPosition = path.points[0];
+    }
+    this.movedDistance = 0;
+  }
+  setCurPathIndex(index) {
+    this.curPathIndex = index;
+    if (this.paths[index]?.floor === this.bmap.context.currentFloor?.name) {
+      this.setCurFloorPath(this.paths[index]);
+      this.renderPath(this.translatePoints(this.curFloorPathPoints));
+    } else {
+      this.clearPath();
+    }
   }
   onSwitchFloor = ({ data: { curFloor } }) => {
-    if (this.paths.length) {
-      const curFloorPathData = this.paths.find(
-        (item) => item.floor === curFloor.name
-      );
+    if (this.paths[this.curPathIndex]) {
+      const curFloorPathData = this.paths[this.curPathIndex];
+      this.setCurFloorPath(curFloorPathData ?? null);
       if (curFloorPathData) {
         this.renderPath(this.translatePoints(curFloorPathData.points));
       } else {
@@ -8054,11 +8177,13 @@ var Navigation = class extends Plugin {
       this.clearPath();
     }
   };
-  addPath(paths) {
+  addPath(paths, routeIndex = 0) {
     this.paths = paths;
+    this.curPathIndex = routeIndex;
     const floorName = this.bmap.context.currentFloor?.name;
-    const curFloorPath = paths.find((item) => item.floor === floorName);
-    if (curFloorPath) {
+    const curFloorPath = paths[routeIndex];
+    if (floorName && curFloorPath?.floor === floorName) {
+      this.setCurFloorPath(curFloorPath);
       if (this.bmap.currentBuildGround) {
         this.renderPath(this.translatePoints(curFloorPath.points));
       } else {
@@ -8079,12 +8204,12 @@ var Navigation = class extends Plugin {
     });
   }
   renderPath(points) {
+    this.translatePath = points;
     const cPath = this.catmullRomCurve3(points);
     this.cPath = cPath;
     this.animationPathOptions = {
       cPathIndex: 0
     };
-    this.movedDistance = 0;
     this.pathStart = cPath[0];
     if (this.path) {
       this.path.updatePoints(cPath);
@@ -8094,6 +8219,10 @@ var Navigation = class extends Plugin {
       this.path.position.z = this.bmap.context.currentFloor.groundMaxHeight + 0.5;
       this.bmap.context.scene.add(this.path);
     }
+    this.dispatchEvent({
+      type: "render-path",
+      path: this.path
+    });
     if (this.startPoi) {
       this.bmap.context.currentFloor?.poiLayer2.removePoi(this.startPoi);
       this.startPoi = null;
@@ -8102,21 +8231,21 @@ var Navigation = class extends Plugin {
       this.startPoi = new Poi2(this.bmap.context, {
         ...this.options.startPoi,
         id: "navigation_start_poi",
-        position: { x: cPath[0][0], y: cPath[0][1], z: 1e-4 },
+        position: { x: cPath[0][0], y: cPath[0][1], z: 0.51 },
         collision_enable: false
       }) || null;
       this.bmap.context.currentFloor?.poiLayer2.pushPoi(this.startPoi);
     }
   }
   catmullRomCurve3(points) {
-    return simplifyPath(points, false, true, 0.1, 150, 2.5);
+    return simplifyPath(points, false, true, 0.1, 170, 2.5);
   }
   /**
    * 按照指定速度移动到目标位置
    * @param point 目标位置
    * @param speed 移动速度 / 米/s
    */
-  async animationTo(point3, speed = this.options.speed) {
+  async animationTo(point3, speed) {
     if (point3.floor !== this.bmap.context.currentFloor?.name || !this.path) {
       return;
     }
@@ -8171,14 +8300,13 @@ var Navigation = class extends Plugin {
       moveDistance = moveDistanceArray.reduce((sum, cur) => sum + cur, 0);
     }
     const timeSecond = moveDistance / speed;
-    this.pathTween.getAll().forEach((item) => item.stop());
-    this.pathTween.removeAll();
+    this.tweenUtil.clear();
     const start = { distance: 0 };
     const prevCPathIndex = this.animationPathOptions.cPathIndex;
     let pastRouteLength = 0;
     let pastRouteIndex = 0;
     return new Promise((resolve) => {
-      const tween = new Tween2(start, this.pathTween).to({ distance: moveDistance }, timeSecond * 1e3).onUpdate(async () => {
+      const tween = new Tween3(start, this.tweenUtil.group).to({ distance: moveDistance }, timeSecond * 1e3).onUpdate(async () => {
         let dis = start.distance - pastRouteLength;
         while (moveDistanceArray.length && dis > moveDistanceArray[0]) {
           pastRouteLength += moveDistanceArray.shift();
@@ -8203,7 +8331,7 @@ var Navigation = class extends Plugin {
         tween.resume();
         this.dispatchEvent({ type: "path-animation", pathIndex: this.animationPathOptions.cPathIndex });
       }).onComplete(() => {
-        this.pathTween.remove(tween);
+        this.tweenUtil.remove(tween);
         this.dispatchEvent({ type: "path-animation-end" });
         this.movedDistance += moveDistance;
         resolve(true);
@@ -8212,25 +8340,22 @@ var Navigation = class extends Plugin {
   }
   // 计算路线的方向
   getPathDirection() {
-    const path = this.cPath.slice(this.animationPathOptions.cPathIndex);
-    if (path.length < 3) {
+    if (!this.curFloorPath || !this.currentPathPosition) {
       return null;
     }
-    const p0 = path[0];
-    const p1 = path[1];
-    const p2 = path[2];
-    const angle = calc_angle(p0, p1, p2);
-    if (Math.abs(angle) >= 179.5 && Math.abs(angle) <= 180) {
-      const v1 = new Vector325(p2[0] - p1[0], p2[1] - p1[1], 0).normalize();
-      const v2 = new Vector325(0, 1, 0).normalize();
-      const angle2 = v1.angleTo(v2);
-      const cross = new Vector325().crossVectors(v2, v1);
-      const sign = Object.is(cross.y, 0) ? -1 : 1;
-      const finalAngle = sign * angle2;
-      return finalAngle;
-    } else {
+    if (this.curFloorPathPoints.length < 2) {
       return null;
     }
+    const index = getPointEdgeIndex(this.curFloorPathPoints, this.currentPathPosition);
+    const l1 = this.curFloorPathPoints[index];
+    const l2 = this.curFloorPathPoints[index + 1];
+    const v1 = new Vector325(l2[0] - l1[0], l2[1] - l1[1], 0).normalize();
+    const v2 = new Vector325(0, 1, 0).normalize();
+    const angle = v1.angleTo(v2);
+    const cross = new Vector325().crossVectors(v2, v1);
+    const sign = Object.is(cross.y, 0) ? -1 : 1;
+    const finalAngle = sign * angle;
+    return finalAngle;
   }
   // 把相机旋转到路线的上方向
   async changeCameraToPathUp(duration = 100) {
@@ -8255,13 +8380,13 @@ var Navigation = class extends Plugin {
     return new Promise((resolve) => {
       const start = { azimuthal: control.getAzimuthalAngle() };
       const end = { azimuthal: angle };
-      const tween = new Tween2(start, this.pathTween).to(end, time).easing(Easing.Quadratic.InOut).onUpdate(async () => {
+      const tween = new Tween3(start, this.tweenUtil.group).to(end, time).easing(Easing.Quadratic.InOut).onUpdate(async () => {
         control.target.copy(this.startPoi.position);
         control.setAzimuthalAngle(start.azimuthal, true);
         control.setTargetByOffset(this.options.offsetY);
       }).onComplete(() => {
         control.enabled = true;
-        this.pathTween.remove(tween);
+        this.tweenUtil.remove(tween);
         resolve(true);
       }).onStart(() => {
         control.enabled = false;
@@ -8320,7 +8445,134 @@ var Navigation = class extends Plugin {
       duration
     );
   }
+  async toPositionBySpeed(position, speed) {
+    if (this.pathTween) {
+      this.tweenUtil.clear();
+    }
+    const { currentPathPosition, curFloorPath, curFloorPathPoints } = this;
+    if (!curFloorPath || !currentPathPosition) {
+      return null;
+    }
+    const curDistance = this.movedDistance;
+    const positionDistance = getDistanceByPathPos(curFloorPathPoints, position);
+    console.log(curDistance, positionDistance);
+    if (curDistance === -1 || positionDistance === -1) {
+      return null;
+    }
+    if (positionDistance <= curDistance) {
+      return null;
+    }
+    const distance = positionDistance - curDistance;
+    if (!distance) {
+      return;
+    }
+    const time = distance / speed;
+    return new Promise((resolve) => {
+      const tween = this.pathTween = new Tween3({ distance: 0 }, this.tweenUtil.group).to({ distance }, time * 1e3).onUpdate(async (v) => {
+        this.movedDistance = v.distance + curDistance;
+        this.path?.movePath(this.movedDistance / this.curFloorPathLength);
+        const pos = getPosByPathDistance(curFloorPathPoints, this.movedDistance);
+        if (pos === null) {
+          this.tweenUtil.remove(tween);
+          return;
+        }
+        this.currentPathPosition = pos;
+        const translatePos = this.translatePoints([pos])[0];
+        if (this.startPoi) {
+          this.startPoi.position.setX(translatePos[0]).setY(translatePos[1]);
+          if (!this.options.disablePathAnimation) {
+            this.bmap.context.control.setTargetByOffset(this.options.offsetY, this.startPoi.position.clone());
+          }
+        }
+        if (!this.options.disablePathAnimation) {
+          tween.pause();
+          await this.changeCameraToPathUp(500 / speed);
+          tween.resume();
+        }
+        this.emitNavigationInfo();
+      }).onComplete(() => {
+        this.tweenUtil.remove(tween);
+        resolve(true);
+      }).start();
+    });
+  }
+  // 吸附路线
+  adsorb(position) {
+    if (!this.curFloorPathPoints.length) {
+      return null;
+    }
+    let path = this.curFloorPathPoints;
+    if (this.currentPathPosition) {
+      const index = getPointEdgeIndex(this.curFloorPathPoints, this.currentPathPosition);
+      path = path.slice(index + 1);
+      path.unshift(this.currentPathPosition);
+    }
+    const { distance, closestPoint } = path.reduce((obj, cur, index, arr) => {
+      if (!arr[index + 1]) {
+        return obj;
+      }
+      const { distance: distance2, closestPoint: closestPoint2 } = distancePointToSegment(position, cur, arr[index + 1]);
+      if (distance2 < obj.distance) {
+        return { distance: distance2, closestPoint: closestPoint2 };
+      }
+      return obj;
+    }, { distance: Infinity, closestPoint: path[0] });
+    return { distance, closestPoint };
+  }
+  // 计算剩余距离
+  getRemainDistance() {
+    const curPathRemainDistance = this.curFloorPathLength - this.movedDistance;
+    const remainFloor = this.paths.slice(this.curPathIndex + 1);
+    const remainFloorDistance = remainFloor.reduce((total, item) => total + item.distance, 0);
+    return remainFloorDistance + curPathRemainDistance;
+  }
+  // 计算下一个拐弯点的方向和距离
+  getNextDirDistance() {
+    if (!this.currentPathPosition) {
+      return null;
+    }
+    const index = getPointEdgeIndex(this.curFloorPathPoints, this.currentPathPosition);
+    const p1 = this.curFloorPathPoints[index];
+    const p2 = this.curFloorPathPoints[index + 1];
+    const p3 = this.curFloorPathPoints[index + 2];
+    if (!p1 || !p2) {
+      return null;
+    }
+    const distance = getLength(this.currentPathPosition, p2);
+    if (index === 0) {
+      const l = getLength(p1, this.currentPathPosition);
+      if (l < 5) {
+        return { dir: "start" /* START */, distance };
+      }
+    }
+    if (!p3) {
+      return { dir: "end" /* END */, distance };
+    }
+    const dir = calc_direction(p1, p2, p3);
+    return { dir, distance };
+  }
+  emitNavigationInfo() {
+    const remainDistance = this.getRemainDistance();
+    const nextDirInfo = this.getNextDirDistance();
+    if (!nextDirInfo) {
+      return null;
+    }
+    let { dir, distance } = nextDirInfo;
+    if (dir === "end" /* END */ && distance > 15) {
+      dir = "front" /* FRONT */;
+    }
+    if (dir !== "start" /* START */ && distance >= this.options.directionEmitThreshold) {
+      dir = "front" /* FRONT */;
+    }
+    this.dispatchEvent({
+      type: "navigation-info",
+      dir,
+      distance: remainDistance,
+      nextDirDistance: distance
+    });
+  }
   dispose() {
+    this.tweenUtil.dispose();
     this.unRegistryEvent();
     this.path?.dispose();
     this.startPoi?.dispose();
@@ -8328,11 +8580,11 @@ var Navigation = class extends Plugin {
 };
 
 // src/plugins/mul-floors/mul-floors.ts
-import { Group as Group3 } from "three";
+import { Group as Group4 } from "three";
 var MulFloors = class extends Plugin {
   poiLayer;
   floors = [];
-  group = new Group3();
+  group = new Group4();
   constructor(bmap) {
     super(bmap);
     this.poiLayer = new PoiLayer(bmap.context);
@@ -8442,7 +8694,6 @@ var NavPath = class extends EventDispatcher10 {
           }
         });
       };
-      console.log(this.initRoadStatus);
       if (this.initRoadStatus) {
         _getPath();
       } else {
@@ -8465,6 +8716,284 @@ var NavPath = class extends EventDispatcher10 {
   }
 };
 
+// src/plugins/select/box-selection.ts
+import { Frustum as Frustum3 } from "three";
+var BoxSelection2 = class extends BaseSvg {
+  startPoint;
+  endPoint;
+  rect;
+  frustum = new Frustum3();
+  constructor(context) {
+    super(context);
+    const { config: { selectBox: { fill, stroke } } } = context;
+    this.rect = createRect(stroke, fill);
+    this.svg.appendChild(this.rect);
+    this.registryEvent();
+  }
+  setEnable(enable) {
+    super.setEnable(enable);
+    setRectPosition(this.rect, 0, 0, 0, 0);
+    if (enable) {
+      this.registryEvent();
+    } else {
+      this.startPoint = void 0;
+      this.unRegistryEvent();
+    }
+  }
+  onPointerDown = (e) => {
+    if (!this.enable) {
+      return;
+    }
+    const point3 = this.getIntersectByPointerEvent(e);
+    if (point3) {
+      this.startPoint = point3;
+    }
+    this.endPoint = void 0;
+  };
+  onPointerMove = (e) => {
+    if (!this.enable || !this.startPoint) {
+      return;
+    }
+    const point3 = this.getIntersectByPointerEvent(e);
+    if (point3) {
+      this.endPoint = point3;
+    }
+  };
+  onPointerUp = (e) => {
+    if (!this.enable) {
+      return;
+    }
+    const point3 = this.getIntersectByPointerEvent(e);
+    if (point3) {
+      this.endPoint = point3;
+    }
+    this.doSelect();
+    this.startPoint = void 0;
+  };
+  onUpdate = () => {
+    if (this.startPoint) {
+      const startPoint = this.getSvgCoordinate(this.startPoint);
+      let endPoint = { ...startPoint };
+      if (this.endPoint) {
+        endPoint = this.getSvgCoordinate(this.endPoint);
+      }
+      const leftTop = { x: Math.min(startPoint.x, endPoint.x), y: Math.min(startPoint.y, endPoint.y) };
+      const width = Math.abs(endPoint.x - startPoint.x);
+      const height = Math.abs(endPoint.y - startPoint.y);
+      setRectPosition(this.rect, leftTop.x, leftTop.y, width, height);
+    } else {
+      setRectPosition(this.rect, 0, 0, 0, 0);
+    }
+  };
+  registryEvent() {
+    this.context.container.addEventListener("pointerdown", this.onPointerDown);
+    this.context.container.addEventListener("pointermove", this.onPointerMove);
+    this.context.container.addEventListener("pointerup", this.onPointerUp);
+    this.context.addEventListener("update", this.onUpdate);
+  }
+  unRegistryEvent() {
+    this.context.container.removeEventListener("pointerdown", this.onPointerDown);
+    this.context.container.removeEventListener("pointermove", this.onPointerMove);
+    this.context.container.removeEventListener("pointerup", this.onPointerUp);
+    this.context.removeEventListener("update", this.onUpdate);
+  }
+  doSelect() {
+    if (this.startPoint && this.endPoint) {
+      const dis = this.startPoint.distanceTo(this.endPoint);
+      if (dis < 0.1) {
+        return;
+      }
+      const { context: { camera, container: { clientWidth: w, clientHeight: h } } } = this;
+      const startDevice = vector3ToDevice(this.startPoint, camera, w, h);
+      const endDevice = vector3ToDevice(this.endPoint, camera, w, h);
+      const leftTop = { x: Math.min(startDevice.x, endDevice.x), y: Math.min(startDevice.y, endDevice.y) };
+      const rightBottom = { x: Math.max(startDevice.x, endDevice.x), y: Math.max(startDevice.y, endDevice.y) };
+      const list = this.searchMapInFrustum(leftTop, rightBottom);
+      this.dispatchEvent({ type: "selected", list });
+    }
+  }
+  searchMapInFrustum(leftTop, rightBottom) {
+    const { context } = this;
+    return context.currentFloor?.graphicLayer.children.filter((item) => {
+      return item instanceof Graphic && this.searchChildInFrustum(item, leftTop, rightBottom);
+    }) || [];
+  }
+  searchChildInFrustum(object, leftTop, rightBottom) {
+    const { context: { camera, container: { clientWidth: w, clientHeight: h } } } = this;
+    if (!object) return false;
+    if (!object.mesh) {
+      const position = object.getPosition();
+      if (position) {
+        const position2d = vector3ToDevice(position, camera, w, h);
+        return isContain(position2d, leftTop, rightBottom);
+      }
+      return false;
+    }
+    if (!object.mesh.geometry.boundingBox) {
+      object.mesh.geometry.computeBoundingBox();
+    }
+    const box = object.mesh.geometry.boundingBox;
+    if (!box) {
+      return false;
+    }
+    const { min, max } = box;
+    const minDevice = vector3ToDevice(min, camera, w, h);
+    const maxDevice = vector3ToDevice(max, camera, w, h);
+    if (!isContain(minDevice, leftTop, rightBottom)) {
+      return false;
+    }
+    if (!isContain(maxDevice, leftTop, rightBottom)) {
+      return false;
+    }
+    return true;
+  }
+  dispose() {
+    this.unRegistryEvent();
+  }
+};
+
+// src/plugins/select/select.ts
+var bmapSelectDefaultOptions = {
+  boxSelection: false,
+  elements: ["graphic", "poi"]
+};
+var BMapSelect = class extends Plugin {
+  options;
+  _list = /* @__PURE__ */ new Set();
+  _poiList = /* @__PURE__ */ new Set();
+  boxSelection;
+  prevPanStatus;
+  prevRotateStatus;
+  downPoint = null;
+  isMultipleSelect = false;
+  constructor(bmap, options = {}) {
+    super(bmap);
+    this.options = { ...bmapSelectDefaultOptions, ...options };
+    this.boxSelection = new BoxSelection2(this.bmap.context);
+    this.boxSelection.setEnable(false);
+    this.registryEvent();
+  }
+  get list() {
+    return this._list;
+  }
+  enableBoxSelection() {
+    if (this.isMultipleSelect || !this.options.boxSelection) {
+      return;
+    }
+    this.isMultipleSelect = true;
+    this.boxSelection.setEnable(true);
+    this.prevPanStatus = this.bmap.context.control.enablePan;
+    this.prevRotateStatus = this.bmap.context.control.enableRotate;
+    this.bmap.context.control.enablePan = false;
+    this.bmap.context.control.enableRotate = false;
+  }
+  disableBoxSelection() {
+    if (this.isMultipleSelect) {
+      this.isMultipleSelect = false;
+      this.boxSelection.setEnable(false);
+      this.bmap.context.control.enablePan = !!this.prevPanStatus;
+      this.bmap.context.control.enableRotate = !!this.prevRotateStatus;
+    }
+  }
+  onPointerDown = (e) => {
+    this.downPoint = { x: e.offsetX, y: e.offsetY };
+  };
+  onPointerUp = (e) => {
+    if (!this.downPoint) {
+      return;
+    }
+    const { offsetX, offsetY } = e;
+    const { x, y } = this.downPoint;
+    if (Math.sqrt((x - offsetX) ** 2 + (y - offsetY) ** 2) > 3) {
+      return;
+    }
+    const set2 = /* @__PURE__ */ new Set();
+    const selectGraphics = [];
+    const selectPois = [];
+    if (this.options.elements.includes("graphic")) {
+      const { graphics } = this.bmap.context.getGraphicsByDeviceXy(offsetX, offsetY);
+      graphics.map((item) => set2.add(item.options.id));
+      selectGraphics.push(...graphics);
+    }
+    if (this.options.elements.includes("poi")) {
+      const pois = this.bmap.context.getPoisByDeviceXy(offsetX, offsetY);
+      selectPois.push(...pois);
+      pois.forEach((item) => {
+        if (!set2.has(item.options.id)) {
+          const graphic = this.bmap.context.currentFloor?.graphicLayer.graphicMap.get(item.options.id) || null;
+          if (graphic) {
+            set2.add(item.options.id);
+            selectGraphics.push(graphic);
+          }
+        }
+      });
+    }
+    if (!this.options.boxSelection || !(isMac ? e.metaKey : e.ctrlKey)) {
+      this._list.clear();
+      this._poiList.clear();
+    }
+    selectGraphics.forEach((item) => this._list.add(item));
+    selectPois.forEach((item) => this._poiList.add(item));
+    this.selectEnd();
+    this.downPoint = null;
+  };
+  onPointerOut = (e) => {
+    this.disableBoxSelection();
+  };
+  onKeyDown = (e) => {
+    if (isControl(e.key)) {
+      this.enableBoxSelection();
+    }
+  };
+  onKeyUp = (e) => {
+    if (isControl(e.key)) {
+      this.disableBoxSelection();
+    }
+  };
+  onBoxSelected = ({ list }) => {
+    this._list.clear();
+    list.forEach((item) => {
+      this._list.add(item);
+    });
+    this.selectEnd();
+  };
+  selectEnd() {
+    this.dispatchEvent({
+      type: "select",
+      graphics: [...this._list],
+      pois: [...this._poiList],
+      isMultipleSelect: this.isMultipleSelect
+    });
+  }
+  registryEvent() {
+    this.bmap.context.container.addEventListener("pointerdown", this.onPointerDown);
+    this.bmap.context.container.addEventListener("pointerup", this.onPointerUp);
+    this.bmap.context.container.addEventListener("pointerout", this.onPointerOut);
+    this.bmap.context.container.addEventListener("pointercancel", this.onPointerOut);
+    window.addEventListener("keydown", this.onKeyDown);
+    window.addEventListener("keyup", this.onKeyUp);
+    this.boxSelection.addEventListener("selected", this.onBoxSelected);
+  }
+  unRegistryEvent() {
+    this.bmap.context.container.removeEventListener("pointerdown", this.onPointerDown);
+    this.bmap.context.container.removeEventListener("pointerup", this.onPointerUp);
+    this.bmap.context.container.removeEventListener("pointerout", this.onPointerOut);
+    this.bmap.context.container.removeEventListener("pointercancel", this.onPointerOut);
+    window.removeEventListener("keydown", this.onKeyDown);
+    window.removeEventListener("keyup", this.onKeyUp);
+    this.boxSelection.removeEventListener("selected", this.onBoxSelected);
+  }
+  clear() {
+    this._list.clear();
+  }
+  remove(graphic) {
+    this._list.delete(graphic);
+  }
+  dispose() {
+    this.unRegistryEvent();
+  }
+};
+
 // src/loader/CrLoader/api/floor.ts
 async function loadBuildingGround({ brand, project }, config) {
   const {
@@ -9121,6 +9650,7 @@ var CrLoader = class {
 export {
   AibeeLoader,
   BMap,
+  BMapSelect,
   BaseSvg,
   Context,
   CrLoader,
@@ -9157,6 +9687,8 @@ export {
   SvgPolygon,
   TextTexture,
   Timer,
+  TweenUtil,
+  UA,
   Wall,
   addAlphaToHexColor,
   calc_angle,
@@ -9167,6 +9699,7 @@ export {
   createRect,
   createSvg,
   createSvgElement,
+  createThreeBox,
   createThreeLine,
   darkenColor,
   defaultAibeeLoaderOption,
@@ -9181,18 +9714,22 @@ export {
   getCenter,
   getConfig,
   getDirectPath,
+  getDistanceByPathPos,
   getLength,
   getLongestSideDir,
   getMinEdgeSquare,
   getPathLength,
   getPointEdgeIndex,
+  getPosByPathDistance,
   hasChinese,
   hexToRgb,
   initDirectionalLight,
   initLight,
   initShape,
+  isAndroid,
   isContain,
   isControl,
+  isIphone,
   isMac,
   isPointInPolygon,
   loadBuildingGround,