leaflet-city-mapper 0.0.4 → 0.0.5

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/collider.js

@@ -1,27 +1,38 @@
-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';
 
 
 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: { data: p }, index, normal, uv, instanceOffset } = mesh.geometry.attributes;
 
-  const count = index ? index.count : p.length / 3;
+  const vertices = index ? index.count : p.length / 3;
+  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 +45,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 +62,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/insideMesh.js

@@ -0,0 +1,53 @@
+import { CELL } from '../globals/CELL.js';
+
+import { collider } from './collider.js';
+import { horizontalRay } from './horizontalRay.js';
+import { computeBounds } from '../geometry/computeBounds.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();
+  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);
+    }
+  }
+  for (ix = 1; ix < hits.length; ix++) {
+    distance = hits[ix];
+    let 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 % 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;
+  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;
+    }
+    const 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/trafficCollision.js

@@ -0,0 +1,60 @@
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { trafficByLayer } from '../weakmaps/trafficByLayer.js';
+
+import { locateTraffic } from '../traffic/locateTraffic.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 = { 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 ||= {};
+  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);
+    if (distance < 1e-6) {
+      data.normal[0] = -dx;
+      data.normal[1] = -dz;
+    } else {
+      data.normal[0] = (x + entry * dx - px) / distance;
+      data.normal[1] = (z + entry * dz - pz) / distance;
+    }
+  }
+  return data.found;
+}

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));

package/src/controls/cameraControls.js

@@ -1,11 +1,13 @@
+import { cameraTouchStateByMap } from '../weakmaps/cameraTouchStateByMap.js';
+import { rotateControlByMap } from '../weakmaps/rotateControlByMap.js';
+
 import { L } from '../globals/L.js';
 import { Compass } from '../globals/Compass.js';
 import { ContainerResize } from '../globals/ContainerResize.js';
 import { PitchDrag } from '../globals/PitchDrag.js';
 import { ShiftRotate } from '../globals/ShiftRotate.js';
 import { TouchMode } from '../globals/TouchMode.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
-import { touchByContainer } from '../globals/touchByContainer.js';
+import { touchByContainer } from '../weakmaps/touchByContainer.js';
 import { cameraTouchStates } from '../globals/cameraTouchStates.js';
 import { cameraListenerOptions } from '../globals/cameraListenerOptions.js';
 import { cameraEmptyOptions } from '../globals/cameraEmptyOptions.js';
@@ -74,7 +76,8 @@ export function cameraControls(map) {
   addCameraHandler(map, 'touchRotate', TouchMode.value);
   addCameraHandler(map, 'touchPitch', TouchMode.value);
   const container = map.getContainer();
-  const state = cameraByMap.get(map)._cameraTouchState = /* alloc */ { map, container, touch: null, nativeZoom: undefined };
+  const state = /* alloc */ { map, container, touch: null, nativeZoom: undefined };
+  cameraTouchStateByMap.set(map, state);
   touchByContainer.set(container, state);
   cameraTouchStates.add(state);
   container.addEventListener('touchstart', startCameraTouch, cameraListenerOptions);
@@ -84,8 +87,8 @@ export function cameraControls(map) {
   window.addEventListener('blur', endAllCameraTouches);
   map.on('cameratouchchange', changeCameraTouch, map);
   if (map.options.rotateControl) {
-    cameraByMap.get(map).rotateControl = /* alloc */ new L.Control.Rotate(typeof map.options.rotateControl === 'object' ? map.options.rotateControl : cameraEmptyOptions);
-    cameraByMap.get(map).rotateControl.addTo(map);
+    rotateControlByMap.set(map, /* alloc */ new L.Control.Rotate(typeof map.options.rotateControl === 'object' ? map.options.rotateControl : cameraEmptyOptions));
+    rotateControlByMap.get(map).addTo(map);
   }
   map.once('unload', cleanupCameraTouch, map);
 }

package/src/controls/cameraDragClick.js

@@ -1,10 +1,10 @@
-import { dragStates } from '../globals/dragStates.js';
+import { dragStates } from '../weakmaps/dragStates.js';
 
 
-export function cameraDragClick(event) {
-  const state = dragStates.value.get(this);
-  if (!state.moved) return;
-  event.preventDefault();
-  event.stopPropagation();
-  state.moved = false;
+export function cameraDragClick(event) {
+  const state = dragStates.value.get(this);
+  if (!state.moved) return;
+  event.preventDefault();
+  event.stopPropagation();
+  state.moved = false;
 }

package/src/controls/cameraDragContextMenu.js

@@ -1,4 +1,4 @@
-import { dragStates } from '../globals/dragStates.js';
+import { dragStates } from '../weakmaps/dragStates.js';
 
 
 export function cameraDragContextMenu(event) {

package/src/controls/cameraDragDown.js

@@ -1,8 +1,8 @@
-import { dragStates } from '../globals/dragStates.js';
+import { dragStates } from '../weakmaps/dragStates.js';
 import { cameraFocusOptions } from '../globals/cameraFocusOptions.js';
 
 
-import { editable } from './editable.js';
+import { editable } from './isEditableTarget.js';
 
 export function cameraDragDown(event) {
   const state = dragStates.value.get(this);

package/src/controls/cameraDragEnd.js

@@ -1,4 +1,4 @@
-import { dragStates } from '../globals/dragStates.js';
+import { dragStates } from '../weakmaps/dragStates.js';
 
 import { finishCameraDrag } from './finishCameraDrag.js';
 

package/src/controls/cameraDragMove.js

@@ -1,7 +1,7 @@
 import { degrees } from '../globals/degrees.js';
-import { dragStates } from '../globals/dragStates.js';
+import { dragStates } from '../weakmaps/dragStates.js';
 
-import { mapStopPitchBearingAnimation } from '../camera/mapStopPitchBearingAnimation.js';
+import { mapStopPitchBearingAnimation } from '../animations/mapStopPitchBearingAnimation.js';
 import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
 import { mapGetPitch } from '../camera/mapGetPitch.js';
 import { mapGetBearing } from '../camera/mapGetBearing.js';

package/src/controls/changeCameraTouch.js

@@ -1,11 +1,14 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { cameraTouchStateByMap } from '../weakmaps/cameraTouchStateByMap.js';
+import { touchPitchByMap } from '../weakmaps/touchPitchByMap.js';
+import { touchRotateByMap } from '../weakmaps/touchRotateByMap.js';
+
 
 
 import { endCameraTouch } from './endCameraTouch.js';
 
 export function changeCameraTouch() {
-  const state = cameraByMap.get(this)._cameraTouchState, { map, container } = state;
-  const active = cameraByMap.get(map).touchRotate.enabled() || cameraByMap.get(map).touchPitch.enabled();
+  const state = cameraTouchStateByMap.get(this), { map, container } = state;
+  const active = touchRotateByMap.get(map).enabled() || touchPitchByMap.get(map).enabled();
   if (active && state.nativeZoom === undefined) {
     state.nativeZoom = map.touchZoom?.enabled();
     map.touchZoom?.disable();