@aibee/crc-bmap 0.0.115 → 0.0.117

package/lib/bmap.esm.js

@@ -454,7 +454,7 @@ var require_Graph = __commonJS({
 });
 
 // src/bmap.ts
-import { EventDispatcher as EventDispatcher7, Vector3 as Vector315 } from "three";
+import { EventDispatcher as EventDispatcher7, Vector3 as Vector318 } from "three";
 
 // src/utils/timer.ts
 var Timer = class {
@@ -1619,10 +1619,10 @@ function toWebWorker(obj) {
 import {
   EventDispatcher as EventDispatcher6,
   Box2,
-  Vector3 as Vector314,
-  Vector2 as Vector25,
+  Vector3 as Vector317,
+  Vector2 as Vector26,
   Raycaster as Raycaster3,
-  Box3 as Box38,
+  Box3 as Box39,
   Color as Color5,
   AmbientLight as AmbientLight2
 } from "three";
@@ -2953,10 +2953,14 @@ var Floor = class extends Object3D8 {
     this.poiLayer = new PoiLayer(this.context);
     this.wallLayer = new Layer(this.context);
     this.textureLayer = new Layer(this.context);
+    this.glbModelLayer = new Layer(this.context);
+    this.laneLayer = new Layer(this.context);
     this.groundUpper.add(this.graphicLayer);
     this.groundUpper.add(this.poiLayer);
     this.groundUpper.add(this.wallLayer);
     this.groundUpper.add(this.textureLayer);
+    this.groundUpper.add(this.glbModelLayer);
+    this.groundUpper.add(this.laneLayer);
     this.add(this.groundUpper);
     this.add(this.models);
   }
@@ -2964,6 +2968,8 @@ var Floor = class extends Object3D8 {
   poiLayer;
   wallLayer;
   textureLayer;
+  glbModelLayer;
+  laneLayer;
   grounds = /* @__PURE__ */ new Set();
   shadow = new Shadow();
   heatmap;
@@ -3051,6 +3057,8 @@ var Floor = class extends Object3D8 {
     this.poiLayer.dispose();
     this.wallLayer.dispose();
     this.textureLayer.dispose();
+    this.glbModelLayer.dispose();
+    this.laneLayer.dispose();
     this.grounds.forEach((ground) => ground.dispose());
     this.heatmap?.dispose();
     this.groundUpper.clear();
@@ -3553,17 +3561,16 @@ var Wall = class extends Object3D9 {
 };
 
 // src/elements/ground-texture.ts
-import { Euler, Mesh as Mesh5, Object3D as Object3D10, PlaneGeometry as PlaneGeometry3 } from "three";
+import { ExtrudeGeometry as ExtrudeGeometry3, Mesh as Mesh5, Object3D as Object3D10 } from "three";
 var defaultOptions4 = {
   uuid: "",
-  url: "",
+  iconUrl: "",
   name: "",
-  angleX: 0,
-  angleY: 0,
-  angleZ: 0,
-  width: 0,
+  secondRotate: 0,
+  airHeight: 0,
+  deltaHeight: 0,
   height: 0,
-  center: [0, 0],
+  geometry: { cds: [], type: "polygon", coords: [], curveCpt: [], curveIndex: [] },
   opacity: 1,
   visible: true
 };
@@ -3580,16 +3587,24 @@ var GroundTexture = class extends Object3D10 {
   options;
   mesh;
   async init() {
-    const { width, height, center: center2, url, opacity, angleX, angleY, angleZ } = this.options;
-    const planeGeometry = new PlaneGeometry3(width, height);
+    const { deltaHeight, airHeight, geometry, iconUrl, opacity } = this.options;
+    const shape = initShape(
+      geometry.coords[0],
+      geometry.coords.slice(1)
+    );
+    const extrudeGeometry = new ExtrudeGeometry3(shape, {
+      steps: 1,
+      bevelEnabled: false,
+      depth: 0,
+      curveSegments: 4
+    });
     const planeMaterial = await this.context.materialFactory.createGroundTextureMaterial({
-      url,
+      url: iconUrl,
       opacity
     });
-    const mesh = new Mesh5(planeGeometry, planeMaterial);
+    const mesh = new Mesh5(extrudeGeometry, planeMaterial);
     this.mesh = mesh;
-    this.mesh.position.set(center2[0], center2[1], 0);
-    mesh.setRotationFromEuler(new Euler(angleX, angleY, angleZ));
+    this.mesh.position.z = airHeight + deltaHeight;
     this.add(mesh);
   }
   dispose() {
@@ -3598,6 +3613,178 @@ var GroundTexture = class extends Object3D10 {
   }
 };
 
+// src/elements/glb-model.ts
+import { Box3 as Box37, Object3D as Object3D11, Vector3 as Vector312 } from "three";
+var defaultGlbOptions = {
+  url: "",
+  geometry: { type: "polygon", cds: [], coords: [], curveCpt: [], curveIndex: [] },
+  id: "",
+  width: 0,
+  rotate: 1,
+  airHeight: 1,
+  deltaHeight: 0
+};
+var GlbModel = class extends Object3D11 {
+  constructor(context, options) {
+    super();
+    this.context = context;
+    this.options = Object.assign({}, defaultGlbOptions, options);
+    this.loadModel();
+  }
+  model = null;
+  options;
+  async loadModel() {
+    const object = await loadModel(this.options.url);
+    object.scene.rotation.set(Math.PI / 2, Math.PI / 2, 0);
+    const box = new Box37().setFromObject(object.scene);
+    const size = box.getSize(new Vector312());
+    const max = Math.max(size.x, size.y);
+    const scale = this.options.width / max;
+    this.scale.set(scale, scale, scale);
+    this.add(object.scene);
+    this.position.copy(box.getCenter(new Vector312()));
+    this.position.z += this.options.airHeight + this.options.deltaHeight;
+    this.model = object;
+  }
+  dispose() {
+    dispose(this);
+    this.model = null;
+  }
+};
+
+// src/elements/lane.ts
+import { BufferGeometry as BufferGeometry3, ExtrudeGeometry as ExtrudeGeometry4, LineSegments as LineSegments3, Mesh as Mesh6, Object3D as Object3D12, Vector3 as Vector313 } from "three";
+import { mergeGeometries as mergeGeometries2 } from "three/examples/jsm/utils/BufferGeometryUtils";
+import { Line2 } from "three/examples/jsm/lines/line2";
+import { LineGeometry } from "three/examples/jsm/lines/lineGeometry";
+var Lane = class extends Object3D12 {
+  constructor(context, options) {
+    super();
+    this.context = context;
+    this.options = options;
+    if (!options.length) {
+      return;
+    }
+    this.init();
+  }
+  geometry;
+  material;
+  lineMaterial;
+  lineGeometry;
+  Mesh;
+  LineMesh;
+  initGeometry() {
+    const geometries = this.options.map((option) => {
+      const shape = initShape(
+        option.geometry.coords[0],
+        option.geometry.coords.slice(1)
+      );
+      const geometry = new ExtrudeGeometry4(shape, {
+        steps: 1,
+        bevelEnabled: false,
+        depth: 0,
+        curveSegments: 4
+      });
+      return geometry;
+    });
+    this.geometry = mergeGeometries2(geometries);
+  }
+  initMaterial() {
+    const { fillColor, fillOpacity } = this.options[0];
+    const material = this.context.materialFactory.createMeshBasicMaterial({
+      color: fillColor,
+      opacity: fillOpacity
+    });
+    this.material = material;
+    return material;
+  }
+  initLineMaterial() {
+    const { strokeColor, strokeOpacity } = this.options[0];
+    const lineMaterial = this.context.materialFactory.createLineMaterial({
+      color: strokeColor,
+      opacity: strokeOpacity
+    });
+    this.lineMaterial = lineMaterial;
+    return lineMaterial;
+  }
+  getBorderPoints(option) {
+    const { deltaHeight, geometry } = option;
+    const points = [];
+    const _height = deltaHeight || 0;
+    const { coords } = geometry;
+    for (let j = 0; j < coords.length; j++) {
+      const curCds = coords[j];
+      for (let i = 0; i < curCds.length; i++) {
+        const cur = curCds[i];
+        const next = i + 1 === curCds.length ? curCds[0] : curCds[i + 1];
+        points.push(new Vector313(cur[0], cur[1], _height));
+        points.push(new Vector313(next[0], next[1], _height));
+      }
+    }
+    return points;
+  }
+  initDoubleLine() {
+    const options = this.options.filter((option) => option.double && option.geometry.otherCoords?.[1]?.length);
+    if (!options.length) {
+      return;
+    }
+    const group = options.reduce((obj, cur) => {
+      const key = `${cur.secondColor}-${cur.dashed}`;
+      if (obj[key]) {
+        obj[key].push(cur);
+      }
+      if (!obj[key]) {
+        obj[key] = [cur];
+      }
+      return obj;
+    }, {});
+    Object.values(group).map((options2) => {
+      const material = this.context.materialFactory.createLine2MaterialMap({
+        color: options2[0].secondColor,
+        width: 0.2,
+        dashed: options2[0].dashed
+      });
+      options2.map((option) => {
+        const geometry = new LineGeometry();
+        const vec = option.geometry.otherCoords[1].map((item) => [...item, 0]).flat(2);
+        geometry.setPositions(vec);
+        const line = new Line2(geometry, material);
+        line.computeLineDistances();
+        line.position.z += 1e-4;
+        this.add(line);
+      });
+    });
+  }
+  initLineGeometry() {
+    const geometries = this.options.map((option) => {
+      const points = this.getBorderPoints(option);
+      return new BufferGeometry3().setFromPoints(points);
+    });
+    this.lineGeometry = mergeGeometries2(geometries);
+  }
+  createBorder() {
+    const line = new LineSegments3(this.lineGeometry, this.lineMaterial);
+    this.LineMesh = line;
+    this.add(line);
+    return line;
+  }
+  init() {
+    this.initGeometry();
+    this.initMaterial();
+    const mesh = new Mesh6(this.geometry, this.material);
+    this.add(mesh);
+    this.initLineMaterial();
+    this.initLineGeometry();
+    this.createBorder();
+    this.initDoubleLine();
+  }
+  dispose() {
+    this.geometry?.dispose();
+    this.lineGeometry?.dispose();
+    this.clear();
+  }
+};
+
 // src/operations/selection/box-selection.ts
 import { Frustum } from "three";
 var BoxSelection = class extends BaseSvg {
@@ -3956,13 +4143,15 @@ var HoverHelper = class extends EventDispatcher5 {
 };
 
 // src/factory/material.ts
+import { LineMaterial } from "three/examples/jsm/lines/LineMaterial";
 import {
   Color as Color4,
-  LineBasicMaterial as LineBasicMaterial3,
+  LineBasicMaterial as LineBasicMaterial4,
   MeshStandardMaterial as MeshStandardMaterial2,
-  MeshBasicMaterial as MeshBasicMaterial5,
+  MeshBasicMaterial as MeshBasicMaterial6,
   ShaderMaterial as ShaderMaterial2,
-  DoubleSide as DoubleSide4
+  DoubleSide as DoubleSide4,
+  Vector2 as Vector25
 } from "three";
 function vectorToString(vector) {
   return `${vector.x}-${vector.y}-${vector.z}`;
@@ -3976,6 +4165,7 @@ var MaterialFactory = class {
   meshBasicMaterialMap = /* @__PURE__ */ new Map();
   shaderMaterialMap = /* @__PURE__ */ new Map();
   groundTextureMaterialMap = /* @__PURE__ */ new Map();
+  line2MaterialMap = /* @__PURE__ */ new Map();
   generateLineMaterialKey({ color, opacity }) {
     return `${color}-${opacity}`;
   }
@@ -3984,7 +4174,7 @@ var MaterialFactory = class {
     if (this.lineMaterialMap.has(key)) {
       return this.lineMaterialMap.get(key);
     }
-    const lineMaterial = new LineBasicMaterial3({
+    const lineMaterial = new LineBasicMaterial4({
       color: new Color4(color).convertLinearToSRGB(),
       transparent: true,
       opacity
@@ -4012,7 +4202,7 @@ var MaterialFactory = class {
     if (this.meshBasicMaterialMap.has(key)) {
       return this.meshBasicMaterialMap.get(key);
     }
-    const material = new MeshBasicMaterial5({
+    const material = new MeshBasicMaterial6({
       color,
       transparent: true,
       opacity,
@@ -4115,7 +4305,7 @@ var MaterialFactory = class {
       return this.groundTextureMaterialMap.get(key);
     }
     const texture = await this.context.textureFactory.getTexture(url);
-    const material = new MeshBasicMaterial5({
+    const material = new MeshBasicMaterial6({
       map: texture,
       transparent: true,
       opacity
@@ -4123,6 +4313,24 @@ var MaterialFactory = class {
     this.groundTextureMaterialMap.set(key, material);
     return material;
   }
+  createLine2MaterialMap({ color, width, dashed }) {
+    const key = `${color}-${width}-${dashed}`;
+    if (this.line2MaterialMap.has(key)) {
+      return this.line2MaterialMap.get(key);
+    }
+    const material = new LineMaterial({
+      color: parseInt(color.slice(1), 16),
+      dashed,
+      linewidth: width,
+      worldUnits: true,
+      dashSize: 1,
+      gapSize: 3,
+      dashScale: 1,
+      resolution: new Vector25(this.context.clientSize.width, this.context.clientSize.height)
+    });
+    this.line2MaterialMap.set(key, material);
+    return material;
+  }
   dispose() {
     this.lineMaterialMap.forEach((val, _) => {
       val.dispose();
@@ -4145,11 +4353,15 @@ var MaterialFactory = class {
       val.map?.dispose();
     });
     this.groundTextureMaterialMap.clear();
+    this.line2MaterialMap.forEach((val, _) => {
+      val.dispose();
+    });
+    this.line2MaterialMap.clear();
   }
 };
 
 // src/utils/camera-bound.ts
-import { Box3 as Box37, Vector3 as Vector313 } from "three";
+import { Box3 as Box38, Vector3 as Vector316 } from "three";
 var CameraBound = class {
   constructor(context) {
     this.context = context;
@@ -4157,9 +4369,9 @@ var CameraBound = class {
     this.changePrevCamera();
   }
   prevCamera = {
-    position: new Vector313(),
+    position: new Vector316(),
     zoom: 1,
-    target: new Vector313()
+    target: new Vector316()
   };
   enable = true;
   setEnable(enable) {
@@ -4196,13 +4408,13 @@ var CameraBound = class {
     if (!floors.length) {
       return null;
     }
-    const box = new Box37().setFromObject(this.context.scene);
+    const box = new Box38().setFromObject(this.context.scene);
     const { camera, clientSize: { width: w, height: h } } = this.context;
     const { min, max } = box;
     const lb = vector3ToDevice(min, camera, w, h);
     const rt = vector3ToDevice(max, camera, w, h);
-    const lt = vector3ToDevice(new Vector313(min.x, max.y, max.z), camera, w, h);
-    const rb = vector3ToDevice(new Vector313(max.x, min.y, min.z), camera, w, h);
+    const lt = vector3ToDevice(new Vector316(min.x, max.y, max.z), camera, w, h);
+    const rb = vector3ToDevice(new Vector316(max.x, min.y, min.z), camera, w, h);
     const left = Math.min(lb.x, rt.x, lt.x, rb.x);
     const right = Math.max(lb.x, rt.x, lt.x, rb.x);
     const top = Math.min(lb.y, rt.y, lt.y, rb.y);
@@ -4332,7 +4544,7 @@ var Context = class extends EventDispatcher6 {
   /**
    * 获取两个点之间的像素数
    */
-  getRatio(point1 = new Vector314(0, 0, 0), point22 = new Vector314(100, 0, 0)) {
+  getRatio(point1 = new Vector317(0, 0, 0), point22 = new Vector317(100, 0, 0)) {
     const { clientWidth, clientHeight } = this.container;
     const device1 = vector3ToDevice(point1, this.camera, clientWidth, clientHeight);
     const device2 = vector3ToDevice(point22, this.camera, clientWidth, clientHeight);
@@ -4393,7 +4605,7 @@ var Context = class extends EventDispatcher6 {
    * @returns
    */
   getGraphicsByDeviceXy(x, y) {
-    const point3 = new Vector25();
+    const point3 = new Vector26();
     point3.x = x / this.clientSize.width * 2 - 1;
     point3.y = y / this.clientSize.height * -2 + 1;
     const raycaster = new Raycaster3();
@@ -4533,7 +4745,7 @@ var Context = class extends EventDispatcher6 {
     );
   }
   getCameraLookAt() {
-    return new Vector314().subVectors(this.control.target, this.camera.position);
+    return new Vector317().subVectors(this.control.target, this.camera.position);
   }
   /**
    * 按照一个中心点设置相机的放大缩小
@@ -4585,28 +4797,28 @@ var Context = class extends EventDispatcher6 {
     if (force2DView) {
       this.setPolarAngle(0, 0);
     }
-    const boundingBox = new Box38().setFromObject(object);
+    const boundingBox = new Box39().setFromObject(object);
     this.setPolarAngle(polar, 0);
     const { max, min } = boundingBox;
-    const leftTop = new Vector314(min.x, max.y, max.z);
-    const rightTop = new Vector314(max.x, max.y, max.z);
-    const rightBottom = new Vector314(max.x, min.y, min.z);
-    const leftBottom = new Vector314(min.x, min.y, min.z);
+    const leftTop = new Vector317(min.x, max.y, max.z);
+    const rightTop = new Vector317(max.x, max.y, max.z);
+    const rightBottom = new Vector317(max.x, min.y, min.z);
+    const leftBottom = new Vector317(min.x, min.y, min.z);
     const leftTop2d = vector3ToDevice(leftTop, this.camera, width, height);
     const rightTop2d = vector3ToDevice(rightTop, this.camera, width, height);
     const leftBottom2d = vector3ToDevice(leftBottom, this.camera, width, height);
     const rightBottom2d = vector3ToDevice(rightBottom, this.camera, width, height);
     const boundingBox2d = new Box2().setFromPoints([
-      new Vector25(leftTop2d.x, leftTop2d.y),
-      new Vector25(rightTop2d.x, rightTop2d.y),
-      new Vector25(leftBottom2d.x, leftBottom2d.y),
-      new Vector25(rightBottom2d.x, rightBottom2d.y)
+      new Vector26(leftTop2d.x, leftTop2d.y),
+      new Vector26(rightTop2d.x, rightTop2d.y),
+      new Vector26(leftBottom2d.x, leftBottom2d.y),
+      new Vector26(rightBottom2d.x, rightBottom2d.y)
     ]);
-    const size = boundingBox2d.getSize(new Vector25());
+    const size = boundingBox2d.getSize(new Vector26());
     const xScale = (width - right - left) / size.x;
     const yScale = (height - top - bottom) / size.y;
     const scale = Math.min(xScale, yScale);
-    const center2 = new Vector314((max.x + min.x) / 2, (max.y + min.y) / 2, (max.z + min.z) / 2);
+    const center2 = new Vector317((max.x + min.x) / 2, (max.y + min.y) / 2, (max.z + min.z) / 2);
     return { zoom: scale * this.camera.zoom, center: center2 };
   }
   /**
@@ -5157,7 +5369,7 @@ var BMap = class extends EventDispatcher7 {
         } = this.context;
         const device = vector3ToDevice(position, camera, width, height);
         const offsetX = device.x - width / 2;
-        const v3 = new Vector315();
+        const v3 = new Vector318();
         v3.setFromMatrixColumn(this.context.camera.matrix, 0);
         v3.normalize();
         v3.multiplyScalar(offsetX / this.context.camera.zoom);
@@ -5530,32 +5742,32 @@ function Worker2() {
 
 // src/plugins/navigation/path.ts
 import {
-  Mesh as Mesh6,
-  Object3D as Object3D13,
+  Mesh as Mesh7,
+  Object3D as Object3D15,
   TextureLoader as TextureLoader2,
   Color as Color7,
-  Vector2 as Vector27,
-  Vector3 as Vector317,
+  Vector2 as Vector28,
+  Vector3 as Vector320,
   NormalBlending,
   RepeatWrapping
 } from "three";
 
 // src/external/meshLine.js
 import {
-  BufferGeometry as BufferGeometry3,
+  BufferGeometry as BufferGeometry4,
   Matrix4,
-  Vector3 as Vector316,
+  Vector3 as Vector319,
   Ray as Ray2,
   Sphere,
-  LineSegments as LineSegments3,
+  LineSegments as LineSegments4,
   BufferAttribute,
   ShaderChunk,
   ShaderMaterial as ShaderMaterial3,
   UniformsLib,
   Color as Color6,
-  Vector2 as Vector26
+  Vector2 as Vector27
 } from "three";
-var MeshLine = class extends BufferGeometry3 {
+var MeshLine = class extends BufferGeometry4 {
   constructor() {
     super();
     this.isMeshLine = true;
@@ -5624,7 +5836,7 @@ MeshLine.prototype.setPoints = function(points, wcb) {
   this.widthCallback = wcb;
   this.positions = [];
   this.counters = [];
-  if (points.length && points[0] instanceof Vector316) {
+  if (points.length && points[0] instanceof Vector319) {
     for (var j = 0; j < points.length; j++) {
       var p = points[j];
       var c = j / points.length;
@@ -5648,7 +5860,7 @@ function MeshLineRaycast(raycaster, intersects) {
   var inverseMatrix = new Matrix4();
   var ray = new Ray2();
   var sphere = new Sphere();
-  var interRay = new Vector316();
+  var interRay = new Vector319();
   var geometry = this.geometry;
   if (!geometry.boundingSphere) geometry.computeBoundingSphere();
   sphere.copy(geometry.boundingSphere);
@@ -5658,10 +5870,10 @@ function MeshLineRaycast(raycaster, intersects) {
   }
   inverseMatrix.copy(this.matrixWorld).invert();
   ray.copy(raycaster.ray).applyMatrix4(inverseMatrix);
-  var vStart = new Vector316();
-  var vEnd = new Vector316();
-  var interSegment = new Vector316();
-  var step = this instanceof LineSegments3 ? 2 : 1;
+  var vStart = new Vector319();
+  var vEnd = new Vector319();
+  var interSegment = new Vector319();
+  var step = this instanceof LineSegments4 ? 2 : 1;
   var index = geometry.index;
   var attributes = geometry.attributes;
   if (index !== null) {
@@ -5714,8 +5926,8 @@ MeshLine.prototype.getDistance = function(i) {
   let maxLength = 0;
   for (let k = 0; k < i; k++) {
     const index = 6 * k;
-    const p0 = new Vector316(this.positions[index], this.positions[index + 1], this.positions[index + 2]);
-    const p1 = new Vector316(this.positions[index + 6], this.positions[index + 7], this.positions[index + 8]);
+    const p0 = new Vector319(this.positions[index], this.positions[index + 1], this.positions[index + 2]);
+    const p1 = new Vector319(this.positions[index + 6], this.positions[index + 7], this.positions[index + 8]);
     const distance = p0.distanceTo(p1);
     maxLength += distance;
   }
@@ -5983,7 +6195,7 @@ var MeshLineMaterial = class extends ShaderMaterial3 {
         useAlphaMap: { value: 0 },
         color: { value: new Color6(16777215) },
         opacity: { value: 1 },
-        resolution: { value: new Vector26(1, 1) },
+        resolution: { value: new Vector27(1, 1) },
         sizeAttenuation: { value: 1 },
         dashArray: { value: 0 },
         dashOffset: { value: 0 },
@@ -5991,7 +6203,7 @@ var MeshLineMaterial = class extends ShaderMaterial3 {
         useDash: { value: 0 },
         visibility: { value: 1 },
         alphaTest: { value: 0 },
-        repeat: { value: new Vector26(1, 1) }
+        repeat: { value: new Vector27(1, 1) }
       }),
       vertexShader: ShaderChunk.meshline_vert,
       fragmentShader: ShaderChunk.meshline_frag
@@ -6178,7 +6390,7 @@ var defaultConfig2 = {
   lineWidth: 8,
   color: 16777215
 };
-var Path2 = class extends Object3D13 {
+var Path2 = class extends Object3D15 {
   constructor(navigation, config) {
     super();
     this.navigation = navigation;
@@ -6227,7 +6439,7 @@ var Path2 = class extends Object3D13 {
       }
     } = this;
     const screenPoints = points.map(
-      ([x, y]) => vector3ToDevice(new Vector317(x, y, 0), camera, width, height)
+      ([x, y]) => vector3ToDevice(new Vector320(x, y, 0), camera, width, height)
     ).map(({ x, y }) => [x, y]);
     const pointLength = getPathLength(screenPoints);
     return pointLength / 32;
@@ -6237,7 +6449,7 @@ var Path2 = class extends Object3D13 {
       return;
     }
     const repeat = this.getRepeat();
-    this.material.repeat = new Vector27(repeat, 1);
+    this.material.repeat = new Vector28(repeat, 1);
   }
   loadTexture(url) {
     return new Promise((r, j) => {
@@ -6272,7 +6484,7 @@ var Path2 = class extends Object3D13 {
       useMap: true,
       color: new Color7(this.config.color),
       transparent: true,
-      resolution: new Vector27(
+      resolution: new Vector28(
         this.navigation.bmap.context.clientSize.width,
         this.navigation.bmap.context.clientSize.height
       ),
@@ -6281,9 +6493,9 @@ var Path2 = class extends Object3D13 {
       lineWidth: this.config.lineWidth * 2,
       map: this.texture,
       blending: NormalBlending,
-      repeat: new Vector27(this.getRepeat(), 1)
+      repeat: new Vector28(this.getRepeat(), 1)
     });
-    const mesh = this.mesh = new Mesh6(lineGeometry, material);
+    const mesh = this.mesh = new Mesh7(lineGeometry, material);
     this.add(mesh);
     return mesh;
   }
@@ -6776,6 +6988,10 @@ function createStore(storeName, db = _db) {
     db.createObjectStore(storeName, { keyPath: "key" });
   }
 }
+function closeDb() {
+  _db?.close();
+  _db = null;
+}
 
 // src/loader/AibeeLoader/zstd.worker.ts
 function Worker3() {
@@ -6785,9 +7001,7 @@ function Worker3() {
 // src/loader/AibeeLoader/utils.ts
 function transformGraphicData(data, center2, baseIndex = 0) {
   data.forEach((item) => {
-    item.geometry.coords = JSON.parse(
-      JSON.stringify(item.geometry.cds)
-    );
+    item.geometry.coords = JSON.parse(JSON.stringify(item.geometry.cds));
     if (item.geometry.type === "polygon") {
       item.geometry.coords.map((cds) => {
         if (Array.isArray(cds)) {
@@ -6797,6 +7011,11 @@ function transformGraphicData(data, center2, baseIndex = 0) {
           });
         }
       });
+      if (item.geometry.otherCds) {
+        item.geometry.otherCoords = item.geometry.otherCds.map(
+          (cds) => cds.map((item2) => translatePosToCenter(item2, center2))
+        );
+      }
     } else {
       item.geometry.coords = translatePosToCenter(item.geometry.cds, center2);
     }
@@ -6908,20 +7127,45 @@ var AibeeLoader = class {
           });
           break;
         case "lane":
+          transformGraphicData(layer.elements, center2);
+          const laneGroup = layer.elements.reduce((obj, options) => {
+            const { fillColor, fillOpacity, strokeColor, strokeOpacity } = options;
+            const key = `${fillColor}-${fillOpacity}-${strokeColor}-${strokeOpacity}`;
+            if (obj[key]) {
+              obj[key].push(options);
+            } else {
+              obj[key] = [options];
+            }
+            return obj;
+          }, {});
+          Object.values(laneGroup).forEach((optionArray) => {
+            const lane = new Lane(this.bmap.context, optionArray);
+            floor.laneLayer.add(lane);
+          });
           break;
         case "texture2d":
         case "texture3d":
+          transformGraphicData(layer.elements, center2);
           layer.elements.forEach((options) => {
-            options.center = translatePosToCenter(options.center, center2);
             const texture = new GroundTexture(this.bmap.context, options);
             floor.textureLayer.add(texture);
           });
           break;
         case "glb":
+          transformGraphicData(layer.elements, center2);
+          layer.elements.forEach((options) => {
+            const model = new GlbModel(this.bmap.context, {
+              ...options,
+              url: options.secondUrl,
+              rotate: options.secondRotate,
+              width: options.secondWidth
+            });
+            floor.glbModelLayer.add(model);
+          });
           break;
         case "store":
           layer.elements.map((options) => {
-            const pos = translatePosToCenter(options.geometry.cds, center2);
+            const pos = translatePosToCenter([options.center_x, options.center_y], center2);
             floor.poiLayer.createPoi({
               icon: options.poi_info.icon,
               texts: [{ text: options.store_name || options.poi_info.name }],
@@ -6971,6 +7215,7 @@ var AibeeLoader = class {
   }
   dispose() {
     this.clear();
+    closeDb();
   }
 };
 export {
@@ -6981,12 +7226,14 @@ export {
   Equipment,
   Events,
   Floor,
+  GlbModel,
   Graphic,
   GraphicLayer,
   GroundTexture,
   HeatmapElement,
   HooksName,
   HoverHelper,
+  Lane,
   Layer,
   MapTypePolar,
   Model,