@aibee/crc-bmap 0.8.45 → 0.8.46

package/lib/src/plugins/navigation/navigation.js

@@ -1,5 +1,8 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _extends } from "@swc/helpers/_/_extends";
+import "core-js/modules/es.string.replace.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.promise.finally.js";
 import { Plugin } from "../base";
 import { Path } from "./path";
 import { HooksName, vector3ToDevice, TweenUtil, getPointEdgeIndex, timeoutPromise } from "../../utils";
@@ -154,7 +157,8 @@ export class Navigation extends Plugin {
             this.clearPath();
         }
     }
-    addPath(paths, routeIndex = 0) {
+    addPath(paths, routeIndex) {
+        if (routeIndex === void 0) routeIndex = 0;
         var _this_bmap_context_currentFloor;
         this.paths = paths;
         this.curPathIndex = routeIndex;
@@ -288,145 +292,137 @@ export class Navigation extends Plugin {
         return (angle - 90 + 360) % 360;
     }
     // 把相机旋转到路线的上方向
-    changeCameraToPathUp(duration = 100) {
-        var _this = this;
-        return _async_to_generator(function*() {
-            let angle = _this.getPathDirection();
-            if (angle === null) {
-                return;
-            }
-            const currentAngle = _this.bmap.context.control.getAzimuthalAngle();
-            if (Math.abs(currentAngle - angle) > Math.PI) {
-                if (currentAngle > 0) {
-                    angle = Math.PI * 2 + angle;
-                } else {
-                    angle = angle - Math.PI * 2;
-                }
-            }
-            const diffAngle = Math.abs(angle - _this.bmap.context.control.getAzimuthalAngle());
-            if (diffAngle < 0.01) {
-                return;
-            }
-            const { control } = _this.bmap.context;
-            const time = duration / Math.PI * 6 * diffAngle;
-            return timeoutPromise(new Promise((resolve)=>{
-                const start = {
-                    azimuthal: control.getAzimuthalAngle()
-                };
-                const end = {
-                    azimuthal: angle
-                };
-                const polar = control.getPolarAngle();
-                const { maxPolarAngle, minPolarAngle } = control;
-                control.maxPolarAngle = polar;
-                control.minPolarAngle = polar;
-                const tween = new Tween(start, _this.tweenUtil.group).to(end, time).easing(Easing.Quadratic.InOut).onUpdate(/*#__PURE__*/ _async_to_generator(function*() {
-                    if (_this.startPoi) {
-                        control.target.copy(_this.startPoi.position);
-                    }
-                    control.setAzimuthalAngle(start.azimuthal, true);
-                    control.setTargetByOffset(_this.options.offsetY);
-                })).onComplete(()=>{
-                    control.enabled = true;
-                    _this.tweenUtil.remove(tween);
-                    control.maxPolarAngle = maxPolarAngle;
-                    control.minPolarAngle = minPolarAngle;
-                    resolve(true);
-                }).onStart(()=>{
-                    control.enabled = false;
-                }).start();
-            }), time + 500).finally(()=>{
-                _this.bmap.context.control.enabled = true;
-            });
-        })();
-    }
-    initNavigationCamera(duration = 1000) {
-        var _this = this;
-        return _async_to_generator(function*() {
-            var _tasks_find;
-            const tasks = _this.taskQueue.getTasks();
-            const tid = (_tasks_find = tasks.find((item)=>item.meta.type === "initNavigationCamera")) == null ? void 0 : _tasks_find.tid;
-            const newTask = {
-                run: ()=>timeoutPromise(_async_to_generator(function*() {
-                        yield _this.initCameraZoom(duration / 2);
-                        yield _this.changeCameraToPathUp(duration / 4);
-                        yield _this.translateCameraToStartPoi(duration / 4);
-                    })(), duration + 500).finally(()=>{
-                        _this.bmap.context.control.enabled = true;
-                    }),
-                meta: {
-                    type: "initNavigationCamera"
-                }
-            };
-            if (tid) {
-                _this.taskQueue.replace(tid, newTask);
+    async changeCameraToPathUp(duration) {
+        if (duration === void 0) duration = 100;
+        let angle = this.getPathDirection();
+        if (angle === null) {
+            return;
+        }
+        const currentAngle = this.bmap.context.control.getAzimuthalAngle();
+        if (Math.abs(currentAngle - angle) > Math.PI) {
+            if (currentAngle > 0) {
+                angle = Math.PI * 2 + angle;
             } else {
-                _this.taskQueue.add(newTask);
+                angle = angle - Math.PI * 2;
             }
-        })();
+        }
+        const diffAngle = Math.abs(angle - this.bmap.context.control.getAzimuthalAngle());
+        if (diffAngle < 0.01) {
+            return;
+        }
+        const { control } = this.bmap.context;
+        const time = duration / Math.PI * 6 * diffAngle;
+        return timeoutPromise(new Promise((resolve)=>{
+            const start = {
+                azimuthal: control.getAzimuthalAngle()
+            };
+            const end = {
+                azimuthal: angle
+            };
+            const polar = control.getPolarAngle();
+            const { maxPolarAngle, minPolarAngle } = control;
+            control.maxPolarAngle = polar;
+            control.minPolarAngle = polar;
+            const tween = new Tween(start, this.tweenUtil.group).to(end, time).easing(Easing.Quadratic.InOut).onUpdate(async ()=>{
+                if (this.startPoi) {
+                    control.target.copy(this.startPoi.position);
+                }
+                control.setAzimuthalAngle(start.azimuthal, true);
+                control.setTargetByOffset(this.options.offsetY);
+            }).onComplete(()=>{
+                control.enabled = true;
+                this.tweenUtil.remove(tween);
+                control.maxPolarAngle = maxPolarAngle;
+                control.minPolarAngle = minPolarAngle;
+                resolve(true);
+            }).onStart(()=>{
+                control.enabled = false;
+            }).start();
+        }), time + 500).finally(()=>{
+            this.bmap.context.control.enabled = true;
+        });
     }
-    translateCameraToStartPoi(duration = 100) {
-        var _this = this;
-        return _async_to_generator(function*() {
-            if (!_this.startPoi) {
-                return;
-            }
-            const { clientSize: { width, height }, camera, control } = _this.bmap.context;
-            const halfWidth = Math.round(width / 2);
-            const halfHeight = Math.round(height / 2);
-            const target = control.target.clone();
-            const device = vector3ToDevice(_this.startPoi.position, camera, width, height);
-            const offsetX = device.x - halfWidth;
-            const offsetY = halfHeight - device.y + _this.options.offsetY;
-            if (Math.abs(offsetX) <= 1 && Math.abs(offsetY) <= 1) {
-                return;
-            }
-            if (Math.abs(offsetX) >= 1) {
-                const xv3 = new Vector3();
-                xv3.setFromMatrixColumn(camera.matrix, 0);
-                xv3.normalize();
-                xv3.multiplyScalar(offsetX / camera.zoom);
-                target.add(new Vector3(xv3.x, xv3.y, 0));
-            }
-            if (Math.abs(offsetY) >= 1) {
-                const v3 = new Vector3();
-                v3.setFromMatrixColumn(camera.matrix, 1);
-                v3.normalize();
-                v3.multiplyScalar(offsetY / camera.zoom);
-                target.add(new Vector3(v3.x, v3.y, 0));
+    async initNavigationCamera(duration) {
+        if (duration === void 0) duration = 1000;
+        var _tasks_find;
+        const tasks = this.taskQueue.getTasks();
+        const tid = (_tasks_find = tasks.find((item)=>item.meta.type === "initNavigationCamera")) == null ? void 0 : _tasks_find.tid;
+        const newTask = {
+            run: ()=>timeoutPromise((async ()=>{
+                    await this.initCameraZoom(duration / 2);
+                    await this.changeCameraToPathUp(duration / 4);
+                    await this.translateCameraToStartPoi(duration / 4);
+                })(), duration + 500).finally(()=>{
+                    this.bmap.context.control.enabled = true;
+                }),
+            meta: {
+                type: "initNavigationCamera"
             }
-            return timeoutPromise(new Promise((resolve)=>{
-                const start = control.target.clone();
-                console.log(start, target, duration);
-                const tween = new Tween(start, _this.tweenUtil.group).to(target, duration).onUpdate(()=>{
-                    _this.bmap.context.control.setCameraPositionByTarget(start, 0);
-                }).onComplete(()=>{
-                    _this.bmap.context.control.setCameraPositionByTarget(target, 0);
-                    _this.tweenUtil.remove(tween);
-                    _this.bmap.context.control.enabled = true;
-                    resolve(true);
-                }).onStart(()=>{
-                    _this.bmap.context.control.enabled = false;
-                }).start();
-            }), duration + 500).then(()=>{
-                _this.bmap.context.control.enabled = true;
-            });
-        })();
+        };
+        if (tid) {
+            this.taskQueue.replace(tid, newTask);
+        } else {
+            this.taskQueue.add(newTask);
+        }
     }
-    initCameraZoom(duration = 100) {
-        var _this = this;
-        return _async_to_generator(function*() {
-            if (!_this.startPoi) {
-                return;
-            }
-            const { clientSize: { width, height }, currentFloor } = _this.bmap.context;
-            const { max, min } = currentFloor.box;
-            const baseScale = Math.min(width / (max.x - min.x), height / (max.y - min.y));
-            const zoom = baseScale * (max.x - min.x) / 45;
-            return _this.bmap.context.setZoom(zoom, _this.startPoi.position, duration).finally(()=>{
-                _this.bmap.context.control.enabled = true;
-            });
-        })();
+    async translateCameraToStartPoi(duration) {
+        if (duration === void 0) duration = 100;
+        if (!this.startPoi) {
+            return;
+        }
+        const { clientSize: { width, height }, camera, control } = this.bmap.context;
+        const halfWidth = Math.round(width / 2);
+        const halfHeight = Math.round(height / 2);
+        const target = control.target.clone();
+        const device = vector3ToDevice(this.startPoi.position, camera, width, height);
+        const offsetX = device.x - halfWidth;
+        const offsetY = halfHeight - device.y + this.options.offsetY;
+        if (Math.abs(offsetX) <= 1 && Math.abs(offsetY) <= 1) {
+            return;
+        }
+        if (Math.abs(offsetX) >= 1) {
+            const xv3 = new Vector3();
+            xv3.setFromMatrixColumn(camera.matrix, 0);
+            xv3.normalize();
+            xv3.multiplyScalar(offsetX / camera.zoom);
+            target.add(new Vector3(xv3.x, xv3.y, 0));
+        }
+        if (Math.abs(offsetY) >= 1) {
+            const v3 = new Vector3();
+            v3.setFromMatrixColumn(camera.matrix, 1);
+            v3.normalize();
+            v3.multiplyScalar(offsetY / camera.zoom);
+            target.add(new Vector3(v3.x, v3.y, 0));
+        }
+        return timeoutPromise(new Promise((resolve)=>{
+            const start = control.target.clone();
+            console.log(start, target, duration);
+            const tween = new Tween(start, this.tweenUtil.group).to(target, duration).onUpdate(()=>{
+                this.bmap.context.control.setCameraPositionByTarget(start, 0);
+            }).onComplete(()=>{
+                this.bmap.context.control.setCameraPositionByTarget(target, 0);
+                this.tweenUtil.remove(tween);
+                this.bmap.context.control.enabled = true;
+                resolve(true);
+            }).onStart(()=>{
+                this.bmap.context.control.enabled = false;
+            }).start();
+        }), duration + 500).then(()=>{
+            this.bmap.context.control.enabled = true;
+        });
+    }
+    async initCameraZoom(duration) {
+        if (duration === void 0) duration = 100;
+        if (!this.startPoi) {
+            return;
+        }
+        const { clientSize: { width, height }, currentFloor } = this.bmap.context;
+        const { max, min } = currentFloor.box;
+        const baseScale = Math.min(width / (max.x - min.x), height / (max.y - min.y));
+        const zoom = baseScale * (max.x - min.x) / 45;
+        return this.bmap.context.setZoom(zoom, this.startPoi.position, duration).finally(()=>{
+            this.bmap.context.control.enabled = true;
+        });
     }
     // 根据定位 实时导航
     toPosition(floor, pos) {
@@ -440,83 +436,77 @@ export class Navigation extends Plugin {
     setSimulationSpeed(speed) {
         this.positionNavigation.changeSimulationSpeed(speed);
     }
-    toPositionBySpeed(position, speed) {
-        var _this = this;
-        return _async_to_generator(function*() {
-            const { currentPathPosition, curFloorPath, curFloorPathPoints } = _this;
-            if (!curFloorPath || !currentPathPosition) {
-                return null;
-            }
-            // 计算当前点在路线上的移动距离
-            const curDistance = _this.movedDistance;
-            // 计算传入点在路线上的移动距离
-            const positionDistance = getDistanceByPathPos(curFloorPathPoints, position);
-            if (curDistance === -1 || positionDistance === -1) {
-                return null;
-            }
-            // 传入点距离如果距离小于当前点距离就返回
-            if (positionDistance <= curDistance) {
-                return null;
-            }
-            // 根据拐弯点切割路线
-            const distance = positionDistance - curDistance;
-            if (!distance) {
-                return;
-            }
-            const time = Math.min(distance / speed, _this.options.runAnimationMaxTime);
-            if (_this.pathTween) {
-                _this.clearTween();
-            }
-            // this.pathMoving = true;
-            // 根据移动的距离开始动画
-            return timeoutPromise(new Promise((resolve)=>{
-                const tween = _this.pathTween = new Tween({
-                    distance: 0
-                }, _this.tweenUtil.group).to({
-                    distance: distance
-                }, time * 1000).onUpdate(/*#__PURE__*/ _async_to_generator(function*(v) {
-                    _this.moveDistance(v.distance + curDistance, tween);
-                })).onComplete(()=>{
-                    _this.tweenUtil.remove(tween);
-                    resolve(true);
-                }).start();
-            }), time * 1000 + 500).finally(()=>{
-                _this.bmap.context.control.enabled = true;
-            });
-        })();
-    }
-    moveDistance(distance, tween) {
-        var _this = this;
-        return _async_to_generator(function*() {
-            var _this_path;
-            _this.movedDistance = distance;
-            (_this_path = _this.path) == null ? void 0 : _this_path.movePath(_this.movedDistance / _this.curFloorPathLength);
-            // 获取移动后的位置
-            const pos = getPosByPathDistance(_this.curFloorPathPoints, _this.movedDistance);
-            if (pos === null) {
-                return;
-            }
-            _this.currentPathPosition = pos;
-            const translatePos = _this.translatePoints([
-                pos
-            ])[0];
-            // 平移相机
-            if (_this.startPoi) {
-                _this.setStartPoiPosition(translatePos[0], translatePos[1]);
-                // 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 == null ? void 0 : tween.pause();
-                // this.positionNavigation.tweenUtil.pause()
-                yield _this.changeCameraToPathUp(500 / _this.options.speed);
-                // this.positionNavigation.tweenUtil.continue()
-                tween == null ? void 0 : tween.resume();
+    async toPositionBySpeed(position, speed) {
+        const { currentPathPosition, curFloorPath, curFloorPathPoints } = this;
+        if (!curFloorPath || !currentPathPosition) {
+            return null;
+        }
+        // 计算当前点在路线上的移动距离
+        const curDistance = this.movedDistance;
+        // 计算传入点在路线上的移动距离
+        const positionDistance = getDistanceByPathPos(curFloorPathPoints, position);
+        if (curDistance === -1 || positionDistance === -1) {
+            return null;
+        }
+        // 传入点距离如果距离小于当前点距离就返回
+        if (positionDistance <= curDistance) {
+            return null;
+        }
+        // 根据拐弯点切割路线
+        const distance = positionDistance - curDistance;
+        if (!distance) {
+            return;
+        }
+        const time = Math.min(distance / speed, this.options.runAnimationMaxTime);
+        if (this.pathTween) {
+            this.clearTween();
+        }
+        // this.pathMoving = true;
+        // 根据移动的距离开始动画
+        return timeoutPromise(new Promise((resolve)=>{
+            const tween = this.pathTween = new Tween({
+                distance: 0
+            }, this.tweenUtil.group).to({
+                distance: distance
+            }, time * 1000).onUpdate(async (v)=>{
+                this.moveDistance(v.distance + curDistance, tween);
+            }).onComplete(()=>{
+                this.tweenUtil.remove(tween);
+                resolve(true);
+            }).start();
+        }), time * 1000 + 500).finally(()=>{
+            this.bmap.context.control.enabled = true;
+        });
+    }
+    async moveDistance(distance, tween) {
+        var _this_path;
+        this.movedDistance = distance;
+        (_this_path = this.path) == null ? void 0 : _this_path.movePath(this.movedDistance / this.curFloorPathLength);
+        // 获取移动后的位置
+        const pos = getPosByPathDistance(this.curFloorPathPoints, this.movedDistance);
+        if (pos === null) {
+            return;
+        }
+        this.currentPathPosition = pos;
+        const translatePos = this.translatePoints([
+            pos
+        ])[0];
+        // 平移相机
+        if (this.startPoi) {
+            this.setStartPoiPosition(translatePos[0], translatePos[1]);
+            // 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 == null ? void 0 : tween.pause();
+            // this.positionNavigation.tweenUtil.pause()
+            await this.changeCameraToPathUp(500 / this.options.speed);
+            // this.positionNavigation.tweenUtil.continue()
+            tween == null ? void 0 : tween.resume();
+        }
     }
     setStartPoiRotate(rotate) {
         this.startPoiRotate = rotate;
@@ -556,7 +546,8 @@ export class Navigation extends Plugin {
         this.animationPathOptions = {
             cPathIndex: 0
         }, this.cPath = [] // 当前楼层的平滑后的路线
-        , this.onNavigationInfo = ({ info })=>{
+        , this.onNavigationInfo = (param)=>{
+            let { info } = param;
             this.dispatchEvent({
                 type: "navigation-info",
                 info
@@ -571,7 +562,8 @@ export class Navigation extends Plugin {
             }
         }, this.onUpdate = ()=>{
             this.tweenUtil.update();
-        }, this.onSwitchFloor = ({ data: { curFloor } })=>{
+        }, this.onSwitchFloor = (param)=>{
+            let { data: { curFloor } } = param;
             this.clearTween();
             if (this.paths[this.curPathIndex]) {
                 const curFloorPathData = this.paths[this.curPathIndex];

package/lib/src/plugins/navigation/path.js

@@ -1,4 +1,5 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.array.push.js";
 import { Mesh, Object3D, TextureLoader, Color, Vector2, Vector3, NormalBlending, RepeatWrapping } from "three";
 // @ts-ignore
 import { MeshLine, MeshLineMaterial } from "../../external/meshLine";
@@ -36,10 +37,16 @@ export class Path extends Object3D {
     }
     getRepeat() {
         const { points, navigation: { bmap: { context: { camera, clientSize: { width, height } } } } } = this;
-        const screenPoints = points.map(([x, y])=>vector3ToDevice(new Vector3(x, y, 0), camera, width, height)).map(({ x, y })=>[
+        const screenPoints = points.map((param)=>{
+            let [x, y] = param;
+            return vector3ToDevice(new Vector3(x, y, 0), camera, width, height);
+        }).map((param)=>{
+            let { x, y } = param;
+            return [
                 x,
                 y
-            ]);
+            ];
+        });
         const pointLength = getPathLength(screenPoints);
         return pointLength / 32;
     }
@@ -77,33 +84,30 @@ export class Path extends Object3D {
         }
         this.material.thresholdRatio = ratio;
     }
-    create(points) {
-        var _this = this;
-        return _async_to_generator(function*() {
-            const lineGeometry = _this.geometry = new MeshLine();
-            _this.updatePoints(points);
-            if (!_this.texture) {
-                const texture = _this.texture = yield _this.loadTexture(_this.config.texture_url);
-                texture.wrapS = texture.wrapT = RepeatWrapping;
-            }
-            const material = _this.material = new MeshLineMaterial({
-                useMap: true,
-                color: new Color(_this.config.color),
-                transparent: true,
-                resolution: new Vector2(_this.navigation.bmap.context.clientSize.width, _this.navigation.bmap.context.clientSize.height),
-                depthTest: _this.depthTest,
-                sizeAttenuation: false,
-                lineWidth: _this.config.lineWidth * 2,
-                map: _this.texture,
-                blending: NormalBlending,
-                repeat: new Vector2(_this.getRepeat(), 1)
-            });
-            // 生成模型
-            const mesh = _this.mesh = new Mesh(lineGeometry, material);
-            mesh.renderOrder = 9;
-            _this.add(mesh);
-            return mesh;
-        })();
+    async create(points) {
+        const lineGeometry = this.geometry = new MeshLine();
+        this.updatePoints(points);
+        if (!this.texture) {
+            const texture = this.texture = await this.loadTexture(this.config.texture_url);
+            texture.wrapS = texture.wrapT = RepeatWrapping;
+        }
+        const material = this.material = new MeshLineMaterial({
+            useMap: true,
+            color: new Color(this.config.color),
+            transparent: true,
+            resolution: new Vector2(this.navigation.bmap.context.clientSize.width, this.navigation.bmap.context.clientSize.height),
+            depthTest: this.depthTest,
+            sizeAttenuation: false,
+            lineWidth: this.config.lineWidth * 2,
+            map: this.texture,
+            blending: NormalBlending,
+            repeat: new Vector2(this.getRepeat(), 1)
+        });
+        // 生成模型
+        const mesh = this.mesh = new Mesh(lineGeometry, material);
+        mesh.renderOrder = 9;
+        this.add(mesh);
+        return mesh;
     }
     dispose() {
         var _this_geometry, _this_material, _this_texture;