leaflet-city-mapper 0.0.4 → 0.0.6

package/src/camera/initializeCameraMap.js

@@ -1,4 +1,6 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { cameraMaps } from '../weakmaps/cameraMaps.js';
+import { cameraReadyByMap } from '../weakmaps/cameraReadyByMap.js';
+
 
 import { mapSetPitchAndBearing } from './mapSetPitchAndBearing.js';
 
@@ -10,7 +12,7 @@ import { loadCameraControls } from '../controls/loadCameraControls.js';
 import { noOperation } from '../utils/noOperation.js';
 
 export function initializeCameraMap() {
-  cameraByMap.set(this, /* alloc */ {});
+  cameraMaps.add(this);
   if (!document.getElementById('leaflet-camera-zoom-style')) {
     const style = document.createElement('style');
     style.id = 'leaflet-camera-zoom-style';
@@ -24,7 +26,7 @@ export function initializeCameraMap() {
   this.once('unload', cleanupCameraMap, this);
   this.whenReady(cameraMapReady, this);
   if (this.options.rotate || this.options.trackContainerMutation) {
-    cameraByMap.get(this).cameraReady = loadCameraControls(this);
-    cameraByMap.get(this).cameraReady.catch(noOperation);
+    cameraReadyByMap.set(this, loadCameraControls(this));
+    cameraReadyByMap.get(this).catch(noOperation);
   }
 }

package/src/camera/mapCamera.js

@@ -9,7 +9,7 @@ import { tooltipPosition } from '../globals/tooltipPosition.js';
 import { tiledBounds } from '../globals/tiledBounds.js';
 import { gridEvents } from '../globals/gridEvents.js';
 
-import { initNativeGPU } from '../core/initNativeGPU.js';
+import { initNativeGPU } from '../native/initNativeGPU.js';
 
 import { mapLayerPointToContainerPoint } from './mapLayerPointToContainerPoint.js';
 import { mapContainerPointToLayerPoint } from './mapContainerPointToLayerPoint.js';

package/src/camera/mapContainerPointToLayerPoint.js

@@ -1,8 +1,8 @@
 import { mapMethods } from '../globals/mapMethods.js';
 
 
-import { animationPoint } from './animationPoint.js';
-import { project } from './project.js';
+import { animationPoint } from '../projections/transformZoomAnimationPoint.js';
+import { project } from '../projections/projectCameraPoint.js';
 
 export function mapContainerPointToLayerPoint(point) {
   return mapMethods.value.containerPointToLayerPoint.call(this, animationPoint(this, project(this, point, true), true));

package/src/camera/mapGetBearing.js

@@ -1,4 +1,5 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { cameraBearingByMap } from '../weakmaps/cameraBearingByMap.js';
 
 
-export function mapGetBearing(map) { return cameraByMap.get(map)?._cameraBearing ?? 0; }
+
+export function mapGetBearing(map) { return cameraBearingByMap.get(map) ?? 0; }

package/src/camera/mapGetBounds.js

@@ -4,8 +4,8 @@ import { mapMethods } from '../globals/mapMethods.js';
 import { mapGetPitch } from './mapGetPitch.js';
 import { mapGetBearing } from './mapGetBearing.js';
 
-import { groundBounds } from './groundBounds.js';
-import { animationPoint } from './animationPoint.js';
+import { groundBounds } from '../projections/groundBounds.js';
+import { animationPoint } from '../projections/transformZoomAnimationPoint.js';
 
 export function mapGetBounds() {
   if (!mapGetPitch(this) && !mapGetBearing(this)) return mapMethods.value.getBounds.call(this);

package/src/camera/mapGetBoundsZoom.js

@@ -6,8 +6,8 @@ import { mapGetPitch } from './mapGetPitch.js';
 import { mapGetBearing } from './mapGetBearing.js';
 
 import { fitCameraBounds } from './fitCameraBounds.js';
-import { pointOf } from './pointOf.js';
-import { groundBounds } from './groundBounds.js';
+import { pointOf } from '../projections/toPoint.js';
+import { groundBounds } from '../projections/groundBounds.js';
 
 export function mapGetBoundsZoom(bounds, inside, padding) {
   if (!mapGetPitch(this) && !mapGetBearing(this)) return mapMethods.value.getBoundsZoom.call(this, bounds, inside, padding);

package/src/camera/mapGetPitch.js

@@ -1,4 +1,5 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { cameraPitchByMap } from '../weakmaps/cameraPitchByMap.js';
 
 
-export function mapGetPitch(map) { return cameraByMap.get(map)?._cameraPitch ?? 0; }
+
+export function mapGetPitch(map) { return cameraPitchByMap.get(map) ?? 0; }

package/src/camera/mapLayerPointToContainerPoint.js

@@ -1,7 +1,7 @@
 import { mapMethods } from '../globals/mapMethods.js';
 
-import { project } from './project.js';
-import { animationPoint } from './animationPoint.js';
+import { project } from '../projections/projectCameraPoint.js';
+import { animationPoint } from '../projections/transformZoomAnimationPoint.js';
 
 export function mapLayerPointToContainerPoint(point) {
   return project(this, animationPoint(this, mapMethods.value.layerPointToContainerPoint.call(this, point)));

package/src/camera/mapLimitCenter.js

@@ -4,7 +4,7 @@ import { mapMethods } from '../globals/mapMethods.js';
 import { mapGetPitch } from './mapGetPitch.js';
 import { mapGetBearing } from './mapGetBearing.js';
 
-import { groundBounds } from './groundBounds.js';
+import { groundBounds } from '../projections/groundBounds.js';
 
 export function mapLimitCenter(center, zoom, bounds) {
   if (!bounds || !this._loaded || !mapGetPitch(this) && !mapGetBearing(this)) {

package/src/camera/mapLimitOffset.js

@@ -3,7 +3,7 @@ import { mapMethods } from '../globals/mapMethods.js';
 import { mapGetPitch } from './mapGetPitch.js';
 import { mapGetBearing } from './mapGetBearing.js';
 
-import { project } from './project.js';
+import { project } from '../projections/projectCameraPoint.js';
 
 export function mapLimitOffset(offset, bounds) {
   if (!bounds || !mapGetPitch(this) && !mapGetBearing(this)) return mapMethods.value._limitOffset.call(this, offset, bounds);

package/src/camera/mapPanBy.js

@@ -1,7 +1,7 @@
 import { mapMethods } from '../globals/mapMethods.js';
 
-import { project } from './project.js';
-import { pointOf } from './pointOf.js';
+import { project } from '../projections/projectCameraPoint.js';
+import { pointOf } from '../projections/toPoint.js';
 
 export function mapPanBy(offset, options) {
   const half = this.getSize().divideBy(2);

package/src/camera/mapPanInside.js

@@ -4,7 +4,7 @@ import { cameraZeroPadding } from '../globals/cameraZeroPadding.js';
 import { mapGetPitch } from './mapGetPitch.js';
 import { mapGetBearing } from './mapGetBearing.js';
 
-import { pointOf } from './pointOf.js';
+import { pointOf } from '../projections/toPoint.js';
 
 export function mapPanInside(latlng, options = /* alloc */ {}) {
   if (!mapGetPitch(this) && !mapGetBearing(this)) return mapMethods.value.panInside.call(this, latlng, options);

package/src/camera/mapResetNorthPitch.js

@@ -1,4 +1,4 @@
 import { cameraAnimatedOptions } from '../globals/cameraAnimatedOptions.js';
-import { mapAnimateCamera } from './mapAnimateCamera.js';
+import { mapAnimateCamera } from '../animations/mapAnimateCamera.js';
 
 export function mapResetNorthPitch(map, options = cameraAnimatedOptions) { return mapAnimateCamera(map, 0, 0, options); }

package/src/camera/mapSetBearing.js

@@ -1,3 +1,3 @@
-import { mapAnimateCamera } from './mapAnimateCamera.js';
+import { mapAnimateCamera } from '../animations/mapAnimateCamera.js';
 import { mapGetPitch } from './mapGetPitch.js';
 export function mapSetBearing(map, bearing, options) { return mapAnimateCamera(map, mapGetPitch(map), bearing, options); }

package/src/camera/mapSetPitch.js

@@ -1,3 +1,3 @@
-import { mapAnimateCamera } from './mapAnimateCamera.js';
+import { mapAnimateCamera } from '../animations/mapAnimateCamera.js';
 import { mapGetBearing } from './mapGetBearing.js';
 export function mapSetPitch(map, pitch, options) { return mapAnimateCamera(map, pitch, mapGetBearing(map), options); }

package/src/camera/mapSetPitchAndBearing.js

@@ -1,4 +1,6 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { cameraBearingByMap } from '../weakmaps/cameraBearingByMap.js';
+import { cameraPitchByMap } from '../weakmaps/cameraPitchByMap.js';
+
 
 import { mapGetPitch } from './mapGetPitch.js';
 import { mapGetBearing } from './mapGetBearing.js';
@@ -11,8 +13,8 @@ export function mapSetPitchAndBearing(map, pitch, bearing) {
     throw /* alloc */ new TypeError('maxPitch must be between 0 and 180 degrees');
   }
   const previousPitch = mapGetPitch(map), previousBearing = mapGetBearing(map);
-  cameraByMap.get(map)._cameraPitch = Math.max(0, Math.min(map.options.maxPitch, pitch));
-  cameraByMap.get(map)._cameraBearing = ((bearing % 360) + 360) % 360;
+  cameraPitchByMap.set(map, Math.max(0, Math.min(map.options.maxPitch, pitch)));
+  cameraBearingByMap.set(map, ((bearing % 360) + 360) % 360);
   if (map._loaded) {
     updateSky.call(map);
     if (previousBearing !== mapGetBearing(map)) map.fire('rotate', /* alloc */ { bearing: mapGetBearing(map) });

package/src/{rendering → camera}/updateMapCamera.js

@@ -1,35 +1,39 @@
+import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
+import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+
+
 import { radians } from '../globals/radians.js';
 import { cameraFov } from '../globals/cameraFov.js';
 import { earthCirc } from '../globals/earthCirc.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { mapElevationOf } from '../terrain/mapElevationOf.js';
 import { mapMethods } from '../globals/mapMethods.js';
-import { walkByMap } from '../globals/walkByMap.js';
-import { mapGetPitch } from '../camera/mapGetPitch.js';
-import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { walkByMap } from '../weakmaps/walkByMap.js';
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
 
-import { updateCamera } from "../scene/updateCamera.js";
-import { getElevation } from "../terrain/getElevation.js";
+import { updateCamera } from "./updateSceneCamera.js";
 
-import { animationPoint } from '../camera/animationPoint.js';
+import { animationPoint } from '../projections/transformZoomAnimationPoint.js';
 
-export function updateMapCamera(backend, size) {
-  const map = backend._map;
+export function updateMapCamera(layer, size) {
+  const map = layer._map;
   // Match the map's perspective, including the intermediate view of an animated zoom.
-  const zoom = cameraByMap.get(map)._cameraView?.zoom ?? map.getZoom();
-  const pixelsPerMeter = map.options.crs.scale(zoom) / (earthCirc * Math.cos(sceneByLayer.get(backend)._sceneOrigin.lat * radians));
+  const zoom = cameraViewByMap.get(map)?.zoom ?? map.getZoom();
+  const pixelsPerMeter = map.options.crs.scale(zoom) /
+    (earthCirc * Math.cos(sceneOriginByLayer.get(layer).lat * radians));
   const origin = animationPoint(map, mapMethods.value.layerPointToContainerPoint.call(map,
-    map.project(sceneByLayer.get(backend)._sceneOrigin).subtract(map.getPixelOrigin())));
+    map.project(sceneOriginByLayer.get(layer)).subtract(map.getPixelOrigin())));
   const distance = size.y * 1.5 / pixelsPerMeter;
   const targetX = (size.x / 2 - origin.x) / pixelsPerMeter;
   // CSS zoom keeps the logical view's ground plane until zoomend.
   const walker = walkByMap.get(map)?.control?._walk;
-  const targetY = ((cameraByMap.get(map)._terrain3D ? getElevation(cameraByMap.get(map)._terrain3D, map.getCenter()): undefined) ?? 0) +
+  const targetY = (mapElevationOf(map, map.getCenter()) ?? 0) +
     (walker?.saved ? walker.state.height : 0);
   const targetZ = (size.y / 2 - origin.y) / pixelsPerMeter;
   const pitch = mapGetPitch(map) * radians;
   const bearing = mapGetBearing(map) * radians;
-  const camera = sceneByLayer.get(backend).camera;
+  const camera = cameraByLayer.get(layer);
   camera.fov = cameraFov;
   camera.aspect = size.x / size.y;
   camera.near = Math.max(0.1, distance / 10000);

package/src/{scene/updateCamera.js → camera/updateSceneCamera.js}

@@ -9,7 +9,7 @@ export function updateCamera(camera) {
   camera.projectionTransform ||= /* alloc */ new DOMMatrix();
   camera.projectionViewTransform ||= /* alloc */ new DOMMatrix();
   const { position, target, up, x, y, z, viewMatrix, projectionMatrix, projectionViewMatrix } = camera;
-  let i, value;
+  let value;
   z[0] = position[0] - target[0], z[1] = position[1] - target[1], z[2] = position[2] - target[2];
   const zLength = Math.hypot(z[0], z[1], z[2]) || 1;
   z[0] /= zLength, z[1] /= zLength, z[2] /= zLength;

package/src/camera/updateSky.js

@@ -1,6 +1,7 @@
+import { pitchSkyByMap } from '../weakmaps/pitchSkyByMap.js';
+
 import { L } from '../globals/L.js';
 import { radians } from '../globals/radians.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
 
 import { mapGetPitch } from './mapGetPitch.js';
 
@@ -9,14 +10,14 @@ export function updateSky() {
   const height = this.getSize().y, pitch = mapGetPitch(this) * radians;
   const far = height * this.options.pitchMaxDistance, distance = height * 1.5;
   const top = height / 2 - far * Math.abs(Math.cos(pitch)) * distance / (distance + Math.sin(pitch) * far);
-  if (top > 0 && !cameraByMap.get(this)._pitchSky) {
-    cameraByMap.get(this)._pitchSky = L.DomUtil.create('div', 'leaflet-pitch-sky', this.getContainer());
-    cameraByMap.get(this)._pitchSky.setAttribute('aria-hidden', 'true');
-    cameraByMap.get(this)._pitchSky.style.cssText = 'position:absolute;inset:0 0 auto;height:0;z-index:0;pointer-events:none;background:var(--leaflet-sky-background,linear-gradient(#9ec5e8,#dfe9f0))';
+  if (top > 0 && !pitchSkyByMap.get(this)) {
+    pitchSkyByMap.set(this, L.DomUtil.create('div', 'leaflet-pitch-sky', this.getContainer()));
+    pitchSkyByMap.get(this).setAttribute('aria-hidden', 'true');
+    pitchSkyByMap.get(this).style.cssText = 'position:absolute;inset:0 0 auto;height:0;z-index:0;pointer-events:none;background:var(--leaflet-sky-background,linear-gradient(#9ec5e8,#dfe9f0))';
   }
-  if (cameraByMap.get(this)._pitchSky) {
-    cameraByMap.get(this)._pitchSky.style.inset = pitch > Math.PI / 2 ? 'auto 0 0' : '0 0 auto';
-    cameraByMap.get(this)._pitchSky.style.height = `${Math.max(0, Math.ceil(top))}px`;
-    cameraByMap.get(this)._pitchSky.style.display = top > 0 ? '' : 'none';
+  if (pitchSkyByMap.get(this)) {
+    pitchSkyByMap.get(this).style.inset = pitch > Math.PI / 2 ? 'auto 0 0' : '0 0 auto';
+    pitchSkyByMap.get(this).style.height = `${Math.max(0, Math.ceil(top))}px`;
+    pitchSkyByMap.get(this).style.display = top > 0 ? '' : 'none';
   }
 }

package/src/collision/collectIntersections.js

@@ -0,0 +1,16 @@
+import { CELL } from '../globals/CELL.js';
+import { horizontalRay } from './horizontalRay.js';
+
+export function collectIntersections(shape, x, y, z, seen, hits, end, iz) {
+  let ix, cell, triangle, distance;
+  for (ix = Math.floor(x / CELL); ix <= end; ix++) {
+    cell = shape.cells.get(`${ix},${iz}`);
+    if (!cell) continue;
+    for (triangle of cell) {
+      if (seen.has(triangle)) continue;
+      seen.add(triangle);
+      distance = horizontalRay(shape.tri, triangle, x, y, z, 1, 0);
+      if (distance > 1e-4) hits.push(distance);
+    }
+  }
+}

package/src/collision/collider.js

@@ -1,27 +1,39 @@
-import { colliders } from '../globals/colliders.js';
-import { transformTriangle } from './transformTriangle.js';
+import { colliders } from '../weakmaps/colliders.js';
 import { indexTriangle } from './indexTriangle.js';
+import { readTriangle } from './readTriangle.js';
+import { vertexCount } from './vertexCount.js';
 
 
 export function collider(mesh) {
   let c = colliders.get(mesh.geometry);
   if (c) return c;
-  const m = mesh.worldMatrix, { position: { data: p }, index, normal, uv } = mesh.geometry.attributes;
+  const m = mesh.worldMatrix, { position, index, normal, uv, instanceOffset } = mesh.geometry.attributes;
 
-  const count = index ? index.count : p.length / 3;
+  const vertices = vertexCount(position, index);
+  const count = vertices * (instanceOffset?.count ?? 1);
   const tri = /* alloc */ [];
   const nrm = /* alloc */ [];
   const cells = /* alloc */ new Map();
+  const a = /* alloc */ [0, 0, 0], b = /* alloc */ [0, 0, 0], d = /* alloc */ [0, 0, 0];
   const v = /* alloc */ [];
 
-  let i, first, j, ex, ey, ez, fx, fy, fz, nx, nz, ny, length, a, h, t;
+  let i, first, j, ex, ey, ez, fx, fy, fz, nx, nz, ny, length, h, t, maxX = -Infinity;
   for (i = 0; i < count; i += 3) {
-    first = index ? index.data[i] : i;
+    first = index ? index.data[i % vertices] : i % vertices;
     // Streetlight halos (uv.x <= 2, see scene/picking.js) are light, not matter.
     if (mesh.program.nightLight && uv && uv.data[first * 2] <= 2) {
       continue;
     }
-    transformTriangle(v, p, index, i, m);
+    readTriangle(mesh, i, a, b, d);
+    v[0] = m[0] * a[0] + m[4] * a[1] + m[8] * a[2] + m[12];
+    v[1] = m[1] * a[0] + m[5] * a[1] + m[9] * a[2] + m[13];
+    v[2] = m[2] * a[0] + m[6] * a[1] + m[10] * a[2] + m[14];
+    v[3] = m[0] * b[0] + m[4] * b[1] + m[8] * b[2] + m[12];
+    v[4] = m[1] * b[0] + m[5] * b[1] + m[9] * b[2] + m[13];
+    v[5] = m[2] * b[0] + m[6] * b[1] + m[10] * b[2] + m[14];
+    v[6] = m[0] * d[0] + m[4] * d[1] + m[8] * d[2] + m[12];
+    v[7] = m[1] * d[0] + m[5] * d[1] + m[9] * d[2] + m[13];
+    v[8] = m[2] * d[0] + m[6] * d[1] + m[10] * d[2] + m[14];
     ex = v[3] - v[0], ey = v[4] - v[1], ez = v[5] - v[2], fx = v[6] - v[0], fy = v[7] - v[1], fz = v[8] - v[2];
 
     nx = ey * fz - ez * fy, nz = ex * fy - ey * fx;
@@ -34,13 +46,15 @@ export function collider(mesh) {
 
     if (normal) {
       // The stored normal tells the outside, whatever the winding.
-      j = first * 3, a = normal.data;
-      if ((m[0] * a[j] + m[4] * a[j + 1] + m[8] * a[j + 2]) * nx + (m[2] * a[j] + m[6] * a[j + 1] + m[10] * a[j + 2]) * nz < 0) { nx = -nx; nz = -nz; }
+      j = first * 3;
+      if ((m[0] * normal.data[j] + m[4] * normal.data[j + 1] + m[8] * normal.data[j + 2]) * nx +
+        (m[2] * normal.data[j] + m[6] * normal.data[j + 1] + m[10] * normal.data[j + 2]) * nz < 0) { nx = -nx; nz = -nz; }
     }
 
     h = Math.hypot(nx, nz), t = nrm.length / 2;
 
     tri.push(...v);
+    maxX = Math.max(maxX, v[0], v[3], v[6]);
     nrm.push(nx / h, nz / h);
 
     indexTriangle(cells, v, t);
@@ -49,6 +63,7 @@ export function collider(mesh) {
     tri: Float32Array.from(tri),
     nrm: Float32Array.from(nrm),
     cells,
+    maxX,
     origin: /* alloc */ [m[12], m[13], m[14]]
   };
   colliders.set(mesh.geometry, c);

package/src/collision/countCrossings.js

@@ -0,0 +1,15 @@
+export function countCrossings(hits) {
+  let ix, j, distance;
+  for (ix = 1; ix < hits.length; ix++) {
+    distance = hits[ix];
+    j = ix - 1;
+    while (j >= 0 && hits[j] > distance) hits[j + 1] = hits[j--];
+    hits[j + 1] = distance;
+  }
+  let crossings = 0, previous = -Infinity;
+  for (distance of hits) {
+    if (distance - previous > 1e-4) crossings++;
+    previous = distance;
+  }
+  return crossings;
+}

package/src/collision/insideMesh.js

@@ -0,0 +1,33 @@
+import { CELL } from '../globals/CELL.js';
+
+import { collider } from './collider.js';
+import { computeBounds } from '../geometry/computeBounds.js';
+import { collectIntersections } from './collectIntersections.js';
+import { countCrossings } from './countCrossings.js';
+
+export function insideMesh(mesh, x, y, z, seen, intersections) {
+  const geometry = mesh.geometry;
+  if (!mesh.visible || !geometry?.attributes?.position?.data || mesh.program?.depthTest === false) return false;
+  if (!geometry.bounds) computeBounds(geometry);
+  const bounds = geometry.bounds;
+  const world = mesh.worldMatrix;
+  const center = bounds.center;
+  const cx = world[0] * center[0] + world[4] * center[1] + world[8] * center[2] + world[12];
+  const cy = world[1] * center[0] + world[5] * center[1] + world[9] * center[2] + world[13];
+  const cz = world[2] * center[0] + world[6] * center[1] + world[10] * center[2] + world[14];
+  const radius = bounds.radius * Math.max(
+    Math.hypot(world[0], world[1], world[2]),
+    Math.hypot(world[4], world[5], world[6]),
+    Math.hypot(world[8], world[9], world[10])
+  );
+  if (Math.hypot(cx - x, cy - y, cz - z) > radius) return false;
+  const shape = collider(mesh);
+  const end = Math.floor(shape.maxX / CELL);
+  if (x >= shape.maxX) return false;
+  const iz = Math.floor(z / CELL);
+  const hits = intersections;
+  hits.length = 0;
+  seen.clear();
+  collectIntersections(shape, x, y, z, seen, hits, end, iz);
+  return countCrossings(hits) % 2 === 1;
+}

package/src/collision/insideWalker.js

@@ -0,0 +1,46 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
+import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
+import { insideMesh } from './insideMesh.js';
+import { trafficCollision } from './trafficCollision.js';
+import { local } from '../projections/walkerLocalPosition.js';
+
+export function insideWalker(context) {
+  const { layer, local: localBuffer, hitData } = context;
+  const shared = sharedByLayer.get(layer);
+  if (!shared || !layersByLayer.get(shared)) return false;
+  updateWorldMatrix(sceneByLayer.get(layer));
+  const root = rootByLayer.get(layer);
+  const feet = local.call(context, localBuffer);
+  const x = root.position[0] + feet[0] * root.scale[0];
+  const y = root.position[1] + feet[1] * root.scale[1];
+  const z = root.position[2] + feet[2] * root.scale[2];
+  const layers = layersByLayer.get(shared);
+  let other, node, child, nodes;
+  for (other of layers) {
+    if (other === layer || kindByLayer.get(other) === 'terrain') continue;
+    if (kindByLayer.get(other) === 'traffic') {
+      hitData.best = 0;
+      hitData.found = false;
+      if (trafficCollision(other, x, y, z, 0, 0, 0, hitData)) return true;
+      continue;
+    }
+    nodes = hitData.nodes;
+    nodes.length = 0;
+    if (rootByLayer.get(other)) nodes.push(rootByLayer.get(other));
+    while (nodes.length) {
+      node = nodes.pop();
+      if (!node.visible) continue;
+      if (node.geometry && (
+        insideMesh(node, x, y + 0.45 * root.scale[1], z, hitData.seen, hitData.intersections) ||
+        insideMesh(node, x, y + 1.35 * root.scale[1], z, hitData.seen, hitData.intersections)
+      )) return true;
+      for (child of node.children) nodes.push(child);
+    }
+  }
+  return false;
+}

package/src/collision/readTriangle.js

@@ -1,14 +1,17 @@
+import { vertexCount } from './vertexCount.js';
+
 export function readTriangle(mesh, i, a, b, c) {
   const { position, index, instanceOffset } = mesh.geometry.attributes;
-  const vertices = index?.count || position.count;
+  const size = position.size ?? 3;
+  const vertices = vertexCount(position, index);
   const vertex = instanceOffset ? i % vertices : i;
   const offset = instanceOffset ? Math.floor(i / vertices) * instanceOffset.size : 0;
   const x = instanceOffset?.data[offset] ?? 0;
   const y = instanceOffset?.data[offset + 1] ?? 0;
   const z = instanceOffset?.data[offset + 2] ?? 0;
-  const ai = (index ? index.data[vertex] : vertex) * position.size;
-  const bi = (index ? index.data[vertex + 1] : vertex + 1) * position.size;
-  const ci = (index ? index.data[vertex + 2] : vertex + 2) * position.size;
+  const ai = (index ? index.data[vertex] : vertex) * size;
+  const bi = (index ? index.data[vertex + 1] : vertex + 1) * size;
+  const ci = (index ? index.data[vertex + 2] : vertex + 2) * size;
   a[0] = position.data[ai]; a[1] = position.data[ai + 1]; a[2] = position.data[ai + 2];
   b[0] = position.data[bi]; b[1] = position.data[bi + 1]; b[2] = position.data[bi + 2];
   c[0] = position.data[ci]; c[1] = position.data[ci + 1]; c[2] = position.data[ci + 2];

package/src/collision/setTrafficNormal.js

@@ -0,0 +1,9 @@
+export function setTrafficNormal(data, x, z, distance, dx, dz) {
+  if (distance < 1e-6) {
+    data.normal[0] = -dx;
+    data.normal[1] = -dz;
+  } else {
+    data.normal[0] = x / distance;
+    data.normal[1] = z / distance;
+  }
+}

package/src/collision/trafficCollision.js

@@ -0,0 +1,55 @@
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { trafficByLayer } from '../weakmaps/trafficByLayer.js';
+
+import { locateTraffic } from '../traffic/locateTraffic.js';
+import { setTrafficNormal } from './setTrafficNormal.js';
+
+export function trafficCollision(layer, x, y, z, dx, dz, reach, data) {
+  const state = trafficByLayer.get(layer);
+  if (!state?.mesh || !state.trips.length) return false;
+  let bounds = state.collisionBounds;
+  if (!bounds) {
+    bounds = state.collisionBounds = /* alloc */ { radius: 0, minY: Infinity, maxY: -Infinity };
+    let i, px, py, pz;
+    for (i = 0; i < state.template.position.length; i += 3) {
+      px = state.template.position[i];
+      py = state.template.position[i + 1];
+      pz = state.template.position[i + 2];
+      bounds.radius = Math.max(bounds.radius, Math.hypot(px, pz));
+      bounds.minY = Math.min(bounds.minY, py);
+      bounds.maxY = Math.max(bounds.maxY, py);
+    }
+  }
+  const root = rootByLayer.get(layer), position = state.position ||= /* alloc */ {};
+  const scale = Math.max(root.scale[0], root.scale[1], root.scale[2]);
+  const radius = bounds.radius * scale + 0.35;
+  let trip, projection, closest, rx, rz, perpendicular, entry, distance, bottom, top, px, pz;
+  for (trip of state.trips) {
+    ({ x: px, y: bottom, z: pz } = locateTraffic(state, trip, position));
+    bottom = root.position[1] + (bottom + bounds.minY) * root.scale[1];
+    top = root.position[1] + (position.y + bounds.maxY) * root.scale[1];
+    if (bottom > y + 1.7 * scale || top < y + 0.2 * scale) continue;
+    px = root.position[0] + px * root.scale[0];
+    pz = root.position[2] + pz * root.scale[2];
+    projection = (px - x) * dx + (pz - z) * dz;
+    closest = Math.max(0, Math.min(reach, projection));
+    rx = x + closest * dx - px;
+    rz = z + closest * dz - pz;
+    perpendicular = rx * rx + rz * rz;
+    if (perpendicular >= radius * radius) continue;
+    if (reach === 0) {
+      data.found = true;
+      distance = Math.hypot(x - px, z - pz);
+      data.normal[0] = distance ? (x - px) / distance : 0;
+      data.normal[1] = distance ? (z - pz) / distance : 0;
+      continue;
+    }
+    entry = Math.max(0, projection - Math.sqrt(radius * radius - perpendicular));
+    if (entry > reach || entry >= data.best) continue;
+    data.best = entry;
+    data.found = true;
+    distance = Math.hypot(x + entry * dx - px, z + entry * dz - pz);
+    setTrafficNormal(data, x + entry * dx - px, z + entry * dz - pz, distance, dx, dz);
+  }
+  return data.found;
+}

package/src/collision/vertexCount.js

@@ -0,0 +1,3 @@
+export function vertexCount(position, index) {
+  return index?.count ?? index?.data.length ?? position.count ?? position.data.length / (position.size ?? 3);
+}

package/src/{utils → colors}/parseColor.js

@@ -1,5 +1,5 @@
 import { toSRGB } from "./toSRGB.js";
-import { channel } from "./channel.js";
+import { channel } from "./hslChannel.js";
 
 /**
  * HSL inputs are linear-space to preserve the original building styling.

package/src/controls/addCameraHandler.js

@@ -1,9 +1,11 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
-
 
+import { cameraHandlersByMap } from '../weakmaps/cameraHandlersByMap.js';
 
 export function addCameraHandler(map, name, Type) {
-  const handler = cameraByMap.get(map)[name] = /* alloc */ new Type(map);
+  let handlers = cameraHandlersByMap.get(map);
+  if (!handlers) cameraHandlersByMap.set(map, handlers = /* alloc */ new Map());
+  const handler = /* alloc */ new Type(map);
+  handlers.set(name, handler);
   map._handlers.push(handler);
   if (map.options[name]) handler.enable();
 }

package/src/controls/adjustCameraDrag.js

@@ -1,13 +1,14 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { cameraDraggableByMap } from '../weakmaps/cameraDraggableByMap.js';
+
 
 import { mapGetPitch } from '../camera/mapGetPitch.js';
 import { mapGetBearing } from '../camera/mapGetBearing.js';
 
-import { project } from '../camera/project.js';
+import { project } from '../projections/projectCameraPoint.js';
 
 export function adjustCameraDrag() {
   const map = this;
-  const draggable = cameraByMap.get(map)._cameraDraggable;
+  const draggable = cameraDraggableByMap.get(map);
   if (!mapGetPitch(map) && !mapGetBearing(map)) return;
   const half = map.getSize().divideBy(2), delta = draggable._newPos.subtract(draggable._startPos);
   const ground = half.subtract(project(map, half.subtract(delta), true));