venue-js 1.2.0-next.13 → 1.2.0-next.15

package/dist/index.mjs

@@ -81,7 +81,8 @@ var defaultFeatureQueryOptionsMap = {
     // refresh every 5 min
   },
   element: {},
-  page: {}
+  page: {},
+  model3d: {}
 };
 
 // src/data/api/delivery-project.ts
@@ -97,6 +98,14 @@ async function fetchDeliveryApi(projectId, apiKey, featureType, baseUrl = DEFAUL
       const items = await res.json();
       return items;
     }
+    case "model3d": {
+      const res = await fetch(
+        `${baseUrl}/delivery/projects/${projectId}/${featureType}.geojson?api-key=${apiKey}`
+      );
+      if (res.status !== 200) return [];
+      const items = await res.json();
+      return items.features;
+    }
     case "sponsored-content": {
       const res = await fetch(
         `${baseUrl}/delivery/projects/${projectId}/sponsored-content.json?api-key=${apiKey}`
@@ -207,16 +216,16 @@ function isValidLinearRingCoordinates(ring) {
   }
   return ring.every(isValidCoordinate) && ring[0][0] === ring[ring.length - 1][0] && ring[0][1] === ring[ring.length - 1][1];
 }
-var isValidPolygonCoordinates = (polygon) => {
-  if (Array.isArray(polygon[0]) && (polygon[0].length === 0 || typeof polygon[0][0] === "number")) {
-    return isValidLinearRingCoordinates(polygon);
+var isValidPolygonCoordinates = (polygon2) => {
+  if (Array.isArray(polygon2[0]) && (polygon2[0].length === 0 || typeof polygon2[0][0] === "number")) {
+    return isValidLinearRingCoordinates(polygon2);
   }
-  if (Array.isArray(polygon) && polygon.length > 0 && Array.isArray(polygon[0])) {
-    if (!isValidLinearRingCoordinates(polygon[0])) {
+  if (Array.isArray(polygon2) && polygon2.length > 0 && Array.isArray(polygon2[0])) {
+    if (!isValidLinearRingCoordinates(polygon2[0])) {
       return false;
     }
-    for (let i = 1; i < polygon.length; i++) {
-      if (!isValidLinearRingCoordinates(polygon[i])) {
+    for (let i = 1; i < polygon2.length; i++) {
+      if (!isValidLinearRingCoordinates(polygon2[i])) {
         return false;
       }
     }
@@ -259,7 +268,7 @@ var isValidPoint = (geometry) => {
 function isInFilter(filter) {
   return typeof filter === "object" && filter !== null && "$in" in filter && Array.isArray(filter.$in);
 }
-var someIntersect = (a, b) => a.some((v) => b.includes(v));
+var someIntersect = (a, b) => a.some((v2) => b.includes(v2));
 function matchFilter(value, filter) {
   if (Array.isArray(value)) {
     if (isInFilter(filter)) return someIntersect(value, filter.$in);
@@ -746,6 +755,28 @@ function point(coordinates, properties, options = {}) {
   };
   return feature(geom, properties, options);
 }
+function polygon(coordinates, properties, options = {}) {
+  for (const ring of coordinates) {
+    if (ring.length < 4) {
+      throw new Error(
+        "Each LinearRing of a Polygon must have 4 or more Positions."
+      );
+    }
+    if (ring[ring.length - 1].length !== ring[0].length) {
+      throw new Error("First and last Position are not equivalent.");
+    }
+    for (let j = 0; j < ring[ring.length - 1].length; j++) {
+      if (ring[ring.length - 1][j] !== ring[0][j]) {
+        throw new Error("First and last Position are not equivalent.");
+      }
+    }
+  }
+  const geom = {
+    type: "Polygon",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
 function lineString(coordinates, properties, options = {}) {
   if (coordinates.length < 2) {
     throw new Error("coordinates must be an array of two or more positions");
@@ -767,6 +798,13 @@ function featureCollection(features, options = {}) {
   fc.features = features;
   return fc;
 }
+function multiPoint(coordinates, properties, options = {}) {
+  const geom = {
+    type: "MultiPoint",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
 function isNumber(num) {
   return !isNaN(num) && num !== null && !Array.isArray(num);
 }
@@ -775,7 +813,7 @@ function isNumber(num) {
 import turfDistance from "@turf/distance";
 import turfCenter3 from "@turf/center";
 import { PerspectiveCamera } from "three";
-import { ThreeLayer as ThreeLayer4 } from "maptalks.three";
+import { ThreeLayer as ThreeLayer5 } from "maptalks.three";
 
 // src/IndoorMap/constants.ts
 var defaultLayerOption = { enableAltitude: true };
@@ -911,7 +949,7 @@ var Billboard = class extends BaseObject {
     this._initOptions(options);
     const {
       altitude = OPTIONS.altitude,
-      scale: scale2 = OPTIONS.scale,
+      scale: scale3 = OPTIONS.scale,
       alphaTest = OPTIONS.alphaTest,
       legColor = OPTIONS.legColor,
       showLeg = OPTIONS.showLeg
@@ -945,8 +983,8 @@ var Billboard = class extends BaseObject {
       const sprite = new Sprite(material);
       sprite.material.sizeAttenuation = false;
       sprite.scale.set(
-        scale2 * naturalWidth / divider,
-        scale2 * naturalHeight / divider,
+        scale3 * naturalWidth / divider,
+        scale3 * naturalHeight / divider,
         1
       );
       this.getObject3d().add(sprite);
@@ -955,7 +993,7 @@ var Billboard = class extends BaseObject {
     const position = layer.coordinateToVector3(coordinate, z);
     _.set(this.properties, "default.position", position);
     _.set(this.properties, "default.altitude", altitude);
-    _.set(this.properties, "default.scale", scale2);
+    _.set(this.properties, "default.scale", scale3);
     this.getObject3d().position.copy(position);
   }
   setLineHeight(altitude) {
@@ -968,414 +1006,120 @@ var Billboard = class extends BaseObject {
   }
 };
 
-// src/IndoorMap/object3d/GroundLabel.ts
-import * as maptalks2 from "maptalks";
+// src/IndoorMap/object3d/SpriteMarker.ts
 import { BaseObject as BaseObject2 } from "maptalks.three";
-import {
-  Texture,
-  MeshPhongMaterial,
-  PlaneGeometry
-} from "three";
-import { largestRect } from "d3plus-shape";
-import { max, merge, isNumber as isNumber2, isArray, range } from "lodash-es";
-var OPTIONS2 = {
-  // Allowing click through and prevent interaction
-  interactive: false,
-  altitude: 0
-};
-var defaultFlatLabelOptions = {
-  fontSize: 14,
-  fontFamily: "Manrope",
-  fontWeight: 600,
-  margin: 0,
-  scaleMin: 0.5,
-  lineHeight: 1.05,
-  scaleStep: 0.05,
-  textAlign: "center",
-  textBaseline: "middle",
-  fillStyle: "#000"
+import { Sprite as Sprite2, SpriteMaterial as SpriteMaterial2 } from "three";
+import _2 from "lodash";
+var DEFAULT_SCALE = 0.05;
+var DEFAULT_ALTITUDE = 0;
+var DEFAULT_ALPHATEST = 0.3;
+var DEFAULT_OPTIONS = {
+  scale: DEFAULT_SCALE,
+  altitude: DEFAULT_ALTITUDE,
+  alphaTest: DEFAULT_ALPHATEST,
+  highlight: {
+    options: {
+      scale: DEFAULT_SCALE * 1.25
+    },
+    material: null
+  }
 };
-var defaultRectAngleToCalc = range(-90, 92, 2);
-var getMaterial = (text, flatLabelOptions) => {
-  const options = merge({}, defaultFlatLabelOptions, flatLabelOptions);
-  const {
-    fontSize: initialFontSize,
-    fontFamily,
-    fontWeight,
-    margin,
-    scaleMin,
-    scaleStep,
-    fillStyle,
-    lineHeight,
-    textAlign,
-    strokeStyle,
-    lineWidth,
-    textBaseline
-  } = options;
-  const pixelMultiplier = 4;
-  const SIZE = 100 * pixelMultiplier;
-  const fontSize = initialFontSize * (pixelMultiplier * 1.25);
-  const canvas = document.createElement("canvas");
-  canvas.width = canvas.height = SIZE;
-  const ctx = canvas.getContext("2d");
-  ctx.font = `${fontWeight} ${fontSize}px "${fontFamily}", Arial`;
-  ctx.textAlign = textAlign;
-  ctx.textBaseline = textBaseline;
-  ctx.fillStyle = fillStyle;
-  ctx.strokeStyle = strokeStyle;
-  ctx.lineWidth = lineWidth;
-  const wrapText = (ctx2, text2, maxWidth) => {
-    const words = text2.trim().split(/\s+/);
-    if (words.length <= 1) return [text2];
-    const lines = [];
-    const MAX_LINES = 3;
-    let currentLine = words[0];
-    for (let i = 1; i < words.length; i++) {
-      const lineToMeasure = currentLine + " " + words[i];
-      if (ctx2.measureText(lineToMeasure).width > maxWidth) {
-        lines.push(currentLine);
-        currentLine = words[i];
-      } else {
-        currentLine = lineToMeasure;
-      }
+var SpriteMarker = class extends BaseObject2 {
+  #default = null;
+  #highlight = null;
+  constructor(coordinate, options, material, layer, properties) {
+    super();
+    this._initOptions(options);
+    this._createGroup();
+    const {
+      altitude = DEFAULT_OPTIONS.altitude,
+      scale: scale3 = DEFAULT_OPTIONS.scale,
+      highlight = DEFAULT_OPTIONS.highlight,
+      alphaTest = DEFAULT_OPTIONS.alphaTest
+    } = options;
+    this.properties = { ...properties };
+    const modifiedAltitude = altitude + 2;
+    this.#default = { options: { scale: scale3, altitude: modifiedAltitude }, material };
+    this.#highlight = _2.merge({}, DEFAULT_OPTIONS.highlight, highlight);
+    if (material && material instanceof SpriteMaterial2)
+      material.alphaTest = alphaTest;
+    const sprite = new Sprite2(material);
+    sprite.scale.set(scale3, scale3, scale3);
+    const obj3d = this.getObject3d();
+    obj3d.add(sprite);
+    const z = layer.altitudeToVector3(modifiedAltitude, modifiedAltitude).x;
+    const position = layer.coordinateToVector3(coordinate, z);
+    _2.set(this.properties, "default.position", position);
+    this.getObject3d().position.copy(position);
+  }
+  // Different objects need to implement their own methods
+  setSymbol(material) {
+    if (material && material instanceof SpriteMaterial2) {
+      const sprite = this.getObject3d().children[0];
+      if (!sprite) return this;
+      sprite.material = material;
+      sprite.material.needsUpdate = true;
     }
-    lines.push(currentLine);
-    return lines.slice(0, MAX_LINES);
-  };
-  const hasManualBreaks = text.includes("\n");
-  let texts;
-  if (hasManualBreaks) {
-    texts = text.split(/\n/g);
-  } else {
-    const maxWidth = SIZE - 2 * margin;
-    texts = wrapText(ctx, text, maxWidth);
+    return this;
   }
-  let textWidth = max(texts.map((text2) => ctx.measureText(text2).width));
-  let scale2 = 1;
-  while (scale2 > 0 && textWidth + 2 * margin > SIZE) {
-    scale2 -= scaleStep;
-    ctx.font = `${fontWeight} ${scale2 * fontSize}px "${fontFamily}", Arial`;
-    textWidth = max(texts.map((text2) => ctx.measureText(text2).width));
+  setScale(scaleX, scaleY = scaleX, scaleZ = scaleX) {
+    const sprite = this.getObject3d().children[0];
+    if (!sprite) return this;
+    sprite.scale.set(scaleX, scaleY, scaleZ);
+    return this;
   }
-  const center2 = { x: 0.5 * SIZE, y: 0.5 * SIZE };
-  if (scale2 > scaleMin) {
-    const totalHeight = texts.length * (fontSize * scale2 * lineHeight);
-    const startY = center2.y - totalHeight / 2 + fontSize * scale2 * lineHeight * 0.5;
-    texts.forEach((text2, index) => {
-      const yOffset = startY + index * (fontSize * scale2 * lineHeight);
-      if (strokeStyle && lineWidth) {
-        ctx.strokeText(text2, center2.x, yOffset);
-      }
-      ctx.fillText(text2, center2.x, yOffset);
-    });
+  // Different objects need to implement their own methods
+  getSymbol() {
+    return this.getObject3d()?.children[0]?.material;
+  }
+  highlight() {
+    const { material, options } = this.#highlight;
+    if (material) this.setSymbol(material);
+    if (options.scale) this.setScale(options.scale);
+    if (options.altitude) this.setAltitude(options.altitude);
+    return this;
+  }
+  removeHighlight() {
+    const { material, options } = this.#default;
+    if (material) this.setSymbol(material);
+    if (options.scale) this.setScale(options.scale);
+    if (options.altitude) this.setAltitude(options.altitude);
+    return this;
   }
-  const texture = new Texture(canvas);
-  texture.needsUpdate = true;
-  const material = new MeshPhongMaterial({
-    map: texture,
-    transparent: true,
-    // @ref: https://threejs.org/docs/#api/en/materials/Material.alphaTest
-    alphaTest: 0.3
-  });
-  return material;
 };
-var GroundLabel = class extends BaseObject2 {
-  #angle = 0;
-  #bearing = 0;
-  #text = "";
-  #offsetX = 0;
-  #offsetY = 0;
-  #originalPosition = null;
-  #layer = null;
-  constructor(bound, options, layer) {
+
+// src/IndoorMap/object3d/NavigationPath.ts
+import * as maptalks2 from "maptalks";
+import { BaseObject as BaseObject3 } from "maptalks.three";
+import { MeshBasicMaterial, ShaderMaterial, Color } from "three";
+var OPTIONS2 = {
+  altitude: 0
+};
+var DEFAULT_LINE_OPTION = {
+  color: "#000",
+  opacity: 1
+};
+var DEFAULT_LINE_EFFECT_OPTION = {
+  color: "#000",
+  opacity: 1
+};
+var ENABLE_ANIMATED_PATH = true;
+var NavigationPath = class extends BaseObject3 {
+  constructor(feature2, layer, properties, options, lineOptions = DEFAULT_LINE_OPTION, outlineOption = DEFAULT_LINE_EFFECT_OPTION) {
     options = maptalks2.Util.extend({}, OPTIONS2, options, {
-      layer,
-      coordinate: bound
+      layer
     });
-    const {
-      altitude,
-      text,
-      fontSize,
-      fillStyle,
-      textAlign,
-      fontFamily,
-      textBaseline,
-      strokeStyle,
-      lineWidth,
-      angle = defaultRectAngleToCalc,
-      maxFontScale,
-      offsetX = 0,
-      offsetY = 0,
-      ...properties
-    } = options;
     super();
     this._initOptions(options);
-    this.properties = properties;
-    this.#offsetX = offsetX;
-    this.#offsetY = offsetY;
-    this.#layer = layer;
-    const material = getMaterial(text, {
-      fillStyle,
-      fontSize,
-      textAlign,
-      textBaseline,
-      fontFamily,
-      strokeStyle,
-      lineWidth
-    });
-    const rectAngles = isArray(angle) ? angle : [angle];
-    material.needsUpdate = true;
-    const rect = largestRect(bound, {
-      cache: true,
-      /**
-       * Black magic here:
-       * For some reason if we allow angle -90 or 90, some polygon will use that angle even if it's wrong angle to use.
-       * So we remove -90 and 90 from choices, and use -85 & 85 instead.
-       */
-      angle: rectAngles
-    });
-    const { cx, cy, width, angle: calculatedAngle } = rect;
-    this.#text = text;
-    this.#angle = calculatedAngle;
-    const geometry = new PlaneGeometry(1, 1);
-    this._createMesh(geometry, material);
-    const z = layer.altitudeToVector3(altitude, altitude).x;
-    const basePosition = layer.coordinateToVector3({ x: cx, y: cy }, z);
-    this.#originalPosition = basePosition.clone();
-    const finalPosition = this.#calculateFinalPosition(basePosition);
-    const scale2 = width / 6456122659e-13;
-    const finalScale = maxFontScale && scale2 > maxFontScale ? maxFontScale : scale2;
-    this.getObject3d().scale.set(finalScale, finalScale, finalScale);
-    this.getObject3d().position.copy(finalPosition);
-    this.getObject3d().rotation.z = Math.PI / 180 * this.#angle;
-  }
-  #calculateFinalPosition(basePosition) {
-    if (this.#offsetX === 0 && this.#offsetY === 0) {
-      return basePosition;
-    }
-    const offsetCoordinate = {
-      x: this.#offsetX,
-      y: this.#offsetY
-    };
-    const z = this.#layer.altitudeToVector3(0, 0).x;
-    const offsetVector = this.#layer.coordinateToVector3(offsetCoordinate, z);
-    const zeroVector = this.#layer.coordinateToVector3({ x: 0, y: 0 }, z);
-    const worldOffsetX = offsetVector.x - zeroVector.x;
-    const worldOffsetY = offsetVector.y - zeroVector.y;
-    return {
-      x: basePosition.x + worldOffsetX,
-      y: basePosition.y + worldOffsetY,
-      z: basePosition.z
-    };
-  }
-  #updatePosition() {
-    if (this.#originalPosition && this.#layer) {
-      const finalPosition = this.#calculateFinalPosition(this.#originalPosition);
-      this.getObject3d().position.copy(finalPosition);
-    }
-  }
-  set bearing(value) {
-    this.#bearing = value;
-    const degree = this.#angle + this.#bearing;
-    const angle = degree > 90 || degree < -90 ? this.#angle + 180 : this.#angle;
-    this.getObject3d().rotation.z = Math.PI / 180 * angle;
-  }
-  get angle() {
-    return this.#angle;
-  }
-  get currentAngle() {
-    return this.#angle;
-  }
-  get text() {
-    return this.#text;
-  }
-  get offsetX() {
-    return this.#offsetX;
-  }
-  get offsetY() {
-    return this.#offsetY;
-  }
-  get offset() {
-    return { x: this.#offsetX, y: this.#offsetY };
-  }
-  set offsetX(value) {
-    if (isNumber2(value)) {
-      this.#offsetX = value;
-      this.#updatePosition();
-    }
-  }
-  set offsetY(value) {
-    if (isNumber2(value)) {
-      this.#offsetY = value;
-      this.#updatePosition();
-    }
-  }
-  set angle(newAngle) {
-    if (isNumber2(newAngle)) {
-      this.#angle = newAngle;
-      this.getObject3d().rotation.z = Math.PI / 180 * this.#angle;
-    }
-  }
-  setOffset(offsetX, offsetY) {
-    if (isNumber2(offsetX) && isNumber2(offsetY)) {
-      this.#offsetX = offsetX;
-      this.#offsetY = offsetY;
-      this.#updatePosition();
-    }
-  }
-  addOffset(deltaX, deltaY) {
-    if (isNumber2(deltaX) && isNumber2(deltaY)) {
-      this.#offsetX += deltaX;
-      this.#offsetY += deltaY;
-      this.#updatePosition();
-    }
-  }
-  resetOffset() {
-    this.#offsetX = 0;
-    this.#offsetY = 0;
-    this.#updatePosition();
-  }
-  moveToPosition(targetX, targetY) {
-    if (this.#originalPosition && this.#layer) {
-      const currentCenter = this.#layer.vector3ToCoordinate(
-        this.#originalPosition
-      );
-      this.#offsetX = targetX - currentCenter.x;
-      this.#offsetY = targetY - currentCenter.y;
-      this.#updatePosition();
-    }
-  }
-  updateText(newText, options = {}) {
-    this.#text = newText;
-    const materialOptions = {
-      fillStyle: options.fillStyle || this.properties.fillStyle,
-      fontSize: options.fontSize || this.properties.fontSize,
-      textAlign: options.textAlign || this.properties.textAlign,
-      textBaseline: options.textBaseline || this.properties.textBaseline,
-      fontFamily: options.fontFamily || this.properties.fontFamily,
-      strokeStyle: options.strokeStyle || this.properties.strokeStyle,
-      lineWidth: options.lineWidth || this.properties.lineWidth
-    };
-    const newMaterial = getMaterial(newText, materialOptions);
-    this.getObject3d().material = newMaterial;
-    newMaterial.needsUpdate = true;
-  }
-};
-
-// src/IndoorMap/object3d/SpriteMarker.ts
-import { BaseObject as BaseObject3 } from "maptalks.three";
-import { Sprite as Sprite2, SpriteMaterial as SpriteMaterial2 } from "three";
-import _2 from "lodash";
-var DEFAULT_SCALE = 0.05;
-var DEFAULT_ALTITUDE = 0;
-var DEFAULT_ALPHATEST = 0.3;
-var DEFAULT_OPTIONS = {
-  scale: DEFAULT_SCALE,
-  altitude: DEFAULT_ALTITUDE,
-  alphaTest: DEFAULT_ALPHATEST,
-  highlight: {
-    options: {
-      scale: DEFAULT_SCALE * 1.25
-    },
-    material: null
-  }
-};
-var SpriteMarker = class extends BaseObject3 {
-  #default = null;
-  #highlight = null;
-  constructor(coordinate, options, material, layer, properties) {
-    super();
-    this._initOptions(options);
-    this._createGroup();
-    const {
-      altitude = DEFAULT_OPTIONS.altitude,
-      scale: scale2 = DEFAULT_OPTIONS.scale,
-      highlight = DEFAULT_OPTIONS.highlight,
-      alphaTest = DEFAULT_OPTIONS.alphaTest
-    } = options;
-    this.properties = { ...properties };
-    const modifiedAltitude = altitude + 2;
-    this.#default = { options: { scale: scale2, altitude: modifiedAltitude }, material };
-    this.#highlight = _2.merge({}, DEFAULT_OPTIONS.highlight, highlight);
-    if (material && material instanceof SpriteMaterial2)
-      material.alphaTest = alphaTest;
-    const sprite = new Sprite2(material);
-    sprite.scale.set(scale2, scale2, scale2);
-    const obj3d = this.getObject3d();
-    obj3d.add(sprite);
-    const z = layer.altitudeToVector3(modifiedAltitude, modifiedAltitude).x;
-    const position = layer.coordinateToVector3(coordinate, z);
-    _2.set(this.properties, "default.position", position);
-    this.getObject3d().position.copy(position);
-  }
-  // Different objects need to implement their own methods
-  setSymbol(material) {
-    if (material && material instanceof SpriteMaterial2) {
-      const sprite = this.getObject3d().children[0];
-      if (!sprite) return this;
-      sprite.material = material;
-      sprite.material.needsUpdate = true;
-    }
-    return this;
-  }
-  setScale(scaleX, scaleY = scaleX, scaleZ = scaleX) {
-    const sprite = this.getObject3d().children[0];
-    if (!sprite) return this;
-    sprite.scale.set(scaleX, scaleY, scaleZ);
-    return this;
-  }
-  // Different objects need to implement their own methods
-  getSymbol() {
-    return this.getObject3d()?.children[0]?.material;
-  }
-  highlight() {
-    const { material, options } = this.#highlight;
-    if (material) this.setSymbol(material);
-    if (options.scale) this.setScale(options.scale);
-    if (options.altitude) this.setAltitude(options.altitude);
-    return this;
-  }
-  removeHighlight() {
-    const { material, options } = this.#default;
-    if (material) this.setSymbol(material);
-    if (options.scale) this.setScale(options.scale);
-    if (options.altitude) this.setAltitude(options.altitude);
-    return this;
-  }
-};
-
-// src/IndoorMap/object3d/NavigationPath.ts
-import * as maptalks3 from "maptalks";
-import { BaseObject as BaseObject4 } from "maptalks.three";
-import { MeshBasicMaterial, ShaderMaterial, Color } from "three";
-var OPTIONS3 = {
-  altitude: 0
-};
-var DEFAULT_LINE_OPTION = {
-  color: "#000",
-  opacity: 1
-};
-var DEFAULT_LINE_EFFECT_OPTION = {
-  color: "#000",
-  opacity: 1
-};
-var ENABLE_ANIMATED_PATH = true;
-var NavigationPath = class extends BaseObject4 {
-  constructor(feature2, layer, properties, options, lineOptions = DEFAULT_LINE_OPTION, outlineOption = DEFAULT_LINE_EFFECT_OPTION) {
-    options = maptalks3.Util.extend({}, OPTIONS3, options, {
-      layer
-    });
-    super();
-    this._initOptions(options);
-    const { altitude = OPTIONS3.altitude } = options;
-    this.properties = { ...properties };
-    this._createGroup();
-    const { color: lineColor, opacity: lineOpacity } = lineOptions || DEFAULT_LINE_OPTION;
-    const staticMaterial = new MeshBasicMaterial({
-      transparent: true,
-      color: lineColor || "#fff",
-      opacity: lineOpacity || 1,
-      depthWrite: false
+    const { altitude = OPTIONS2.altitude } = options;
+    this.properties = { ...properties };
+    this._createGroup();
+    const { color: lineColor, opacity: lineOpacity } = lineOptions || DEFAULT_LINE_OPTION;
+    const staticMaterial = new MeshBasicMaterial({
+      transparent: true,
+      color: lineColor || "#fff",
+      opacity: lineOpacity || 1,
+      depthWrite: false
     });
     const uniforms = {
       time: { value: 0 },
@@ -1407,7 +1151,7 @@ var NavigationPath = class extends BaseObject4 {
         }
       `
     });
-    const pathGeometry = maptalks3.GeoJSON.toGeometry(feature2);
+    const pathGeometry = maptalks2.GeoJSON.toGeometry(feature2);
     const line = layer.toPath(
       pathGeometry,
       {
@@ -1465,8 +1209,8 @@ var createPolygonFromLineString = (geometry) => {
   const right = turfLineOffset(line, -0.3, { units: "meters" });
   const leftCoords = left.geometry.coordinates;
   const rightCoords = right.geometry.coordinates.reverse();
-  const polygon = [...leftCoords, ...rightCoords, leftCoords[0]];
-  return [polygon];
+  const polygon2 = [...leftCoords, ...rightCoords, leftCoords[0]];
+  return [polygon2];
 };
 
 // src/IndoorMap/utils/svg.ts
@@ -1500,8 +1244,8 @@ var createSVGPathFromMarkerSymbol = (style) => {
     markerFill,
     markerPath
   } = style;
-  const scale2 = markerWidth / 24;
-  return `<path d="${markerPath}" style="transform:translate(${markerDx}px, ${markerDy}px) scale(${scale2})" fill="${markerFill}"/>`;
+  const scale3 = markerWidth / 24;
+  return `<path d="${markerPath}" style="transform:translate(${markerDx}px, ${markerDy}px) scale(${scale3})" fill="${markerFill}"/>`;
 };
 
 // src/IndoorMap/utils/createElements.js
@@ -1642,8 +1386,8 @@ var createObstructionalFixture = (feature2, style = {}, options = {}) => {
   if (allowOverride) _4.merge(symbolStyle, properties.style);
   if (inheritFillColorToLine) symbolStyle.lineColor = symbolStyle.polygonFill;
   if (geometry.type === "LineString") {
-    const polygon = createPolygonFromLineString(geometry);
-    return new GeometryType["Polygon"](polygon, {
+    const polygon2 = createPolygonFromLineString(geometry);
+    return new GeometryType["Polygon"](polygon2, {
       properties: {
         altitude: getAltitude(properties)
       },
@@ -2498,68 +2242,12 @@ var styledFeatureGenerator = (mapTheme) => {
       }
       return objects;
     },
-    create3DGroundLabel: (label, threeLayer) => {
-      const text = label.properties.name;
-      const bound = label.geometry.coordinates[0];
-      if (_4.isNil(bound)) throw new Error("Invalid coordinates");
-      const groundLabelSymbol = getElementSymbol("ground-label");
-      const featureSymbol = _4.get(label, "properties", {});
-      const groundLabelOptions = _4.merge(
-        {},
-        { text },
-        groundLabelSymbol,
-        featureSymbol
-      );
-      return new GroundLabel(bound, groundLabelOptions, threeLayer);
-    },
-    createOccupantGroundLabel: (feature2, location, mapConfig, threeLayer) => {
-      const text = feature2.properties.name.en;
-      const bound = location.geometry.coordinates[0];
-      if (_4.isNil(bound)) throw new Error("Invalid coordinates");
-      const groundLabelSymbol = getElementSymbol("occupant-flat-label");
-      const groundLabelOptions = getElementOptions("occupant-flat-label");
-      const baseAltitude = getAltitude(location.properties);
-      const extrudeHeight = _4.get(
-        mapConfig,
-        "extrudeConfig.unit.room.height",
-        0
-      );
-      const totalAltitude = baseAltitude + extrudeHeight + 0.05;
-      const customAngle = _4.get(feature2, "properties.style.angle");
-      const offsetX = _4.get(feature2, "properties.style.offsetX", 0);
-      const offsetY = _4.get(feature2, "properties.style.offsetY", 0);
-      const featureSymbol = {
-        name: text,
-        ordinal: location.properties.ordinal,
-        venue_id: feature2.properties.venue_id
-      };
-      const mergedGroundLabelOptions = _4.merge(
-        {},
-        { text },
-        groundLabelSymbol,
-        groundLabelOptions,
-        featureSymbol,
-        {
-          altitude: totalAltitude,
-          offsetX,
-          offsetY,
-          // set custom angle
-          ...!_4.isNil(customAngle) ? { angle: customAngle } : {}
-        }
-      );
-      const groundLabel = new GroundLabel(
-        bound,
-        mergedGroundLabelOptions,
-        threeLayer
-      );
-      return groundLabel;
-    },
     create3DBillboard: (billboard, threeLayer) => {
       const { id, feature_type, properties } = billboard;
       const {
         logo,
         altitude,
-        scale: scale2,
+        scale: scale3,
         alphaTest,
         legColor,
         showLeg,
@@ -2573,7 +2261,7 @@ var styledFeatureGenerator = (mapTheme) => {
       };
       const options = {
         altitude,
-        scale: scale2,
+        scale: scale3,
         alphaTest,
         legColor,
         showLeg,
@@ -2712,10 +2400,10 @@ var styledFeatureGenerator = (mapTheme) => {
         transparent: true
       });
       if (unit.geometry.type === "LineString") {
-        const polygon = createPolygonFromLineString(unit.geometry);
+        const polygon2 = createPolygonFromLineString(unit.geometry);
         const geometry = {
           type: "Polygon",
-          coordinates: polygon
+          coordinates: polygon2
         };
         return createExtrudePolygon(
           geometry,
@@ -2817,9 +2505,9 @@ var getRelatedLocationsByAmenity = (feature2) => {
 var getRelatedLocationIdsByFeature = (feature2) => {
   switch (feature2?.feature_type) {
     case "amenity":
-      return getRelatedLocationsByAmenity(feature2).map((v) => v?.id);
+      return getRelatedLocationsByAmenity(feature2).map((v2) => v2?.id);
     case "occupant":
-      return getRelatedLocationsByOccupant(feature2).map((v) => v?.id);
+      return getRelatedLocationsByOccupant(feature2).map((v2) => v2?.id);
     default:
       return [];
   }
@@ -2963,120 +2651,429 @@ function coordEach(geojson, callback, excludeWrapCoord) {
       }
     }
   }
-}
-
-// ../../node_modules/@turf/bbox/dist/esm/index.js
-function bbox(geojson, options = {}) {
-  if (geojson.bbox != null && true !== options.recompute) {
-    return geojson.bbox;
+}
+
+// ../../node_modules/@turf/bbox/dist/esm/index.js
+function bbox(geojson, options = {}) {
+  if (geojson.bbox != null && true !== options.recompute) {
+    return geojson.bbox;
+  }
+  const result = [Infinity, Infinity, -Infinity, -Infinity];
+  coordEach(geojson, (coord) => {
+    if (result[0] > coord[0]) {
+      result[0] = coord[0];
+    }
+    if (result[1] > coord[1]) {
+      result[1] = coord[1];
+    }
+    if (result[2] < coord[0]) {
+      result[2] = coord[0];
+    }
+    if (result[3] < coord[1]) {
+      result[3] = coord[1];
+    }
+  });
+  return result;
+}
+var index_default = bbox;
+
+// src/IndoorMap/camera/CameraManager.ts
+import scale from "@turf/transform-scale";
+import bboxPolygon from "@turf/bbox-polygon";
+var CameraManager = class {
+  map;
+  constructor(map, options) {
+    this.map = map;
+    if (options?.defaultView) {
+      this.setView(options?.defaultView);
+    }
+  }
+  /** Public methods */
+  getView = () => {
+    return this.map.getView();
+  };
+  setView = (value) => {
+    if (this.map && Object.keys(value).length !== 0) {
+      this.map.setView(value);
+    }
+  };
+  animateTo = (view, options = {}, step) => {
+    this.map.animateTo(view, options, step);
+  };
+  setMaxExtent(extent) {
+    return this.map.setMaxExtent(extent);
+  }
+  getFeatureExtent = (feature2, scaleFactor = 1) => {
+    const [minX, minY, maxX, maxY] = index_default(
+      scale(bboxPolygon(index_default(feature2)), scaleFactor)
+    );
+    return new Extent(minX, minY, maxX, maxY);
+  };
+  getExtentZoom = (extent, options = {
+    isFraction: false,
+    padding: {
+      paddingLeft: 0,
+      paddingRight: 0,
+      paddingTop: 0,
+      paddingBottom: 0
+    }
+  }) => {
+    const { isFraction = false, padding } = options;
+    return this.map.getFitZoom(extent, isFraction, padding);
+  };
+  set maxZoom(value) {
+    this.map.setMaxZoom(value);
+    const spatialReference = {
+      projection: "EPSG:3857",
+      resolutions: (function() {
+        const resolutions = [];
+        const d = 2 * 6378137 * Math.PI;
+        for (let i = 0; i < value; i++) {
+          resolutions[i] = d / (256 * Math.pow(2, i));
+        }
+        return resolutions;
+      })()
+    };
+    this.map.setSpatialReference(spatialReference);
+  }
+  set minZoom(value) {
+    this.map.setMinZoom(value);
+  }
+};
+
+// src/IndoorMap/renderer/RendererManager.ts
+import _compact2 from "lodash/compact";
+import _isFunction from "lodash/isFunction";
+import _min from "lodash/min";
+import { center as turfCenter2 } from "@turf/center";
+import * as THREE3 from "three";
+
+// src/IndoorMap/renderer/3d/Element3DRenderer.ts
+import * as maptalks4 from "maptalks-gl";
+import * as THREE from "three";
+import { BaseObject as BaseObject5 } from "maptalks.three";
+import turfBuffer2 from "@turf/buffer";
+import { cleanCoords } from "@turf/clean-coords";
+import { polygonToLine } from "@turf/polygon-to-line";
+import { nearestPointOnLine } from "@turf/nearest-point-on-line";
+import { length } from "@turf/length";
+import { along } from "@turf/along";
+import { pointToLineDistance } from "@turf/point-to-line-distance";
+
+// src/IndoorMap/renderer/3d/objects/GroundLabel.ts
+import * as maptalks3 from "maptalks-gl";
+import { BaseObject as BaseObject4 } from "maptalks.three";
+import {
+  Texture,
+  MeshPhongMaterial,
+  PlaneGeometry
+} from "three";
+import { largestRect } from "d3plus-shape";
+import { max, merge, isNumber as isNumber2, isArray, range } from "lodash-es";
+var OPTIONS3 = {
+  // Allowing click through and prevent interaction
+  interactive: false,
+  altitude: 0
+};
+var defaultFlatLabelOptions = {
+  fontSize: 14,
+  fontFamily: "Manrope",
+  fontWeight: 600,
+  margin: 0,
+  scaleMin: 0.5,
+  lineHeight: 1.05,
+  scaleStep: 0.05,
+  textAlign: "center",
+  textBaseline: "middle",
+  fillStyle: "#000"
+};
+var defaultRectAngleToCalc = range(-90, 92, 2);
+var getMaterial = (text, flatLabelOptions) => {
+  const options = merge({}, defaultFlatLabelOptions, flatLabelOptions);
+  const {
+    fontSize: initialFontSize,
+    fontFamily,
+    fontWeight,
+    margin,
+    scaleMin,
+    scaleStep,
+    fillStyle,
+    lineHeight,
+    textAlign,
+    strokeStyle,
+    lineWidth,
+    textBaseline
+  } = options;
+  const pixelMultiplier = 4;
+  const SIZE = 100 * pixelMultiplier;
+  const fontSize = initialFontSize * (pixelMultiplier * 1.25);
+  const canvas = document.createElement("canvas");
+  canvas.width = canvas.height = SIZE;
+  const ctx = canvas.getContext("2d");
+  ctx.font = `${fontWeight} ${fontSize}px "${fontFamily}", Arial`;
+  ctx.textAlign = textAlign;
+  ctx.textBaseline = textBaseline;
+  ctx.fillStyle = fillStyle;
+  ctx.strokeStyle = strokeStyle;
+  ctx.lineWidth = lineWidth;
+  const wrapText = (ctx2, text2, maxWidth) => {
+    const words = text2.trim().split(/\s+/);
+    if (words.length <= 1) return [text2];
+    const lines = [];
+    const MAX_LINES = 3;
+    let currentLine = words[0];
+    for (let i = 1; i < words.length; i++) {
+      const lineToMeasure = currentLine + " " + words[i];
+      if (ctx2.measureText(lineToMeasure).width > maxWidth) {
+        lines.push(currentLine);
+        currentLine = words[i];
+      } else {
+        currentLine = lineToMeasure;
+      }
+    }
+    lines.push(currentLine);
+    return lines.slice(0, MAX_LINES);
+  };
+  const hasManualBreaks = text.includes("\n");
+  let texts;
+  if (hasManualBreaks) {
+    texts = text.split(/\n/g);
+  } else {
+    const maxWidth = SIZE - 2 * margin;
+    texts = wrapText(ctx, text, maxWidth);
+  }
+  let textWidth = max(texts.map((text2) => ctx.measureText(text2).width));
+  let scale3 = 1;
+  while (scale3 > 0 && textWidth + 2 * margin > SIZE) {
+    scale3 -= scaleStep;
+    ctx.font = `${fontWeight} ${scale3 * fontSize}px "${fontFamily}", Arial`;
+    textWidth = max(texts.map((text2) => ctx.measureText(text2).width));
+  }
+  const center2 = { x: 0.5 * SIZE, y: 0.5 * SIZE };
+  if (scale3 > scaleMin) {
+    const totalHeight = texts.length * (fontSize * scale3 * lineHeight);
+    const startY = center2.y - totalHeight / 2 + fontSize * scale3 * lineHeight * 0.5;
+    texts.forEach((text2, index) => {
+      const yOffset = startY + index * (fontSize * scale3 * lineHeight);
+      if (strokeStyle && lineWidth) {
+        ctx.strokeText(text2, center2.x, yOffset);
+      }
+      ctx.fillText(text2, center2.x, yOffset);
+    });
+  }
+  const texture = new Texture(canvas);
+  texture.needsUpdate = true;
+  const material = new MeshPhongMaterial({
+    map: texture,
+    transparent: true,
+    // @ref: https://threejs.org/docs/#api/en/materials/Material.alphaTest
+    alphaTest: 0.3
+  });
+  return material;
+};
+var GroundLabel = class extends BaseObject4 {
+  #angle = 0;
+  #bearing = 0;
+  #text = "";
+  #offsetX = 0;
+  #offsetY = 0;
+  #originalPosition = null;
+  #layer = null;
+  constructor(bound, text, options, layer) {
+    options = maptalks3.Util.extend({}, OPTIONS3, options, {
+      layer,
+      coordinate: bound
+    });
+    const {
+      altitude = 0,
+      bottomHeight = 0,
+      fontSize,
+      fillStyle,
+      textAlign,
+      fontFamily,
+      textBaseline,
+      strokeStyle,
+      lineWidth,
+      angle = defaultRectAngleToCalc,
+      maxFontScale,
+      offsetX = 0,
+      offsetY = 0,
+      ...properties
+    } = options;
+    super();
+    this._initOptions(options);
+    this.properties = properties;
+    this.#offsetX = offsetX;
+    this.#offsetY = offsetY;
+    this.#layer = layer;
+    const material = getMaterial(text, {
+      fillStyle,
+      fontSize,
+      textAlign,
+      textBaseline,
+      fontFamily,
+      strokeStyle,
+      lineWidth
+    });
+    const rectAngles = isArray(angle) ? angle : [angle];
+    material.needsUpdate = true;
+    const rect = largestRect(bound, {
+      cache: true,
+      /**
+       * Black magic here:
+       * For some reason if we allow angle -90 or 90, some polygon will use that angle even if it's wrong angle to use.
+       * So we remove -90 and 90 from choices, and use -85 & 85 instead.
+       */
+      angle: rectAngles
+    });
+    const { cx, cy, width, angle: calculatedAngle } = rect;
+    this.#text = text;
+    this.#angle = calculatedAngle;
+    const geometry = new PlaneGeometry(1, 1);
+    this._createMesh(geometry, material);
+    const z = layer.altitudeToVector3(altitude + bottomHeight, altitude + bottomHeight).x;
+    const basePosition = layer.coordinateToVector3([cx, cy], z);
+    this.#originalPosition = basePosition.clone();
+    const finalPosition = this.#calculateFinalPosition(basePosition);
+    const scale3 = width / 6456122659e-13;
+    const finalScale = maxFontScale && scale3 > maxFontScale ? maxFontScale : scale3;
+    this.getObject3d().scale.set(finalScale, finalScale, finalScale);
+    this.getObject3d().position.copy(finalPosition);
+    this.getObject3d().rotation.z = Math.PI / 180 * this.#angle;
+  }
+  #calculateFinalPosition(basePosition) {
+    if (this.#offsetX === 0 && this.#offsetY === 0) {
+      return basePosition;
+    }
+    const offsetCoordinate = [this.#offsetX, this.#offsetY];
+    const z = this.#layer.altitudeToVector3(0, 0).x;
+    const offsetVector = this.#layer.coordinateToVector3(offsetCoordinate, z);
+    const zeroVector = this.#layer.coordinateToVector3([0, 0], z);
+    const worldOffsetX = offsetVector.x - zeroVector.x;
+    const worldOffsetY = offsetVector.y - zeroVector.y;
+    return {
+      x: basePosition.x + worldOffsetX,
+      y: basePosition.y + worldOffsetY,
+      z: basePosition.z
+    };
+  }
+  #updatePosition() {
+    if (this.#originalPosition && this.#layer) {
+      const finalPosition = this.#calculateFinalPosition(this.#originalPosition);
+      this.getObject3d().position.copy(finalPosition);
+    }
+  }
+  set bearing(value) {
+    this.#bearing = value;
+    const degree = this.#angle + this.#bearing;
+    const angle = degree > 90 || degree < -90 ? this.#angle + 180 : this.#angle;
+    this.getObject3d().rotation.z = Math.PI / 180 * angle;
+  }
+  get angle() {
+    return this.#angle;
+  }
+  get currentAngle() {
+    return this.#angle;
+  }
+  get text() {
+    return this.#text;
+  }
+  get offsetX() {
+    return this.#offsetX;
   }
-  const result = [Infinity, Infinity, -Infinity, -Infinity];
-  coordEach(geojson, (coord) => {
-    if (result[0] > coord[0]) {
-      result[0] = coord[0];
-    }
-    if (result[1] > coord[1]) {
-      result[1] = coord[1];
+  get offsetY() {
+    return this.#offsetY;
+  }
+  get offset() {
+    return { x: this.#offsetX, y: this.#offsetY };
+  }
+  set offsetX(value) {
+    if (isNumber2(value)) {
+      this.#offsetX = value;
+      this.#updatePosition();
     }
-    if (result[2] < coord[0]) {
-      result[2] = coord[0];
+  }
+  set offsetY(value) {
+    if (isNumber2(value)) {
+      this.#offsetY = value;
+      this.#updatePosition();
     }
-    if (result[3] < coord[1]) {
-      result[3] = coord[1];
+  }
+  set angle(newAngle) {
+    if (isNumber2(newAngle)) {
+      this.#angle = newAngle;
+      this.getObject3d().rotation.z = Math.PI / 180 * this.#angle;
     }
-  });
-  return result;
-}
-var index_default = bbox;
-
-// src/IndoorMap/camera/CameraManager.ts
-import scale from "@turf/transform-scale";
-import bboxPolygon from "@turf/bbox-polygon";
-var CameraManager = class {
-  map;
-  constructor(map, options) {
-    this.map = map;
-    if (options?.defaultView) {
-      this.setView(options?.defaultView);
+  }
+  setOffset(offsetX, offsetY) {
+    if (isNumber2(offsetX) && isNumber2(offsetY)) {
+      this.#offsetX = offsetX;
+      this.#offsetY = offsetY;
+      this.#updatePosition();
     }
   }
-  /** Public methods */
-  getView = () => {
-    return this.map.getView();
-  };
-  setView = (value) => {
-    if (this.map && Object.keys(value).length !== 0) {
-      this.map.setView(value);
+  addOffset(deltaX, deltaY) {
+    if (isNumber2(deltaX) && isNumber2(deltaY)) {
+      this.#offsetX += deltaX;
+      this.#offsetY += deltaY;
+      this.#updatePosition();
     }
-  };
-  animateTo = (view, options = {}, step) => {
-    this.map.animateTo(view, options, step);
-  };
-  setMaxExtent(extent) {
-    return this.map.setMaxExtent(extent);
   }
-  getFeatureExtent = (feature2, scaleFactor = 1) => {
-    const [minX, minY, maxX, maxY] = index_default(
-      scale(bboxPolygon(index_default(feature2)), scaleFactor)
-    );
-    return new Extent(minX, minY, maxX, maxY);
-  };
-  getExtentZoom = (extent, options = {
-    isFraction: false,
-    padding: {
-      paddingLeft: 0,
-      paddingRight: 0,
-      paddingTop: 0,
-      paddingBottom: 0
+  resetOffset() {
+    this.#offsetX = 0;
+    this.#offsetY = 0;
+    this.#updatePosition();
+  }
+  moveToPosition(targetX, targetY) {
+    if (this.#originalPosition && this.#layer) {
+      const currentCenter = this.#layer.vector3ToCoordinate(
+        this.#originalPosition
+      );
+      this.#offsetX = targetX - currentCenter.x;
+      this.#offsetY = targetY - currentCenter.y;
+      this.#updatePosition();
     }
-  }) => {
-    const { isFraction = false, padding } = options;
-    return this.map.getFitZoom(extent, isFraction, padding);
-  };
-  set maxZoom(value) {
-    this.map.setMaxZoom(value);
-    const spatialReference = {
-      projection: "EPSG:3857",
-      resolutions: (function() {
-        const resolutions = [];
-        const d = 2 * 6378137 * Math.PI;
-        for (let i = 0; i < value; i++) {
-          resolutions[i] = d / (256 * Math.pow(2, i));
-        }
-        return resolutions;
-      })()
+  }
+  updateText(newText, options = {}) {
+    this.#text = newText;
+    const materialOptions = {
+      fillStyle: options.fillStyle || this.properties.fillStyle,
+      fontSize: options.fontSize || this.properties.fontSize,
+      textAlign: options.textAlign || this.properties.textAlign,
+      textBaseline: options.textBaseline || this.properties.textBaseline,
+      fontFamily: options.fontFamily || this.properties.fontFamily,
+      strokeStyle: options.strokeStyle || this.properties.strokeStyle,
+      lineWidth: options.lineWidth || this.properties.lineWidth
     };
-    this.map.setSpatialReference(spatialReference);
+    const newMaterial = getMaterial(newText, materialOptions);
+    this.getObject3d().material = newMaterial;
+    newMaterial.needsUpdate = true;
   }
-  set minZoom(value) {
-    this.map.setMinZoom(value);
+  _animation() {
+    const map = this.getMap();
+    if (!map) return;
+    const bearing = map.getBearing();
+    this.bearing = bearing;
+  }
+  // Add bottomHeight to altitude as final altitude position
+  setAltitude(altitude) {
+    const bottomHeight = this.options.bottomHeight ?? 0;
+    return super.setAltitude(altitude + bottomHeight);
   }
 };
 
-// src/IndoorMap/renderer/RendererManager.ts
-import _isFunction from "lodash/isFunction";
-import _min from "lodash/min";
-import { center as turfCenter2 } from "@turf/center";
-import * as THREE3 from "three";
-
-// src/IndoorMap/renderer/3d/Element3DRenderer.ts
-import * as maptalks4 from "maptalks-gl";
-import * as THREE from "three";
-import { BaseObject as BaseObject5 } from "maptalks.three";
-import turfBuffer2 from "@turf/buffer";
-
 // src/IndoorMap/renderer/3d/element3DRendererOptions.ts
 var element3DRendererOptions = {
   unit: {
-    default: { color: "#ffffff", height: 4 },
+    default: { color: "#ffffff", height: 0.2 },
     byCategory: {
       walkway: { color: "#cccccc", height: 0.1 },
       terrace: { color: "#cccccc", height: 0.1 },
       unenclosedarea: { color: "#cccccc", height: 0.2 },
       nonpublic: { color: "#999999", height: 0.3 },
       escalator: { height: 0.2 },
-      parking: { height: 0.1 },
-      room: { color: "#ffffff", height: 2, bottomHeight: 0.12 }
+      parking: { color: "#999999", height: 0.1 },
+      room: { color: "#ffffff", height: 0.5, bottomHeight: 0.12 }
     }
   },
   kiosk: {
@@ -3092,30 +3089,31 @@ var element3DRendererOptions = {
   }
 };
 
-// src/IndoorMap/renderer/3d/Element3DRenderer.ts
+// src/IndoorMap/renderer/3d/utils/get3DRendererOption.ts
 var DEFAULT_POLYGON_OPTION = {
   color: "#FFFFFF",
   offset: 0,
   altitude: 0
 };
-var HEIGHT_METER = 4;
-var MULTIORDINAL_HEIGHT_METER = 9;
-var getGeometryOption = (feature2, options) => {
+var get3DRendererOption = (featureType, category, options) => {
   try {
-    const option = options[feature2.feature_type] ?? element3DRendererOptions[feature2.feature_type];
-    const category = feature2.properties.category;
+    const option = options[featureType] ?? element3DRendererOptions[featureType];
     return (category && option.byCategory?.[category]) ?? option?.default ?? DEFAULT_POLYGON_OPTION;
   } catch (err) {
-    console.log(err.message, { options, feature: feature2 });
+    console.log(err.message, { options, featureType, category });
   }
 };
+
+// src/IndoorMap/renderer/3d/Element3DRenderer.ts
+import lineSplit from "@turf/line-split";
+var HEIGHT_METER = 4;
+var MULTIORDINAL_HEIGHT_METER = 9;
 var Element3DRenderer = class extends EventTarget {
   options;
   map;
   gltfLayer;
   threeLayer;
   scene;
-  // private dracoLoader: DRACOLoader
   lineMaterial;
   materialByColorMap;
   // Renderer is Ready
@@ -3154,7 +3152,7 @@ var Element3DRenderer = class extends EventTarget {
       bottomHeight: bottomHeightOptions,
       color: colorOptions,
       ...options
-    } = getGeometryOption(feature2, this.options);
+    } = get3DRendererOption(feature2.feature_type, feature2.properties.category, this.options);
     const _this = this;
     const createPolygon = (geometry, feature3) => {
       try {
@@ -3239,6 +3237,68 @@ var Element3DRenderer = class extends EventTarget {
       console.log(`error createGeometry`, err, { feature: feature2, options });
     }
   };
+  createRoomWall(unit, openings = []) {
+    const polygons = unit.geometry.type === "Polygon" ? [unit.geometry.coordinates] : unit.geometry.coordinates;
+    return polygons.map((plg) => {
+      return plg.map((ring) => {
+        const roomWall = cleanCoords(polygonToLine(polygon([ring])));
+        if (openings.length === 0) {
+          const color = "#ababab";
+          const material = this.getOrCreateMaterialByColor(color);
+          const extrudedWall = this.threeLayer.toExtrudeLine(
+            new maptalks4.LineString(roomWall.geometry.coordinates),
+            { height: 4, width: 1 },
+            material
+          );
+          return extrudedWall;
+        }
+        let openingPoints = [];
+        openings.forEach((opening) => {
+          const doorCoords = opening?.geometry?.coordinates;
+          const p0 = point(doorCoords[0]);
+          const p1 = point(doorCoords[doorCoords.length - 1]);
+          const s0 = nearestPointOnLine(roomWall, p0, { units: "meters" });
+          const s1 = nearestPointOnLine(roomWall, p1, { units: "meters" });
+          const d0 = s0.properties.dist;
+          const d1 = s1.properties.dist;
+          if (d0 > 1 || d1 > 1) {
+          } else {
+            openingPoints = openingPoints.concat([s0.geometry.coordinates, s1.geometry.coordinates]);
+          }
+        });
+        try {
+          const split = lineSplit(roomWall, multiPoint(openingPoints));
+          const wallsOnly = split.features.filter((seg) => {
+            const mid = along(seg, length(seg, { units: "meters" }) / 2, { units: "meters" });
+            for (const opening of openings) {
+              const dist = pointToLineDistance(mid, opening, { units: "meters" });
+              if (dist < 0.05) return false;
+            }
+            return true;
+          });
+          const wallMeshes = wallsOnly.map((feature2, i) => {
+            const color = "#ababab";
+            const material = this.getOrCreateMaterialByColor(color);
+            const extrudedLine = this.threeLayer.toExtrudeLine(
+              new maptalks4.LineString(feature2.geometry.coordinates),
+              { height: 3, width: 0.4, id: unit.id },
+              material
+            );
+            extrudedLine.getObject3d().userData = {
+              unitId: unit.id,
+              coords: feature2.geometry.coordinates
+            };
+            return extrudedLine;
+          }).flat();
+          this.threeLayer.addMesh(wallMeshes);
+          return wallMeshes;
+        } catch (e) {
+          console.log(e.message, { unit, roomWall });
+          return [];
+        }
+      }).flat();
+    }).flat();
+  }
   async createEscalator(f, coordinate, options) {
     const model = {
       url: "https://cdn.venue.in.th/static/glb/escalator.glb",
@@ -3258,14 +3318,24 @@ var Element3DRenderer = class extends EventTarget {
     escalatorMarker.addTo(this.gltfLayer);
     return escalatorMarker;
   }
-  async createTree(coordinate, ordinal) {
-    const treeMarker = new maptalks4.GLTFMarker(coordinate, {
+  // Note: Move to another renderer and keep this file on Geometry only?
+  createGroundLabel(f, unit) {
+    const text = f.properties.name;
+    const bound = f.geometry.coordinates[0];
+    const { height: unitHeight } = get3DRendererOption("unit", unit.properties.category, this.options);
+    const options = { bottomHeight: unitHeight + 5e-3 };
+    const groundLabel = new GroundLabel(bound, text, options, this.threeLayer);
+    this.threeLayer.addMesh(groundLabel);
+    return groundLabel;
+  }
+  async createModel3d(f) {
+    const marker = new maptalks4.GLTFMarker(f.properties.center, {
       symbol: {
-        url: "https://dashboard.situm.com/uploads/3dmodels/demoaccount/new_escalator.glb"
+        url: f.properties.model
       }
     });
-    treeMarker.addTo(this.gltfLayer);
-    return treeMarker;
+    marker.addTo(this.gltfLayer);
+    return marker;
   }
   async createBuilding(coordinate, ordinal) {
     return Promise.resolve(null);
@@ -3378,7 +3448,7 @@ var getGeometryProperties = (feature2) => ({
   category: feature2.properties.category,
   name: feature2.properties.name?.en
 });
-var getGeometryOption2 = (feature2, options) => {
+var getGeometryOption = (feature2, options) => {
   try {
     const option = options[feature2.feature_type] ?? element2DRendererOptions[feature2.feature_type];
     const category = feature2.properties.category;
@@ -3405,7 +3475,7 @@ var Element2DRenderer = class extends EventTarget {
   }
   createGeometry = (imdfFeature) => {
     const feature2 = getGeometryProperties(imdfFeature);
-    const { symbol, ...options } = getGeometryOption2(imdfFeature, this.options);
+    const { symbol, ...options } = getGeometryOption(imdfFeature, this.options);
     const altitude = feature2.properties.ordinal * 10;
     const geometry = maptalks5.Geometry.fromJSON({
       feature: feature2,
@@ -3424,11 +3494,16 @@ var Element2DRenderer = class extends EventTarget {
       return geometry;
     }
   };
+  createRoomWall(unit, openings) {
+    return null;
+  }
   async createEscalator(f, coordinates) {
     return Promise.resolve(null);
   }
-  async createTree(coordinates) {
-    return Promise.resolve(null);
+  createGroundLabel(f, unit) {
+    const text = f.properties.name;
+    const bound = f.geometry.coordinates[0];
+    return null;
   }
   async createBuilding(coordinate, ordinal) {
     return Promise.resolve(null);
@@ -3793,6 +3868,479 @@ var angleBetweenLineStrings = (line1, line2) => {
   return Math.atan2(dy, dx);
 };
 
+// ../../node_modules/point-in-polygon-hao/node_modules/robust-predicates/esm/util.js
+var epsilon = 11102230246251565e-32;
+var splitter = 134217729;
+var resulterrbound = (3 + 8 * epsilon) * epsilon;
+function sum(elen, e, flen, f, h) {
+  let Q, Qnew, hh, bvirt;
+  let enow = e[0];
+  let fnow = f[0];
+  let eindex = 0;
+  let findex = 0;
+  if (fnow > enow === fnow > -enow) {
+    Q = enow;
+    enow = e[++eindex];
+  } else {
+    Q = fnow;
+    fnow = f[++findex];
+  }
+  let hindex = 0;
+  if (eindex < elen && findex < flen) {
+    if (fnow > enow === fnow > -enow) {
+      Qnew = enow + Q;
+      hh = Q - (Qnew - enow);
+      enow = e[++eindex];
+    } else {
+      Qnew = fnow + Q;
+      hh = Q - (Qnew - fnow);
+      fnow = f[++findex];
+    }
+    Q = Qnew;
+    if (hh !== 0) {
+      h[hindex++] = hh;
+    }
+    while (eindex < elen && findex < flen) {
+      if (fnow > enow === fnow > -enow) {
+        Qnew = Q + enow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (enow - bvirt);
+        enow = e[++eindex];
+      } else {
+        Qnew = Q + fnow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+        fnow = f[++findex];
+      }
+      Q = Qnew;
+      if (hh !== 0) {
+        h[hindex++] = hh;
+      }
+    }
+  }
+  while (eindex < elen) {
+    Qnew = Q + enow;
+    bvirt = Qnew - Q;
+    hh = Q - (Qnew - bvirt) + (enow - bvirt);
+    enow = e[++eindex];
+    Q = Qnew;
+    if (hh !== 0) {
+      h[hindex++] = hh;
+    }
+  }
+  while (findex < flen) {
+    Qnew = Q + fnow;
+    bvirt = Qnew - Q;
+    hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+    fnow = f[++findex];
+    Q = Qnew;
+    if (hh !== 0) {
+      h[hindex++] = hh;
+    }
+  }
+  if (Q !== 0 || hindex === 0) {
+    h[hindex++] = Q;
+  }
+  return hindex;
+}
+function estimate(elen, e) {
+  let Q = e[0];
+  for (let i = 1; i < elen; i++) Q += e[i];
+  return Q;
+}
+function vec(n) {
+  return new Float64Array(n);
+}
+
+// ../../node_modules/point-in-polygon-hao/node_modules/robust-predicates/esm/orient2d.js
+var ccwerrboundA = (3 + 16 * epsilon) * epsilon;
+var ccwerrboundB = (2 + 12 * epsilon) * epsilon;
+var ccwerrboundC = (9 + 64 * epsilon) * epsilon * epsilon;
+var B = vec(4);
+var C1 = vec(8);
+var C2 = vec(12);
+var D = vec(16);
+var u = vec(4);
+function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
+  let acxtail, acytail, bcxtail, bcytail;
+  let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u32;
+  const acx = ax - cx;
+  const bcx = bx - cx;
+  const acy = ay - cy;
+  const bcy = by - cy;
+  s1 = acx * bcy;
+  c = splitter * acx;
+  ahi = c - (c - acx);
+  alo = acx - ahi;
+  c = splitter * bcy;
+  bhi = c - (c - bcy);
+  blo = bcy - bhi;
+  s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+  t1 = acy * bcx;
+  c = splitter * acy;
+  ahi = c - (c - acy);
+  alo = acy - ahi;
+  c = splitter * bcx;
+  bhi = c - (c - bcx);
+  blo = bcx - bhi;
+  t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+  _i = s0 - t0;
+  bvirt = s0 - _i;
+  B[0] = s0 - (_i + bvirt) + (bvirt - t0);
+  _j = s1 + _i;
+  bvirt = _j - s1;
+  _0 = s1 - (_j - bvirt) + (_i - bvirt);
+  _i = _0 - t1;
+  bvirt = _0 - _i;
+  B[1] = _0 - (_i + bvirt) + (bvirt - t1);
+  u32 = _j + _i;
+  bvirt = u32 - _j;
+  B[2] = _j - (u32 - bvirt) + (_i - bvirt);
+  B[3] = u32;
+  let det = estimate(4, B);
+  let errbound = ccwerrboundB * detsum;
+  if (det >= errbound || -det >= errbound) {
+    return det;
+  }
+  bvirt = ax - acx;
+  acxtail = ax - (acx + bvirt) + (bvirt - cx);
+  bvirt = bx - bcx;
+  bcxtail = bx - (bcx + bvirt) + (bvirt - cx);
+  bvirt = ay - acy;
+  acytail = ay - (acy + bvirt) + (bvirt - cy);
+  bvirt = by - bcy;
+  bcytail = by - (bcy + bvirt) + (bvirt - cy);
+  if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) {
+    return det;
+  }
+  errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);
+  det += acx * bcytail + bcy * acxtail - (acy * bcxtail + bcx * acytail);
+  if (det >= errbound || -det >= errbound) return det;
+  s1 = acxtail * bcy;
+  c = splitter * acxtail;
+  ahi = c - (c - acxtail);
+  alo = acxtail - ahi;
+  c = splitter * bcy;
+  bhi = c - (c - bcy);
+  blo = bcy - bhi;
+  s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+  t1 = acytail * bcx;
+  c = splitter * acytail;
+  ahi = c - (c - acytail);
+  alo = acytail - ahi;
+  c = splitter * bcx;
+  bhi = c - (c - bcx);
+  blo = bcx - bhi;
+  t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+  _i = s0 - t0;
+  bvirt = s0 - _i;
+  u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+  _j = s1 + _i;
+  bvirt = _j - s1;
+  _0 = s1 - (_j - bvirt) + (_i - bvirt);
+  _i = _0 - t1;
+  bvirt = _0 - _i;
+  u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+  u32 = _j + _i;
+  bvirt = u32 - _j;
+  u[2] = _j - (u32 - bvirt) + (_i - bvirt);
+  u[3] = u32;
+  const C1len = sum(4, B, 4, u, C1);
+  s1 = acx * bcytail;
+  c = splitter * acx;
+  ahi = c - (c - acx);
+  alo = acx - ahi;
+  c = splitter * bcytail;
+  bhi = c - (c - bcytail);
+  blo = bcytail - bhi;
+  s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+  t1 = acy * bcxtail;
+  c = splitter * acy;
+  ahi = c - (c - acy);
+  alo = acy - ahi;
+  c = splitter * bcxtail;
+  bhi = c - (c - bcxtail);
+  blo = bcxtail - bhi;
+  t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+  _i = s0 - t0;
+  bvirt = s0 - _i;
+  u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+  _j = s1 + _i;
+  bvirt = _j - s1;
+  _0 = s1 - (_j - bvirt) + (_i - bvirt);
+  _i = _0 - t1;
+  bvirt = _0 - _i;
+  u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+  u32 = _j + _i;
+  bvirt = u32 - _j;
+  u[2] = _j - (u32 - bvirt) + (_i - bvirt);
+  u[3] = u32;
+  const C2len = sum(C1len, C1, 4, u, C2);
+  s1 = acxtail * bcytail;
+  c = splitter * acxtail;
+  ahi = c - (c - acxtail);
+  alo = acxtail - ahi;
+  c = splitter * bcytail;
+  bhi = c - (c - bcytail);
+  blo = bcytail - bhi;
+  s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+  t1 = acytail * bcxtail;
+  c = splitter * acytail;
+  ahi = c - (c - acytail);
+  alo = acytail - ahi;
+  c = splitter * bcxtail;
+  bhi = c - (c - bcxtail);
+  blo = bcxtail - bhi;
+  t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+  _i = s0 - t0;
+  bvirt = s0 - _i;
+  u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+  _j = s1 + _i;
+  bvirt = _j - s1;
+  _0 = s1 - (_j - bvirt) + (_i - bvirt);
+  _i = _0 - t1;
+  bvirt = _0 - _i;
+  u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+  u32 = _j + _i;
+  bvirt = u32 - _j;
+  u[2] = _j - (u32 - bvirt) + (_i - bvirt);
+  u[3] = u32;
+  const Dlen = sum(C2len, C2, 4, u, D);
+  return D[Dlen - 1];
+}
+function orient2d(ax, ay, bx, by, cx, cy) {
+  const detleft = (ay - cy) * (bx - cx);
+  const detright = (ax - cx) * (by - cy);
+  const det = detleft - detright;
+  const detsum = Math.abs(detleft + detright);
+  if (Math.abs(det) >= ccwerrboundA * detsum) return det;
+  return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);
+}
+
+// ../../node_modules/point-in-polygon-hao/node_modules/robust-predicates/esm/orient3d.js
+var o3derrboundA = (7 + 56 * epsilon) * epsilon;
+var o3derrboundB = (3 + 28 * epsilon) * epsilon;
+var o3derrboundC = (26 + 288 * epsilon) * epsilon * epsilon;
+var bc = vec(4);
+var ca = vec(4);
+var ab = vec(4);
+var at_b = vec(4);
+var at_c = vec(4);
+var bt_c = vec(4);
+var bt_a = vec(4);
+var ct_a = vec(4);
+var ct_b = vec(4);
+var bct = vec(8);
+var cat = vec(8);
+var abt = vec(8);
+var u2 = vec(4);
+var _8 = vec(8);
+var _8b = vec(8);
+var _16 = vec(8);
+var _12 = vec(12);
+var fin = vec(192);
+var fin2 = vec(192);
+
+// ../../node_modules/point-in-polygon-hao/node_modules/robust-predicates/esm/incircle.js
+var iccerrboundA = (10 + 96 * epsilon) * epsilon;
+var iccerrboundB = (4 + 48 * epsilon) * epsilon;
+var iccerrboundC = (44 + 576 * epsilon) * epsilon * epsilon;
+var bc2 = vec(4);
+var ca2 = vec(4);
+var ab2 = vec(4);
+var aa = vec(4);
+var bb = vec(4);
+var cc = vec(4);
+var u3 = vec(4);
+var v = vec(4);
+var axtbc = vec(8);
+var aytbc = vec(8);
+var bxtca = vec(8);
+var bytca = vec(8);
+var cxtab = vec(8);
+var cytab = vec(8);
+var abt2 = vec(8);
+var bct2 = vec(8);
+var cat2 = vec(8);
+var abtt = vec(4);
+var bctt = vec(4);
+var catt = vec(4);
+var _82 = vec(8);
+var _162 = vec(16);
+var _16b = vec(16);
+var _16c = vec(16);
+var _32 = vec(32);
+var _32b = vec(32);
+var _48 = vec(48);
+var _64 = vec(64);
+var fin3 = vec(1152);
+var fin22 = vec(1152);
+
+// ../../node_modules/point-in-polygon-hao/node_modules/robust-predicates/esm/insphere.js
+var isperrboundA = (16 + 224 * epsilon) * epsilon;
+var isperrboundB = (5 + 72 * epsilon) * epsilon;
+var isperrboundC = (71 + 1408 * epsilon) * epsilon * epsilon;
+var ab3 = vec(4);
+var bc3 = vec(4);
+var cd = vec(4);
+var de = vec(4);
+var ea = vec(4);
+var ac = vec(4);
+var bd = vec(4);
+var ce = vec(4);
+var da = vec(4);
+var eb = vec(4);
+var abc = vec(24);
+var bcd = vec(24);
+var cde = vec(24);
+var dea = vec(24);
+var eab = vec(24);
+var abd = vec(24);
+var bce = vec(24);
+var cda = vec(24);
+var deb = vec(24);
+var eac = vec(24);
+var adet = vec(1152);
+var bdet = vec(1152);
+var cdet = vec(1152);
+var ddet = vec(1152);
+var edet = vec(1152);
+var abdet = vec(2304);
+var cddet = vec(2304);
+var cdedet = vec(3456);
+var deter = vec(5760);
+var _83 = vec(8);
+var _8b2 = vec(8);
+var _8c = vec(8);
+var _163 = vec(16);
+var _24 = vec(24);
+var _482 = vec(48);
+var _48b = vec(48);
+var _96 = vec(96);
+var _192 = vec(192);
+var _384x = vec(384);
+var _384y = vec(384);
+var _384z = vec(384);
+var _768 = vec(768);
+var xdet = vec(96);
+var ydet = vec(96);
+var zdet = vec(96);
+var fin4 = vec(1152);
+
+// ../../node_modules/point-in-polygon-hao/dist/esm/index.js
+function pointInPolygon(p, polygon2) {
+  var i;
+  var ii;
+  var k = 0;
+  var f;
+  var u1;
+  var v1;
+  var u22;
+  var v2;
+  var currentP;
+  var nextP;
+  var x = p[0];
+  var y = p[1];
+  var numContours = polygon2.length;
+  for (i = 0; i < numContours; i++) {
+    ii = 0;
+    var contour = polygon2[i];
+    var contourLen = contour.length - 1;
+    currentP = contour[0];
+    if (currentP[0] !== contour[contourLen][0] && currentP[1] !== contour[contourLen][1]) {
+      throw new Error("First and last coordinates in a ring must be the same");
+    }
+    u1 = currentP[0] - x;
+    v1 = currentP[1] - y;
+    for (ii; ii < contourLen; ii++) {
+      nextP = contour[ii + 1];
+      u22 = nextP[0] - x;
+      v2 = nextP[1] - y;
+      if (v1 === 0 && v2 === 0) {
+        if (u22 <= 0 && u1 >= 0 || u1 <= 0 && u22 >= 0) {
+          return 0;
+        }
+      } else if (v2 >= 0 && v1 <= 0 || v2 <= 0 && v1 >= 0) {
+        f = orient2d(u1, u22, v1, v2, 0, 0);
+        if (f === 0) {
+          return 0;
+        }
+        if (f > 0 && v2 > 0 && v1 <= 0 || f < 0 && v2 <= 0 && v1 > 0) {
+          k++;
+        }
+      }
+      currentP = nextP;
+      v1 = v2;
+      u1 = u22;
+    }
+  }
+  if (k % 2 === 0) {
+    return false;
+  }
+  return true;
+}
+
+// ../../node_modules/@turf/invariant/dist/esm/index.js
+function getCoord(coord) {
+  if (!coord) {
+    throw new Error("coord is required");
+  }
+  if (!Array.isArray(coord)) {
+    if (coord.type === "Feature" && coord.geometry !== null && coord.geometry.type === "Point") {
+      return [...coord.geometry.coordinates];
+    }
+    if (coord.type === "Point") {
+      return [...coord.coordinates];
+    }
+  }
+  if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
+    return [...coord];
+  }
+  throw new Error("coord must be GeoJSON Point or an Array of numbers");
+}
+function getGeom(geojson) {
+  if (geojson.type === "Feature") {
+    return geojson.geometry;
+  }
+  return geojson;
+}
+
+// ../../node_modules/@turf/boolean-point-in-polygon/dist/esm/index.js
+function booleanPointInPolygon(point2, polygon2, options = {}) {
+  if (!point2) {
+    throw new Error("point is required");
+  }
+  if (!polygon2) {
+    throw new Error("polygon is required");
+  }
+  const pt = getCoord(point2);
+  const geom = getGeom(polygon2);
+  const type = geom.type;
+  const bbox2 = polygon2.bbox;
+  let polys = geom.coordinates;
+  if (bbox2 && inBBox(pt, bbox2) === false) {
+    return false;
+  }
+  if (type === "Polygon") {
+    polys = [polys];
+  }
+  let result = false;
+  for (var i = 0; i < polys.length; ++i) {
+    const polyResult = pointInPolygon(pt, polys[i]);
+    if (polyResult === 0) return options.ignoreBoundary ? false : true;
+    else if (polyResult) result = true;
+  }
+  return result;
+}
+function inBBox(pt, bbox2) {
+  return bbox2[0] <= pt[0] && bbox2[1] <= pt[1] && bbox2[2] >= pt[0] && bbox2[3] >= pt[1];
+}
+
+// src/IndoorMap/renderer/utils/findUnitOnPoint.ts
+var findUnitOnPoint = (units, point2) => {
+  return units.find((unit) => booleanPointInPolygon(point2, polygon(unit.geometry.coordinates)));
+};
+
 // src/IndoorMap/renderer/RendererManager.ts
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -3828,6 +4376,38 @@ var RendererManager = class extends EventTarget {
       const groupLayer = this.map.getLayer("group");
       const threeLayer = groupLayer.getLayer("three");
       threeLayer.prepareToDraw = function(gl, scene, camera) {
+        function findBadMeshes(scene2) {
+          const bad = [];
+          scene2.traverse((obj) => {
+            if (!obj?.isMesh) return;
+            const geom = obj.geometry;
+            const pos = geom?.attributes?.position?.array;
+            if (!pos || pos.length === 0) return;
+            for (let i = 0; i < pos.length; i++) {
+              const v2 = pos[i];
+              if (!Number.isFinite(v2)) {
+                bad.push({ mesh: obj, index: i, value: v2 });
+                break;
+              }
+            }
+          });
+          if (bad.length) {
+            console.group(`\u274C Found ${bad.length} meshes with invalid positions`);
+            for (const b of bad) {
+              console.log({
+                name: b.mesh.name,
+                userData: b.mesh.userData,
+                uuid: b.mesh.uuid,
+                badIndex: b.index,
+                badValue: b.value
+              });
+            }
+            console.groupEnd();
+          } else {
+            console.log("\u2705 No invalid meshes found");
+          }
+          return bad;
+        }
         const ambientLight = new THREE3.AmbientLight(16777215, 0.3);
         scene.add(ambientLight);
         const dirColor = 16777215;
@@ -3842,6 +4422,9 @@ var RendererManager = class extends EventTarget {
           options.onRendererReady();
         }
         _this.#createElements();
+        setTimeout(() => {
+          findBadMeshes(scene);
+        }, 3e3);
       };
     } else {
       this.elementRenderer = new Element2DRenderer(map, options.elements);
@@ -3883,6 +4466,9 @@ var RendererManager = class extends EventTarget {
     const levels = await this.#dataClient.filterByType("level", {
       populate: true
     });
+    const openings = await this.#dataClient.filterByType("opening", {
+      populate: true
+    });
     const relationships = await this.#dataClient.filterByType("relationship");
     const fixtures = await this.#dataClient.filterByType("fixture", { populate: true });
     fixtures.forEach((fixture) => {
@@ -3896,7 +4482,7 @@ var RendererManager = class extends EventTarget {
       populate: true
     });
     units.filter(
-      (u) => !["opentobelow", "escalator"].includes(u.properties.category)
+      (u4) => !["opentobelow", "escalator", "room"].includes(u4.properties.category)
     ).forEach((unit) => {
       const element = this.elementRenderer.createGeometry(unit);
       if (element) {
@@ -3904,6 +4490,22 @@ var RendererManager = class extends EventTarget {
         this.addElementsToManager(unit.id, _elements, unit.properties.level.properties.ordinal);
       }
     });
+    units.filter((u4) => u4.properties.category === "room").forEach((unit) => {
+      const openingRelationships = relationships.filter((r) => r.properties.origin?.id === unit.id || r.properties.destination?.id === unit.id);
+      const roomOpenings = _compact2(openingRelationships.map((rel) => {
+        const openingId = rel?.properties.intermediary[0].id;
+        return openings.find((o) => o.id === openingId);
+      }));
+      const innerElements = this.elementRenderer.createGeometry(unit);
+      const wallElements = this.elementRenderer.createRoomWall(unit, roomOpenings);
+      if (innerElements || wallElements) {
+        const _innerElements = Array.isArray(innerElements) ? innerElements : [innerElements];
+        const _wallElements = Array.isArray(wallElements) ? wallElements : [wallElements];
+        const _elements = [..._innerElements, ..._wallElements];
+        const ordinal = unit.properties.level.properties.ordinal;
+        this.addElementsToManager(unit.id, _elements, ordinal);
+      }
+    });
     const kiosks = await this.#dataClient.filterByType("kiosk", {
       populate: true
     });
@@ -3914,7 +4516,7 @@ var RendererManager = class extends EventTarget {
         this.addElementsToManager(kiosk.id, _elements, kiosk.properties.level.properties.ordinal);
       }
     });
-    const escalators = units.filter((u) => u.properties.category === "escalator");
+    const escalators = units.filter((u4) => u4.properties.category === "escalator");
     for (const escalator of escalators) {
       try {
         const escalatorRelationships = relationships.filter((r) => (r.properties?.intermediary || []).some((inter) => inter.id === escalator.id));
@@ -3946,6 +4548,22 @@ var RendererManager = class extends EventTarget {
         console.warn(`cannot create escalator`, err.message);
       }
     }
+    const groundLabels = await this.#dataClient.filterByType("label");
+    for (const label of groundLabels) {
+      const center2 = turfCenter2(polygon(label.geometry.coordinates)).geometry.coordinates;
+      const unit = findUnitOnPoint(units, center2);
+      const element = this.elementRenderer.createGroundLabel(label, unit);
+      if (element) {
+        const _elements = Array.isArray(element) ? element : [element];
+        this.addElementsToManager(label.id, _elements, label.properties.ordinal);
+      }
+    }
+    if (this.options.type === "3D") {
+      const model3ds = await this.#dataClient.filterByType("model3d");
+      for (const model3d of model3ds) {
+        this.elementRenderer.createModel3d(model3d);
+      }
+    }
     this.changeLevelByOrdinal(this.currentOrdinals);
     this.dispatchEvent(new CustomEvent("renderermanager:elements_created"));
   }
@@ -4072,7 +4690,6 @@ var IndoorMap = class extends EventTarget {
   #billboardObjects = [];
   #spriteMarkerObjects = [];
   #mapDecorations = [];
-  #groundLabels = [];
   #groundObjects = [];
   #navigationGeometries = {};
   #venueObjects = [];
@@ -4136,7 +4753,7 @@ var IndoorMap = class extends EventTarget {
       layers: []
     });
     const groupLayer = new GroupGLLayer("group", [], {}).addTo(this.map);
-    const threeLayer = new ThreeLayer4("three", {
+    const threeLayer = new ThreeLayer5("three", {
       forceRenderOnMoving: true,
       forceRenderOnRotating: true
     });
@@ -4237,9 +4854,6 @@ var IndoorMap = class extends EventTarget {
   set mapDecorations(value) {
     this.#mapDecorations = value;
   }
-  set groundLabels(value) {
-    this.#groundLabels = value;
-  }
   set pixelRatio(value) {
     this.map.setDevicePixelRatio(value);
   }
@@ -4283,13 +4897,11 @@ var IndoorMap = class extends EventTarget {
       createDecoration,
       // 3D
       create3DFootprint,
-      create3DGroundLabel,
       create3DBillboard,
       createExtrudedUnit,
       create3DAmenityMarker,
       create3DOccupantAmenityMarker,
-      create3DOpeningMarker,
-      createOccupantGroundLabel
+      create3DOpeningMarker
     } = this.#styler;
     let elements = {};
     let object3ds = [];
@@ -4367,16 +4979,6 @@ var IndoorMap = class extends EventTarget {
         console.warn(`Cannot create ${feature2.id}: ${err.message}`);
       }
     }
-    this.#groundLabels.forEach((label) => {
-      const text = label.properties.name;
-      try {
-        const groundLabel = create3DGroundLabel(label, this.threeLayer);
-        object3ds.push(groundLabel);
-        this.#groundObjects.push(groundLabel);
-      } catch (error) {
-        console.log("error creating ground label for ", text);
-      }
-    });
     this.#mapDecorations.forEach((decoration) => {
       const { id, geometry, properties } = decoration;
       const geometryType = decoration?.geometry?.type;
@@ -4815,9 +5417,6 @@ var IndoorMap = class extends EventTarget {
           child.visible = this.showVenueObject && objectOpacity > 0.4;
         });
       });
-      this.#groundObjects.forEach((gLabel) => {
-        gLabel.bearing = currBearing;
-      });
     }
     this.#animationsToRun.forEach(({ callback }) => callback(this));
     TWEEN.update();