@mapvx/web-js 2.0.2-dev.1 → 2.1.0-dev.1

package/dist/umd/index.js

@@ -11242,7 +11242,7 @@ const extractSafariExtensionDetails = (func, filename) => {
 // replaced with the package version by scripts/inject-build-defines.js. The DSN
 // falls back to the public MapVX Sentry project DSN when none is injected at
 // build time — a DSN's public key is safe to ship in the client bundle.
-var sentry_SDK_VERSION =  true ? "2.0.2-dev.1" : 0;
+var sentry_SDK_VERSION =  true ? "2.1.0-dev.1" : 0;
 var DSN =  false ? 0 : "https://872f598f020e3cd73a0933b562d24c81@sentry.mapvx.app/5";
 
 /**
@@ -12764,6 +12764,60 @@ var RouteController = /*#__PURE__*/function () {
       } finally {
         _iterator.f();
       }
+      this.syncRouteCollision();
+    }
+
+    /**
+     * Recompute the GLB route-transparency collision path from all active routes and push it to the
+     * map. Every polyline point of every step is tagged with the floor its segment is drawn on (same
+     * derivation as the route line's `floor_key`), so a 3D building only fades when a route is visibly
+     * crossing it on the displayed floor. The map ignores this unless the 3D scene is active, so it is
+     * safe to call unconditionally.
+     */
+  }, {
+    key: "syncRouteCollision",
+    value: function syncRouteCollision() {
+      var points = [];
+      var _iterator2 = routeController_createForOfIteratorHelper(this.routes.values()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var instance = _step2.value;
+          var _iterator3 = routeController_createForOfIteratorHelper(instance.route.steps),
+            _step3;
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var step = _step3.value;
+              var floorKey = this.getFloorKeyForStep(step);
+              var _iterator4 = routeController_createForOfIteratorHelper(step.coordinates),
+                _step4;
+              try {
+                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                  var coord = _step4.value;
+                  points.push({
+                    lng: coord.lng,
+                    lat: coord.lat,
+                    floorKey: floorKey
+                  });
+                }
+              } catch (err) {
+                _iterator4.e(err);
+              } finally {
+                _iterator4.f();
+              }
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      this.mapvxMap.setRouteCollisionPath(points);
     }
 
     /**
@@ -12781,6 +12835,7 @@ var RouteController = /*#__PURE__*/function () {
       this.setSourceData(instance, instance.aheadId, route.steps);
       this.setLayerPaint(instance.aheadId, drawConfig);
       this.updateLayerFilter(instance.aheadId);
+      this.syncRouteCollision();
     }
 
     /**
@@ -13091,19 +13146,19 @@ var RouteController = /*#__PURE__*/function () {
   }, {
     key: "updateRouteLayers",
     value: function updateRouteLayers(floorId) {
-      var _iterator2 = routeController_createForOfIteratorHelper(this.routes.values()),
-        _step2;
+      var _iterator5 = routeController_createForOfIteratorHelper(this.routes.values()),
+        _step5;
       try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var instance = _step2.value;
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var instance = _step5.value;
           this.updateLayerFilter(instance.aheadId, floorId);
           this.updateLayerFilter(instance.behindId, floorId);
           this.updateLayerFilter(instance.currentId, floorId);
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator5.e(err);
       } finally {
-        _iterator2.f();
+        _iterator5.f();
       }
     }
 
@@ -13114,18 +13169,18 @@ var RouteController = /*#__PURE__*/function () {
   }, {
     key: "updateRouteMarkerVisibility",
     value: function updateRouteMarkerVisibility(floorId) {
-      var _iterator3 = routeController_createForOfIteratorHelper(this.routes.values()),
-        _step3;
+      var _iterator6 = routeController_createForOfIteratorHelper(this.routes.values()),
+        _step6;
       try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
           var _instance$routeMarker, _instance$routeMarker2, _instance$routeMarker3;
-          var instance = _step3.value;
+          var instance = _step6.value;
           ((_instance$routeMarker = instance.routeMarker) === null || _instance$routeMarker === void 0 ? void 0 : _instance$routeMarker.floorId) === floorId ? (_instance$routeMarker2 = instance.routeMarker) === null || _instance$routeMarker2 === void 0 ? void 0 : _instance$routeMarker2.show(this.map) : (_instance$routeMarker3 = instance.routeMarker) === null || _instance$routeMarker3 === void 0 ? void 0 : _instance$routeMarker3.hide();
         }
       } catch (err) {
-        _iterator3.e(err);
+        _iterator6.e(err);
       } finally {
-        _iterator3.f();
+        _iterator6.f();
       }
     }
   }, {
@@ -13209,6 +13264,7 @@ var RouteController = /*#__PURE__*/function () {
           return _this2.prepareForNextStep(time, instance);
         }
       };
+      this.syncRouteCollision();
     }
   }, {
     key: "clearRouteInstance",
@@ -13247,6 +13303,7 @@ var RouteController = /*#__PURE__*/function () {
         var remaining = _toConsumableArray(this.routes.keys());
         this.lastAddedRouteId = remaining.length > 0 ? remaining[remaining.length - 1] : undefined;
       }
+      this.syncRouteCollision();
     }
 
     /**
@@ -13255,21 +13312,22 @@ var RouteController = /*#__PURE__*/function () {
   }, {
     key: "removeAllRoutes",
     value: function removeAllRoutes() {
-      var _iterator4 = routeController_createForOfIteratorHelper(this.routes.values()),
-        _step4;
+      var _iterator7 = routeController_createForOfIteratorHelper(this.routes.values()),
+        _step7;
       try {
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-          var instance = _step4.value;
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var instance = _step7.value;
           this.clearRouteInstance(instance);
           this.removeSourcesAndLayersForRoute(instance);
         }
       } catch (err) {
-        _iterator4.e(err);
+        _iterator7.e(err);
       } finally {
-        _iterator4.f();
+        _iterator7.f();
       }
       this.routes.clear();
       this.lastAddedRouteId = undefined;
+      this.syncRouteCollision();
     }
 
     /**
@@ -13518,6 +13576,7 @@ var RouteController = /*#__PURE__*/function () {
           instance.stepAnimationStatus = "WAITING";
         }
       };
+      this.syncRouteCollision();
     }
 
     /**
@@ -17944,6 +18003,44 @@ function opacityForZoom(cfg, zoom) {
   return zoom >= cfg.zoom ? cfg.opacity : 1;
 }
 
+/**
+ * Resolves the effective route-based transparency for a placement, applying precedence:
+ * placement > asset > global. Returns `undefined` when none is configured, which disables
+ * route transparency for that model (a route crossing it leaves its opacity unchanged).
+ */
+function resolveRouteTransparency(models, asset, placement) {
+  var _ref2, _placement$routeTrans;
+  return (_ref2 = (_placement$routeTrans = placement.routeTransparency) !== null && _placement$routeTrans !== void 0 ? _placement$routeTrans : asset === null || asset === void 0 ? void 0 : asset.routeTransparency) !== null && _ref2 !== void 0 ? _ref2 : models.routeTransparency;
+}
+
+/**
+ * Axis-aligned footprint of a model in its own local x/z plane (metres), used for cheap
+ * point-in-building collision tests. Height (y) is ignored: a route point on the floor should
+ * match regardless of the model's vertical extent.
+ * @internal
+ */
+
+/**
+ * Whether a point already expressed in the model's local space falls within its x/z footprint.
+ * @internal
+ */
+function pointInFootprint(footprint, localX, localZ) {
+  return localX >= footprint.minX && localX <= footprint.maxX && localZ >= footprint.minZ && localZ <= footprint.maxZ;
+}
+
+/**
+ * Effective opacity for a placed model: the more transparent of its zoom-based value and, when a
+ * route currently crosses it, its route-based value. Route transparency only participates when a
+ * {@link RouteTransparencyConfig} is configured (`routeCfg` present) and the model is currently
+ * crossed by a route (`routeAffected`).
+ * @internal
+ */
+function effectiveModelOpacity(zoomCfg, routeCfg, zoom, routeAffected) {
+  var zoomOpacity = opacityForZoom(zoomCfg, zoom);
+  var routeOpacity = routeAffected && routeCfg ? routeCfg.opacity : 1;
+  return Math.min(zoomOpacity, routeOpacity);
+}
+
 /**
  * Whether a GLB placement should be visible for the given floor key.
  */
@@ -18415,6 +18512,13 @@ var Scene3DController = /*#__PURE__*/function () {
     scene3DController_defineProperty(this, "scene3DGlbLightCount", 0);
     /** Container group holding all placed GLB pivots; rebuilt on each floor change. */
     scene3DController_defineProperty(this, "scene3DModelsGroup", undefined);
+    /**
+     * Route points currently used for GLB route-transparency collision, tagged with the floor on
+     * which each point's route segment is visible. Stored as coordinates (not pivot references) so
+     * they survive `placeScene3DModels` rebuilds on floor change. Only points matching the current
+     * floor participate, so a model only fades when a route is visibly crossing it on that floor.
+     */
+    scene3DController_defineProperty(this, "scene3DRouteCollisionPoints", []);
     scene3DController_defineProperty(this, "spriteIconMapping", {});
     scene3DController_defineProperty(this, "spriteAtlasImage", new Image());
     this.map = map;
@@ -18497,7 +18601,21 @@ var Scene3DController = /*#__PURE__*/function () {
   }, {
     key: "onZoom",
     value: function onZoom() {
-      this.applyModelZoomOpacity();
+      this.applyModelOpacity();
+    }
+
+    /**
+     * Sets the route path used for GLB route-transparency collision and re-evaluates which models a
+     * route currently crosses. Points are tagged with the floor on which their route segment is
+     * visible; only points on the current floor participate, so a model never fades unless a route is
+     * visibly crossing it on the displayed floor. Pass an empty array to clear.
+     */
+  }, {
+    key: "setRouteCollisionPath",
+    value: function setRouteCollisionPath(points) {
+      this.scene3DRouteCollisionPoints = points;
+      this.recomputeRouteAffectedModels();
+      this.applyModelOpacity();
     }
 
     /** Rebuilds the deck overlay and GLB placements for the given floor. */
@@ -18788,6 +18906,22 @@ var Scene3DController = /*#__PURE__*/function () {
 
             // Stash the resolved zoom-transparency config so it can be re-applied on every zoom change.
             pivot.userData.zoomTransparency = resolveZoomTransparency(models, asset, placement);
+
+            // Stash route-transparency config (may be undefined => feature off for this model) so a
+            // route crossing this model can fade it independently of zoom.
+            pivot.userData.routeTransparency = resolveRouteTransparency(models, asset, placement);
+
+            // Precompute the model footprint in the pivot's local x/z frame while `model` has no parent
+            // (its world matrix equals its local matrix), for cheap point-in-building collision tests.
+            // After `pivot.add(model)` the world matrix would fold in the pivot transform, giving a loose
+            // world-axis box instead; `pivot.worldToLocal` at test time undoes the pivot transform.
+            var localBox = new three.Box3().setFromObject(model);
+            pivot.userData.footprint = {
+              minX: localBox.min.x,
+              maxX: localBox.max.x,
+              minZ: localBox.min.z,
+              maxZ: localBox.max.z
+            };
             pivot.add(model);
             modelsGroup.add(pivot);
           },
@@ -18803,42 +18937,114 @@ var Scene3DController = /*#__PURE__*/function () {
       }
       this.scene3DModelsGroup = modelsGroup;
       this.scene3DGlbScene.add(modelsGroup);
-      this.applyModelZoomOpacity();
+      // Recompute route collision against the freshly rebuilt pivots (footprints/floor changed),
+      // then apply the combined opacity.
+      this.recomputeRouteAffectedModels();
+      this.applyModelOpacity();
       this.map.triggerRepaint();
     }
 
     /**
-     * Applies zoom-based transparency to placed GLB models, using each placement's resolved
-     * {@link ZoomTransparencyConfig} stored in `pivot.userData.zoomTransparency`. Hard threshold:
-     * fully opaque below the configured zoom, configured opacity at/above it. Only triggers a
+     * Recomputes `pivot.userData.routeAffected` for every placed model by testing the current-floor
+     * route collision points against each model's precomputed footprint. Cheap point-in-box tests in
+     * the pivot's local x/z frame; runs only when the route path or the placed models change, never
+     * per zoom frame.
+     */
+  }, {
+    key: "recomputeRouteAffectedModels",
+    value: function recomputeRouteAffectedModels() {
+      var _this$threeMod4,
+        _this3 = this;
+      var three = (_this$threeMod4 = this.threeMod) === null || _this$threeMod4 === void 0 ? void 0 : _this$threeMod4.THREE;
+      var modelsGroup = this.scene3DModelsGroup;
+      if (!three || !modelsGroup) {
+        return;
+      }
+      var points = this.scene3DRouteCollisionPoints.filter(function (p) {
+        return p.floorKey === _this3.currentFloor;
+      });
+
+      // Convert each route point into the models group's local frame (metres relative to
+      // initialCenter), exactly as placements are positioned in `placeScene3DModels`. The group's
+      // own transform (globalOffset) is applied via `localToWorld` at test time, so route points and
+      // model pivots share one frame regardless of the collective offset.
+      var refMercator = maplibre_gl.MercatorCoordinate.fromLngLat(this.initialCenter, 0);
+      var meterScale = refMercator.meterInMercatorCoordinateUnits();
+      var groupLocalPoints = points.map(function (p) {
+        var target = maplibre_gl.MercatorCoordinate.fromLngLat([p.lng, p.lat], 0);
+        var x = (target.x - refMercator.x) / meterScale;
+        var z = (target.y - refMercator.y) / meterScale;
+        return new three.Vector3(x, 0, z);
+      });
+      modelsGroup.updateMatrixWorld(true);
+      var local = new three.Vector3();
+      var _iterator3 = scene3DController_createForOfIteratorHelper(modelsGroup.children),
+        _step3;
+      try {
+        var _loop2 = function _loop2() {
+          var pivot = _step3.value;
+          var routeCfg = pivot.userData.routeTransparency;
+          var footprint = pivot.userData.footprint;
+          // Only models with a route-transparency config participate (feature activation gate).
+          if (!routeCfg || !footprint || groupLocalPoints.length === 0) {
+            pivot.userData.routeAffected = false;
+            return 1; // continue
+          }
+          pivot.userData.routeAffected = groupLocalPoints.some(function (gp) {
+            // group-local -> world (applies globalOffset) -> pivot-local (undoes position/rotation/
+            // scale), then test its x/z against the footprint. y is ignored (floor-level footprint).
+            local.copy(gp);
+            modelsGroup.localToWorld(local);
+            pivot.worldToLocal(local);
+            return pointInFootprint(footprint, local.x, local.z);
+          });
+        };
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          if (_loop2()) continue;
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+
+    /**
+     * Applies transparency to placed GLB models, combining zoom-based transparency
+     * ({@link ZoomTransparencyConfig}, a hard threshold: fully opaque below the configured zoom,
+     * configured opacity at/above it) with route-based transparency
+     * ({@link RouteTransparencyConfig}) for models a route currently crosses
+     * (`pivot.userData.routeAffected`). The more transparent of the two wins. Only triggers a
      * repaint when at least one material actually changed.
      */
   }, {
-    key: "applyModelZoomOpacity",
-    value: function applyModelZoomOpacity() {
+    key: "applyModelOpacity",
+    value: function applyModelOpacity() {
       if (!this.scene3DModelsGroup) {
         return;
       }
       var zoom = this.map.getZoom();
       var changed = false;
-      var _iterator3 = scene3DController_createForOfIteratorHelper(this.scene3DModelsGroup.children),
-        _step3;
+      var _iterator4 = scene3DController_createForOfIteratorHelper(this.scene3DModelsGroup.children),
+        _step4;
       try {
-        var _loop2 = function _loop2() {
-          var pivot = _step3.value;
-          var cfg = pivot.userData.zoomTransparency;
-          var opacity = opacityForZoom(cfg, zoom);
+        var _loop3 = function _loop3() {
+          var pivot = _step4.value;
+          var zoomCfg = pivot.userData.zoomTransparency;
+          var routeCfg = pivot.userData.routeTransparency;
+          var routeAffected = pivot.userData.routeAffected === true;
+          var opacity = effectiveModelOpacity(zoomCfg, routeCfg, zoom, routeAffected);
           pivot.traverse(function (obj) {
             var mesh = obj;
             if (!mesh.isMesh) {
               return;
             }
             var materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
-            var _iterator4 = scene3DController_createForOfIteratorHelper(materials),
-              _step4;
+            var _iterator5 = scene3DController_createForOfIteratorHelper(materials),
+              _step5;
             try {
-              for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-                var material = _step4.value;
+              for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                var material = _step5.value;
                 if (material.opacity !== opacity) {
                   material.transparent = opacity < 1;
                   material.opacity = opacity;
@@ -18848,19 +19054,19 @@ var Scene3DController = /*#__PURE__*/function () {
                 }
               }
             } catch (err) {
-              _iterator4.e(err);
+              _iterator5.e(err);
             } finally {
-              _iterator4.f();
+              _iterator5.f();
             }
           });
         };
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          _loop2();
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          _loop3();
         }
       } catch (err) {
-        _iterator3.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator3.f();
+        _iterator4.f();
       }
       if (changed) {
         this.map.triggerRepaint();
@@ -18942,7 +19148,7 @@ var Scene3DController = /*#__PURE__*/function () {
       var _layerConfig$binaryDa2,
         _layerConfig$minZoom,
         _layerConfig$maxZoom,
-        _this3 = this;
+        _this4 = this;
       var useSdf = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
       var deck = this.deckMod;
       if (!deck) return null;
@@ -18957,7 +19163,7 @@ var Scene3DController = /*#__PURE__*/function () {
           // Use area_name and poi Point features — unique per tile, no duplicates.
           // If a logo-{name} image exists in the sprite, the icon takes priority over the text label.
           var textData = buildLabelData(props.data || [], floorKey, function (imageId) {
-            return _this3.map.hasImage(imageId);
+            return _this4.map.hasImage(imageId);
           }, (_layerConfig$defaultH2 = layerConfig.defaultHeight) !== null && _layerConfig$defaultH2 !== void 0 ? _layerConfig$defaultH2 : 5);
           if (!textData.length) return null;
           return new deck.TextLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, props), {}, {
@@ -18996,7 +19202,7 @@ var Scene3DController = /*#__PURE__*/function () {
       var _layerConfig$binaryDa3,
         _layerConfig$minZoom2,
         _layerConfig$maxZoom2,
-        _this4 = this;
+        _this5 = this;
       var deck = this.deckMod;
       if (!deck || !this.spriteIconMapping || !this.spriteAtlasImage) return null;
       return new deck.MVTLayer({
@@ -19012,8 +19218,8 @@ var Scene3DController = /*#__PURE__*/function () {
           return new deck.IconLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, props), {}, {
             id: "".concat(props.id, "-poi-icons"),
             data: iconData,
-            iconAtlas: _this4.spriteAtlasImage,
-            iconMapping: _this4.spriteIconMapping,
+            iconAtlas: _this5.spriteAtlasImage,
+            iconMapping: _this5.spriteIconMapping,
             getIcon: function getIcon(d) {
               return d.icon;
             },
@@ -19038,7 +19244,7 @@ var Scene3DController = /*#__PURE__*/function () {
       var _layerConfig$binaryDa4,
         _layerConfig$minZoom3,
         _layerConfig$maxZoom3,
-        _this5 = this;
+        _this6 = this;
       var deck = this.deckMod;
       if (!deck || !this.spriteIconMapping || !this.spriteAtlasImage) return null;
       return new deck.MVTLayer({
@@ -19049,13 +19255,13 @@ var Scene3DController = /*#__PURE__*/function () {
         maxZoom: (_layerConfig$maxZoom3 = layerConfig.maxZoom) !== null && _layerConfig$maxZoom3 !== void 0 ? _layerConfig$maxZoom3 : 24,
         renderSubLayers: function renderSubLayers(props) {
           var _layerConfig$defaultH4, _layerConfig$sizeUnit2, _layerConfig$sizeScal2, _layerConfig$billboar2;
-          var logoData = buildStoreLogoData(props.data || [], floorKey, _this5.spriteIconMapping, (_layerConfig$defaultH4 = layerConfig.defaultHeight) !== null && _layerConfig$defaultH4 !== void 0 ? _layerConfig$defaultH4 : 5);
+          var logoData = buildStoreLogoData(props.data || [], floorKey, _this6.spriteIconMapping, (_layerConfig$defaultH4 = layerConfig.defaultHeight) !== null && _layerConfig$defaultH4 !== void 0 ? _layerConfig$defaultH4 : 5);
           if (!logoData.length) return null;
           return new deck.IconLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, props), {}, {
             id: "".concat(props.id, "-store-logos"),
             data: logoData,
-            iconAtlas: _this5.spriteAtlasImage,
-            iconMapping: _this5.spriteIconMapping,
+            iconAtlas: _this6.spriteAtlasImage,
+            iconMapping: _this6.spriteIconMapping,
             getIcon: function getIcon(d) {
               return d.icon;
             },
@@ -19067,7 +19273,7 @@ var Scene3DController = /*#__PURE__*/function () {
             },
             getSize: function getSize(d) {
               var _layerConfig$logoScal;
-              return computeStoreLogoSize(_this5.spriteIconMapping, d.icon, (_layerConfig$logoScal = layerConfig.logoScale) !== null && _layerConfig$logoScal !== void 0 ? _layerConfig$logoScal : {});
+              return computeStoreLogoSize(_this6.spriteIconMapping, d.icon, (_layerConfig$logoScal = layerConfig.logoScale) !== null && _layerConfig$logoScal !== void 0 ? _layerConfig$logoScal : {});
             },
             sizeUnits: (_layerConfig$sizeUnit2 = layerConfig.sizeUnits) !== null && _layerConfig$sizeUnit2 !== void 0 ? _layerConfig$sizeUnit2 : "meters",
             sizeScale: (_layerConfig$sizeScal2 = layerConfig.sizeScale) !== null && _layerConfig$sizeScal2 !== void 0 ? _layerConfig$sizeScal2 : 1,
@@ -19112,19 +19318,19 @@ var Scene3DController = /*#__PURE__*/function () {
     key: "hideLayers",
     value: function hideLayers(layersIds) {
       if (!layersIds) return;
-      var _iterator5 = scene3DController_createForOfIteratorHelper(layersIds),
-        _step5;
+      var _iterator6 = scene3DController_createForOfIteratorHelper(layersIds),
+        _step6;
       try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var layerId = _step5.value;
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var layerId = _step6.value;
           var layer = this.map.getLayer(layerId);
           if (!layer) continue;
           this.map.setLayoutProperty(layer.id, "visibility", "none");
         }
       } catch (err) {
-        _iterator5.e(err);
+        _iterator6.e(err);
       } finally {
-        _iterator5.f();
+        _iterator6.f();
       }
     }
   }]);
@@ -19952,6 +20158,24 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       return (_this$currentFloor = this.currentFloor) !== null && _this$currentFloor !== void 0 ? _this$currentFloor : "";
     }
 
+    /**
+     * Sets the route path used for GLB route-transparency collision, so 3D models a route passes
+     * through fade and reveal the floor plan underneath. Called by {@link RouteController} whenever
+     * the set of drawn routes changes. Points are tagged with the floor their segment is drawn on;
+     * only points on the displayed floor participate. Pass an empty array to clear.
+     *
+     * No-op unless the 3D scene is active.
+     */
+  }, {
+    key: "setRouteCollisionPath",
+    value: function setRouteCollisionPath(points) {
+      var _this$scene3D;
+      if (!this.is3DSceneActive()) {
+        return;
+      }
+      (_this$scene3D = this.scene3D) === null || _this$scene3D === void 0 || _this$scene3D.setRouteCollisionPath(points);
+    }
+
     /**
      * Performs changes when parent place is updated
      * @param place new parent place
@@ -19966,7 +20190,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         _this$innerFloors$fin,
         _this$innerFloors$fin2,
         _this$innerFloors$,
-        _this$scene3D,
+        _this$scene3D2,
         _this9 = this;
       var updateStyle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
       var onStyleReady = arguments.length > 2 ? arguments[2] : undefined;
@@ -19981,7 +20205,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       if (place) {
         this.subPlacesLoad(place.mapvxId);
       }
-      (_this$scene3D = this.scene3D) === null || _this$scene3D === void 0 || _this$scene3D.onFloorChange(this.currentFloor);
+      (_this$scene3D2 = this.scene3D) === null || _this$scene3D2 === void 0 || _this$scene3D2.onFloorChange(this.currentFloor);
       if (updateStyle) {
         this.repository.fetchAndParseMapStyle(place === null || place === void 0 ? void 0 : place.mapvxId).then(function (style) {
           var useServiceWorkerCaching = _this9.tileCacheConfig.enabled && _this9.tileCacheConfig.persistToServiceWorker;
@@ -20003,7 +20227,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "updatePlaceAndFloor",
     value: function updatePlaceAndFloor(parentPlaceId, floorId) {
-      var _place$innerFloors$so2, _ref2, _ref3, _this$innerFloors$fin3, _this$innerFloors$2, _this$scene3D2;
+      var _place$innerFloors$so2, _ref2, _ref3, _this$innerFloors$fin3, _this$innerFloors$2, _this$scene3D3;
       var place = this.potentialParentPlaces.find(function (place) {
         return place.mapvxId === parentPlaceId;
       });
@@ -20015,7 +20239,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       this.currentFloor = (_ref2 = (_ref3 = floorId !== null && floorId !== void 0 ? floorId : (_this$innerFloors$fin3 = this.innerFloors.find(function (floor) {
         return floor.defaultFloor;
       })) === null || _this$innerFloors$fin3 === void 0 ? void 0 : _this$innerFloors$fin3.key) !== null && _ref3 !== void 0 ? _ref3 : (_this$innerFloors$2 = this.innerFloors[0]) === null || _this$innerFloors$2 === void 0 ? void 0 : _this$innerFloors$2.key) !== null && _ref2 !== void 0 ? _ref2 : "";
-      (_this$scene3D2 = this.scene3D) === null || _this$scene3D2 === void 0 || _this$scene3D2.onFloorChange(this.currentFloor);
+      (_this$scene3D3 = this.scene3D) === null || _this$scene3D3 === void 0 || _this$scene3D3.onFloorChange(this.currentFloor);
     }
   }, {
     key: "updateParentPlaceAndFloor",
@@ -20075,14 +20299,14 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "whenStyleUpdates",
     value: function whenStyleUpdates(newStyle) {
-      var _this$scene3D3;
+      var _this$scene3D4;
       if (newStyle) {
         this.setBaseFilters(newStyle);
       }
       this.routeController.addSourcesAndLayers();
       this.refreshCircles();
       this.filterByFloorKey(this.currentFloor);
-      (_this$scene3D3 = this.scene3D) === null || _this$scene3D3 === void 0 || _this$scene3D3.refreshOverlay(this.currentFloor);
+      (_this$scene3D4 = this.scene3D) === null || _this$scene3D4 === void 0 || _this$scene3D4.refreshOverlay(this.currentFloor);
     }
   }, {
     key: "addMarker",
@@ -20949,9 +21173,9 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
     key: "updateFloor",
     value: function updateFloor(floorId, options) {
       try {
-        var _this$scene3D4, _this$onFloorChange2, _options$onComplete6;
+        var _this$scene3D5, _this$onFloorChange2, _options$onComplete6;
         this.filterByFloorKey(floorId);
-        (_this$scene3D4 = this.scene3D) === null || _this$scene3D4 === void 0 || _this$scene3D4.onFloorChange(this.currentFloor);
+        (_this$scene3D5 = this.scene3D) === null || _this$scene3D5 === void 0 || _this$scene3D5.onFloorChange(this.currentFloor);
         (_this$onFloorChange2 = this.onFloorChange) === null || _this$onFloorChange2 === void 0 || _this$onFloorChange2.call(this, floorId);
         this.logEvent("updateFloor", {
           floorId: floorId