leaflet-city-mapper 0.0.3 → 0.0.5

package/src/native/updateNativeHover.js

@@ -0,0 +1,7 @@
+export function updateNativeHover(map, context, event, source) {
+  if (context.hovered === source) return;
+  if (context.hovered) context.fireDOMEvent.call(map, event, context.out, /* alloc */ [context.hovered]);
+  context.hovered = source;
+  if (source) context.fireDOMEvent.call(map, event, context.over, /* alloc */ [source]);
+  map.getContainer().style.cursor = source ? 'pointer' : '';
+}

package/src/native/updateNativeLayerView.js

@@ -0,0 +1,10 @@
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
+
+
+import { update } from '../scene/scheduleSceneUpdate.js';
+
+export function updateNativeLayerView() {
+  this.viewDirty = true;
+  if (sharedByLayer.get(this.backend)) update(this.backend);
+}

package/src/picking/findFeature.js

@@ -1,3 +1,9 @@
+import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
+import { modelByLayer } from '../weakmaps/modelByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
+
+
 import { raycast } from './raycast.js';
 
 /**
@@ -6,21 +12,22 @@ import { raycast } from './raycast.js';
  * @returns {PickedFeature|null}
  */
 
-export function findFeature(backend, event) {
-  if (!backend.root || !backend.camera) {
+export function findFeature(layer, event) {
+  const model = modelByLayer.get(layer)
+  if (!rootByLayer.get(layer) || !cameraByLayer.get(layer)) {
     return null;
   }
   let hit, object, ranges, low, high, middle, range;
-  for (hit of raycast(backend, event, backend.root.children, Boolean(backend.model))) {
-    if (backend.model) {
+  for (hit of raycast(layer, event, rootByLayer.get(layer).children, Boolean(model))) {
+    if (model) {
       object = hit.object;
-      while (object && object !== backend.model) {
+      while (object && object !== model) {
         object = object.parent;
       }
-      if (object === backend.model) {
-        return {
-          id: backend.model.id, properties: backend.model.extras,
-          model: backend.model, mesh: hit.object, point: hit.point
+      if (object === model) {
+        return /* alloc */ {
+          id: model.id, properties: model.extras,
+          model, mesh: hit.object, point: hit.point
         };
       }
     }
@@ -37,7 +44,7 @@ export function findFeature(backend, event) {
       } else if (hit.faceIndex >= range.faceEnd) {
         low = middle + 1;
       } else {
-        return {
+        return /* alloc */ {
           ...range,
           mesh: hit.object,
           point: hit.point

package/src/picking/hit.js

@@ -1,23 +1,32 @@
-import { CELL } from '../constants/CELL.js';
-import { collider } from '../collision/collider.js';
-import { computeBounds } from '../geometry/computeBounds.js';
-import { horizontalRay } from '../collision/horizontalRay.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
+
+
+
 import { traverse } from '../scene/traverse.js';
-import { updateWorldMatrix } from '../scene/updateWorldMatrix.js';
-import { shouldSkipOther } from './shouldSkipOther.js';
+import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
 import { hitMesh } from './hitMesh.js';
+import { trafficCollision } from '../collision/trafficCollision.js';
 
 // Horizontal normal of the nearest wall faced within `reach` metres of the feet at world (x, y, z), walking along
 // the unit (dx, dz); knee and chest rays, so arches and tree crowns above the head let the walker through.
-// ponytail: traffic vehicles and boats move on the GPU and are not obstacles.
 
-export function hit(layer, x, y, z, dx, dz, reach) {
-  updateWorldMatrix(layer.scene);
-  const data = { x, y, z, dx, dz, reach, best: reach, found: null };
+export function hit(layer, x, y, z, dx, dz, reach, data) {
+  updateWorldMatrix(sceneByLayer.get(layer));
+  data.x = x, data.y = y, data.z = z, data.dx = dx, data.dz = dz, data.reach = reach;
+  data.best = reach, data.found = false;
   let other;
-  for (other of layer._shared._layers) {
-    if (shouldSkipOther(other, layer)) continue;
-    traverse(other.root, hitMesh, data);
+  for (other of layersByLayer.get(sharedByLayer.get(layer))) {
+    if (other === layer || kindByLayer.get(other) === 'terrain') continue;
+    if (kindByLayer.get(other) === 'traffic') {
+      trafficCollision(other, x, y, z, dx, dz, reach, data);
+      continue;
+    }
+    traverse(rootByLayer.get(other), hitMesh, data);
   }
-  return data.found;
+  return data.found ? data.normal : null;
 }

package/src/picking/hitColliderCell.js

@@ -0,0 +1,19 @@
+import { horizontalRay } from '../collision/horizontalRay.js';
+
+export function hitColliderCell(cell, c, data, ox, oy, oz) {
+  const { dx, dz, seen } = data;
+  let t, height, d;
+  for (t of cell) {
+    if (seen.has(t) || dx * c.nrm[t * 2] + dz * c.nrm[t * 2 + 1] >= 0) continue;
+    seen.add(t);
+    for (height = 0.4; height < 2; height += 1.1) {
+      d = horizontalRay(c.tri, t, ox, oy + height, oz, dx, dz);
+      if (d >= 0 && d < data.best) {
+        data.best = d;
+        data.found = true;
+        data.normal[0] = c.nrm[t * 2];
+        data.normal[1] = c.nrm[t * 2 + 1];
+      }
+    }
+  }
+}

package/src/picking/hitMesh.js

@@ -1,7 +1,9 @@
+import { CELL } from '../globals/CELL.js';
+
 import { computeBounds } from '../geometry/computeBounds.js';
 import { collider } from '../collision/collider.js';
-import { CELL } from '../constants/CELL.js';
-import { horizontalRay } from '../collision/horizontalRay.js';
+
+import { hitColliderCell } from './hitColliderCell.js';
 
 export function hitMesh(mesh, data) {
   if (!mesh.visible) return true;
@@ -12,19 +14,13 @@ export function hitMesh(mesh, data) {
   if (Math.hypot(m[0] * k[0] + m[4] * k[1] + m[8] * k[2] + m[12] - x, m[2] * k[0] + m[6] * k[1] + m[10] * k[2] + m[14] - z) >
     radius * Math.hypot(m[0], m[1], m[2]) + reach) return;
   const c = collider(mesh), ox = x - m[12] + c.origin[0], oy = y - m[13] + c.origin[1], oz = z - m[14] + c.origin[2];
-  const seen = new Set();
-  let ix, iz, t, height, d;
+  const seen = data.seen;
+  seen.clear();
+  let ix, iz, cell;
   for (ix = Math.floor(Math.min(ox, ox + dx * reach) / CELL); ix <= Math.floor(Math.max(ox, ox + dx * reach) / CELL); ix++)
-    for (iz = Math.floor(Math.min(oz, oz + dz * reach) / CELL); iz <= Math.floor(Math.max(oz, oz + dz * reach) / CELL); iz++)
-      for (t of c.cells.get(ix + ',' + iz) || []) {
-        if (seen.has(t) || dx * c.nrm[t * 2] + dz * c.nrm[t * 2 + 1] >= 0) continue;
-        seen.add(t);
-        for (height of [0.4, 1.5]) {
-          d = horizontalRay(c.tri, t, ox, oy + height, oz, dx, dz);
-          if (d >= 0 && d < data.best) {
-            data.best = d;
-            data.found = [c.nrm[t * 2], c.nrm[t * 2 + 1]];
-          }
-        }
-      }
+    for (iz = Math.floor(Math.min(oz, oz + dz * reach) / CELL); iz <= Math.floor(Math.max(oz, oz + dz * reach) / CELL); iz++) {
+      cell = c.cells.get(ix + ',' + iz);
+      if (!cell) continue;
+      hitColliderCell(cell, c, data, ox, oy, oz);
+    }
 }

package/src/picking/onClick.js

@@ -1,3 +1,7 @@
+import { hoveredFeatureByLayer } from '../weakmaps/hoveredFeatureByLayer.js';
+
+
+
 import { findFeature } from './findFeature.js';
 import { setHighlight } from './setHighlight.js';
 import { showFeature } from './showFeature.js';
@@ -6,8 +10,8 @@ import { showFeature } from './showFeature.js';
 
 export function onClick(layer, event) {
   const feature = findFeature(layer, event);
-  layer.hoveredFeature = feature;
+  hoveredFeatureByLayer.set(layer, feature);
   setHighlight(layer, feature);
   showFeature(layer, feature, event);
-  layer.fire('featureclick', { feature, originalEvent: event });
+  layer.fire('featureclick', /* alloc */ { feature, originalEvent: event });
 }

package/src/picking/onPointerLeave.js

@@ -1,11 +1,15 @@
+import { hoveredFeatureByLayer } from '../weakmaps/hoveredFeatureByLayer.js';
+
+
+
 import { setHighlight } from './setHighlight.js';
 import { showFeature } from './showFeature.js';
 
 /** Clear hover, highlight and tooltip without retaining a selected feature. */
 
 export function onPointerLeave(layer) {
-  layer.hoveredFeature = null;
+  hoveredFeatureByLayer.set(layer, null);
   setHighlight(layer, null);
   showFeature(layer, null);
-  layer.fire('featurehover', { feature: null });
+  layer.fire('featurehover', /* alloc */ { feature: null });
 }

package/src/picking/onPointerMove.js

@@ -1,15 +1,24 @@
+import { hoveredFeatureByLayer } from '../weakmaps/hoveredFeatureByLayer.js';
+
+
+
 import { findFeature } from './findFeature.js';
 import { setHighlight } from './setHighlight.js';
 import { showFeature } from './showFeature.js';
+import { onPointerLeave } from './onPointerLeave.js';
 
-/** Hover is transient; featurehover also reports misses with feature:null. */
+/** Gestures clear hover once without raycasting; normal misses report feature:null. */
 
 export function onPointerMove(layer, event) {
-  layer.hoveredFeature = findFeature(layer, event);
-  setHighlight(layer, layer.hoveredFeature);
-  showFeature(layer, layer.hoveredFeature, event);
-  layer.fire('featurehover', {
-    feature: layer.hoveredFeature,
+  if (event.buttons || layer._map.dragging?.moving() || layer._map._animatingZoom) {
+    if (hoveredFeatureByLayer.get(layer)) onPointerLeave(layer);
+    return;
+  }
+  hoveredFeatureByLayer.set(layer, findFeature(layer, event));
+  setHighlight(layer, hoveredFeatureByLayer.get(layer));
+  showFeature(layer, hoveredFeatureByLayer.get(layer), event);
+  layer.fire('featurehover', /* alloc */ {
+    feature: hoveredFeatureByLayer.get(layer),
     originalEvent: event
   });
 }

package/src/picking/raycast.js

@@ -1,8 +1,19 @@
+import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
+import { raycasterByLayer } from '../weakmaps/raycasterByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
+
+import { trafficByLayer } from '../weakmaps/trafficByLayer.js';
+
+
 import { intersectMeshes } from '../collision/intersectMeshes.js';
 import { traverse } from '../scene/traverse.js';
-import { updateCamera } from '../scene/updateCamera.js';
-import { updateWorldMatrix } from '../scene/updateWorldMatrix.js';
+import { updateCamera } from '../camera/updateSceneCamera.js';
+import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
 import { collectVisibleMesh } from './collectVisibleMesh.js';
+import { placeTraffic } from '../traffic/placeTraffic.js';
+import { validateCameraInverse } from './validateCameraInverse.js';
 
 /** Raycasting, hover/click highlight and tooltips. */
 /**
@@ -14,46 +25,47 @@ import { collectVisibleMesh } from './collectVisibleMesh.js';
  * @returns {Object[]} Nearest hit per mesh: object, shared-world point/distance and triangle faceIndex.
  */
 
-export function raycast(backend, event, objects = backend.root.children, recursive = true) {
-  if (!backend.renderer) {
-    return [];
+export function raycast(layer, event, objects = rootByLayer.get(layer).children, recursive = true) {
+  if (!rendererByLayer.get(layer)) {
+    return /* alloc */ [];
   }
-  backend._beforeRaycast?.();
-  const rect = backend._map.getContainer().getBoundingClientRect();
-  updateWorldMatrix(backend.scene);
-  updateCamera(backend.camera);
+  const traffic = trafficByLayer.get(layer);
+  if (traffic) placeTraffic(traffic);
+  const rect = layer._map.getContainer().getBoundingClientRect();
+  updateWorldMatrix(sceneByLayer.get(layer));
+  updateCamera(cameraByLayer.get(layer));
   // Unproject the mouse (-1..1) into a world-space ray from the camera.
-  const inverseCamera = new DOMMatrix(backend.camera.projectionViewMatrix).inverse();
-  const inverseCameraValues = inverseCamera.toFloat64Array();
-  let value, object;
-  for (value of inverseCameraValues) {
-    if (!Number.isFinite(value)) throw new Error('Singular 3D transform');
-  }
-  backend.raycaster.origin[0] = backend.camera.position[0];
-  backend.raycaster.origin[1] = backend.camera.position[1];
-  backend.raycaster.origin[2] = backend.camera.position[2];
-  const unprojected = new DOMPoint(
-    ((event.clientX - rect.left) / rect.width) * 2 - 1,
-    -((event.clientY - rect.top) / rect.height) * 2 + 1,
-    0,
-    1
-  ).matrixTransform(inverseCamera);
-  const end = [
-    unprojected.x / unprojected.w,
-    unprojected.y / unprojected.w,
-    unprojected.z / unprojected.w
-  ];
-  backend.raycaster.direction[0] = end[0] - backend.raycaster.origin[0];
-  backend.raycaster.direction[1] = end[1] - backend.raycaster.origin[1];
-  backend.raycaster.direction[2] = end[2] - backend.raycaster.origin[2];
-  const rayLength = Math.hypot(...backend.raycaster.direction) || 1;
-  backend.raycaster.direction[0] /= rayLength;
-  backend.raycaster.direction[1] /= rayLength;
-  backend.raycaster.direction[2] /= rayLength;
-  const meshes = [];
+  const inverseCamera = raycasterByLayer.get(layer).inverse;
+  const matrix = cameraByLayer.get(layer).projectionViewMatrix;
+  inverseCamera.m11 = matrix[0], inverseCamera.m12 = matrix[1], inverseCamera.m13 = matrix[2], inverseCamera.m14 = matrix[3];
+  inverseCamera.m21 = matrix[4], inverseCamera.m22 = matrix[5], inverseCamera.m23 = matrix[6], inverseCamera.m24 = matrix[7];
+  inverseCamera.m31 = matrix[8], inverseCamera.m32 = matrix[9], inverseCamera.m33 = matrix[10], inverseCamera.m34 = matrix[11];
+  inverseCamera.m41 = matrix[12], inverseCamera.m42 = matrix[13], inverseCamera.m43 = matrix[14], inverseCamera.m44 = matrix[15];
+  inverseCamera.invertSelf();
+  const x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
+  const y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+  const endX = inverseCamera.m11 * x + inverseCamera.m21 * y + inverseCamera.m41;
+  const endY = inverseCamera.m12 * x + inverseCamera.m22 * y + inverseCamera.m42;
+  const endZ = inverseCamera.m13 * x + inverseCamera.m23 * y + inverseCamera.m43;
+  const endW = inverseCamera.m14 * x + inverseCamera.m24 * y + inverseCamera.m44;
+  let object;
+  validateCameraInverse(inverseCamera);
+  raycasterByLayer.get(layer).origin[0] = cameraByLayer.get(layer).position[0];
+  raycasterByLayer.get(layer).origin[1] = cameraByLayer.get(layer).position[1];
+  raycasterByLayer.get(layer).origin[2] = cameraByLayer.get(layer).position[2];
+  raycasterByLayer.get(layer).direction[0] = endX / endW - raycasterByLayer.get(layer).origin[0];
+  raycasterByLayer.get(layer).direction[1] = endY / endW - raycasterByLayer.get(layer).origin[1];
+  raycasterByLayer.get(layer).direction[2] = endZ / endW - raycasterByLayer.get(layer).origin[2];
+  const direction = raycasterByLayer.get(layer).direction;
+  const rayLength = Math.hypot(direction[0], direction[1], direction[2]) || 1;
+  raycasterByLayer.get(layer).direction[0] /= rayLength;
+  raycasterByLayer.get(layer).direction[1] /= rayLength;
+  raycasterByLayer.get(layer).direction[2] /= rayLength;
+  const meshes = raycasterByLayer.get(layer).meshes;
+  meshes.length = 0;
   for (object of objects) {
     if (recursive) traverse(object, collectVisibleMesh, meshes);
     else if (object.geometry && object.visible && object._appearance !== 0) meshes.push(object);
   }
-  return intersectMeshes(backend.raycaster, meshes, backend.renderer.uniformData?.[55]);
+  return intersectMeshes(raycasterByLayer.get(layer), meshes, rendererByLayer.get(layer).uniformData?.[55]);
 }

package/src/picking/setHighlight.js

@@ -1,13 +1,21 @@
-import { update } from '../scene/update.js';
+import { highlightedFeatureByLayer } from '../weakmaps/highlightedFeatureByLayer.js';
+
+
+
+import { update } from '../scene/scheduleSceneUpdate.js';
 
 /** Highlight a source vertex range in the shader; vertex colors stay untouched. */
 
-export function setHighlight(backend, feature) {
+export function setHighlight(layer, feature) {
   if (feature?.model) feature = null;
-  if (backend.highlightedFeature?.mesh === feature?.mesh &&
-    backend.highlightedFeature?.vertexStart === feature?.vertexStart) return;
-  if (backend.highlightedFeature) backend.highlightedFeature.mesh.highlight = null;
-  backend.highlightedFeature = feature;
-  if (feature) feature.mesh.highlight = [feature.vertexStart, feature.vertexEnd];
-  update(backend);
+  if (highlightedFeatureByLayer.get(layer)?.mesh === feature?.mesh &&
+    highlightedFeatureByLayer.get(layer)?.vertexStart === feature?.vertexStart) return;
+  if (highlightedFeatureByLayer.get(layer)) highlightedFeatureByLayer.get(layer).mesh.highlight = null;
+  highlightedFeatureByLayer.set(layer, feature);
+  if (feature) {
+    feature.mesh.highlightRange[0] = feature.vertexStart;
+    feature.mesh.highlightRange[1] = feature.vertexEnd;
+    feature.mesh.highlight = feature.mesh.highlightRange;
+  }
+  update(layer);
 }

package/src/picking/shouldSkipOther.js

@@ -1,3 +1,7 @@
+import { typeByLayer } from '../weakmaps/typeByLayer.js';
+
+
+
 export function shouldSkipOther(other, layer) {
-  return other === layer || other._type === 'terrain' || other._type === 'traffic';
+  return other === layer || typeByLayer.get(other) === 'terrain' || typeByLayer.get(other) === 'traffic';
 }

package/src/picking/showFeature.js

@@ -1,34 +1,42 @@
+import { containerByLayer } from '../weakmaps/containerByLayer.js';
+import { cursorByLayer } from '../weakmaps/cursorByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+import { tooltipByLayer } from '../weakmaps/tooltipByLayer.js';
+
+
+
 /** Update tooltip content/position and arbitrate cursor ownership across shared layers. */
 
-export function showFeature(backend, feature, event) {
-  const tooltip = backend._tooltip;
+export function showFeature(layer, feature, event) {
+  const tooltip = tooltipByLayer.get(layer);
   if (!tooltip) return;
   if (feature) {
-    tooltip.replaceChildren(backend.options.tooltip(feature));
+    tooltip.replaceChildren(layer.options.tooltip(feature));
     tooltip.hidden = false;
-    const rect = backend.container.getBoundingClientRect();
+    const rect = containerByLayer.get(layer).getBoundingClientRect();
     const x = event.clientX - rect.left, y = event.clientY - rect.top;
     tooltip.style.left = `${x + tooltip.offsetWidth + 16 > rect.width ? x - tooltip.offsetWidth - 12 : x + 12}px`;
     tooltip.style.top = `${y + tooltip.offsetHeight + 16 > rect.height ? y - tooltip.offsetHeight - 12 : y + 12}px`;
   } else {
     tooltip.hidden = true;
   }
-  const shared = backend._shared;
-  let layer;
+  const shared = sharedByLayer.get(layer);
+  let sharedLayer;
   if (shared) {
     let visible = false;
-    for (layer of shared._layers) {
-      if (layer._tooltip && !layer._tooltip.hidden) {
+    for (sharedLayer of layersByLayer.get(shared)) {
+      if (tooltipByLayer.get(sharedLayer) && !tooltipByLayer.get(sharedLayer).hidden) {
         visible = true;
         break;
       }
     }
     if (visible) {
-      if (shared._cursor === undefined) shared._cursor = backend.container.style.cursor;
-      backend.container.style.cursor = 'pointer';
-    } else if (shared._cursor !== undefined) {
-      backend.container.style.cursor = shared._cursor;
-      delete shared._cursor;
+      if (cursorByLayer.get(shared) === undefined) cursorByLayer.set(shared, containerByLayer.get(layer).style.cursor);
+      containerByLayer.get(layer).style.cursor = 'pointer';
+    } else if (cursorByLayer.get(shared) !== undefined) {
+      containerByLayer.get(layer).style.cursor = cursorByLayer.get(shared);
+      cursorByLayer.delete(shared);
     }
   }
 }

package/src/picking/validateCameraInverse.js

@@ -0,0 +1,8 @@
+export function validateCameraInverse(matrix) {
+  let column, row;
+  for (column = 1; column <= 4; column++) {
+    for (row = 1; row <= 4; row++) {
+      if (!Number.isFinite(matrix[`m${column}${row}`])) throw /* alloc */ new Error('Singular 3D transform');
+    }
+  }
+}

package/src/projections/cameraAngles.js

@@ -0,0 +1,14 @@
+import { radians } from '../globals/radians.js';
+
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+
+export function angles(map, target) {
+  const bearing = mapGetBearing(map) * radians, pitch = mapGetPitch(map) * radians;
+  target ||= /* alloc */ [];
+  target[0] = Math.cos(bearing);
+  target[1] = Math.sin(bearing);
+  target[2] = Math.cos(pitch);
+  target[3] = Math.sin(pitch);
+  return target;
+}

package/src/projections/groundBounds.js

@@ -0,0 +1,18 @@
+import { L } from '../globals/L.js';
+import { cameraZeroPadding } from '../globals/cameraZeroPadding.js';
+import { pointOf } from './toPoint.js';
+import { project } from './projectCameraPoint.js';
+
+
+export function groundBounds(map, padding = cameraZeroPadding) {
+  const min = pointOf(padding).divideBy(2), max = map.getSize().subtract(min);
+  const bounds = /* alloc */ new L.Bounds();
+  const minX = min.x, minY = min.y;
+  let i;
+  for (i = 0; i < 4; i++) {
+    min.x = i % 2 ? max.x : minX;
+    min.y = i < 2 ? minY : max.y;
+    bounds.extend(project(map, min, true, true));
+  }
+  return bounds;
+}

package/src/projections/localPixelForGeometry.js

@@ -0,0 +1,7 @@
+import { geometryPixelStates } from '../globals/geometryPixelStates.js';
+
+import { localPixel } from './localPixel.js';
+
+export function localPixelForGeometry(point) {
+  return localPixel(geometryPixelStates[geometryPixelStates.length - 1], point);
+}

package/src/projections/localPosition.js

@@ -0,0 +1,11 @@
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+
+import { radians } from '../globals/radians.js';
+
+
+export function localPosition(state, latlng) {
+  const { map, backend: layer } = state, crs = map.options.crs;
+  const origin = crs.project(locationByLayer.get(layer)), point = crs.project(latlng);
+  const metres = Math.cos(locationByLayer.get(layer).lat * radians);
+  return /* alloc */ [(point.x - origin.x) * metres, 0, -(point.y - origin.y) * metres];
+}

package/src/projections/markerCameraIconPoint.js

@@ -0,0 +1,12 @@
+import { L } from '../globals/L.js';
+import { radians } from '../globals/radians.js';
+
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+export function markerCameraIconPoint(marker, x, y) {
+  let rotation = marker.options.rotation + (marker.options.rotateWithView ? mapGetBearing(marker._map) * radians : 0);
+  if (marker.options.keepUpright && Math.cos(rotation) < 0) rotation += Math.PI;
+  const scale = marker.options.scale;
+  return /* alloc */ new L.Point((x * Math.cos(rotation) - y * Math.sin(rotation)) * scale,
+    (x * Math.sin(rotation) + y * Math.cos(rotation)) * scale);
+}

package/src/projections/projectBridgePoint.js

@@ -0,0 +1,5 @@
+import { L } from '../globals/L.js';
+export function local([lng, lat, z], crs, origin, metres, base) {
+  const p = crs.project(/* alloc */ new L.LatLng(lat, lng));
+  return /* alloc */ [(p.x - origin.x) * metres, z - base, -(p.y - origin.y) * metres];
+}

package/src/projections/projectCameraPoint.js

@@ -0,0 +1,27 @@
+import { cameraAngles } from '../globals/cameraAngles.js';
+import { pointOf } from './toPoint.js';
+import { angles } from './cameraAngles.js';
+
+
+export function project(map, point, inverse = false, limit = false) {
+  const size = map.getSize(), halfX = size.x / 2, halfY = size.y / 2, distance = size.y * 1.5;
+  const result = pointOf(point);
+  if (!distance) return result;
+  const [cos, sin, tilt, rise] = angles(map, cameraAngles);
+  const x = result.x - halfX, y = result.y - halfY;
+  if (inverse) {
+    const far = size.y * map.options.pitchMaxDistance;
+    const denominator = tilt * distance + rise * y;
+    let v = denominator * tilt > 0 ? y * distance / denominator : -far;
+    if (limit) v = Math.max(-far, Math.min(far, v));
+    const u = x * (distance - rise * v) / distance;
+    result.x = cos * u + sin * v + halfX;
+    result.y = -sin * u + cos * v + halfY;
+    return result;
+  }
+  const u = cos * x - sin * y, v = sin * x + cos * y;
+  const scale = distance / (distance - rise * v);
+  result.x = u * scale + halfX;
+  result.y = tilt * v * scale + halfY;
+  return result;
+}

package/src/projections/projectCelestialBody.js

@@ -0,0 +1,13 @@
+/** Perspective projection of a celestial direction; null when behind the camera. */
+
+export function projectCelestialBody(dir, size, pitch, bearing, target) {
+  const [x, y, z] = dir;
+  const forward = -x * Math.sin(bearing) * Math.sin(pitch) - y * Math.cos(pitch) - z * Math.cos(bearing) * Math.sin(pitch);
+  if (forward > 0) {
+    target ||= /* alloc */ {};
+    target.left = size.x / 2 + size.y * 1.5 * (x * Math.cos(bearing) - z * Math.sin(bearing)) / forward;
+    target.top = size.y / 2 - size.y * 1.5 * (-x * Math.sin(bearing) * Math.cos(pitch) + y * Math.sin(pitch) - z * Math.cos(bearing) * Math.cos(pitch)) / forward;
+    return target;
+  }
+  return null;
+}

package/src/projections/projectRing.js

@@ -0,0 +1,26 @@
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
+import { L } from '../globals/L.js';
+import { mapElevationOf } from '../terrain/mapElevationOf.js';
+
+export function projectRing(context, ring) {
+  const { backend: layer, crs, origin, metres, map } = context;
+  if (ring.length < 4) throw /* alloc */ new Error('Invalid GeoJSON polygon ring');
+  const path = /* alloc */ [];
+  const root = rootByLayer.get(layer);
+  let i, lng, lat, location, point, elevation;
+  for (i = 0; i < ring.length - 1; i++) {
+    lng = ring[i][0], lat = ring[i][1];
+    if (!Number.isFinite(lng) || !Number.isFinite(lat)) throw /* alloc */ new Error('Invalid GeoJSON coordinates');
+    location = /* alloc */ new L.LatLng(lat, lng);
+    point = crs.project(location);
+    elevation = mapElevationOf(map, location);
+    path.push(/* alloc */ {
+      x: (point.x - origin.x) * metres,
+      y: (point.y - origin.y) * metres,
+      ground: Number.isFinite(elevation) && Number.isFinite(root.position[1])
+        ? elevation - root.position[1] : 0,
+    });
+  }
+  return path;
+}

package/src/projections/projectTreePoint.js

@@ -0,0 +1,17 @@
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
+import { L } from '../globals/L.js';
+import { mapElevationOf } from '../terrain/mapElevationOf.js';
+
+export function projectedTree(context, lon, lat) {
+  const { backend: layer, crs, origin, metres, map } = context;
+  const location = /* alloc */ new L.LatLng(lat, lon);
+  const point = crs.project(location);
+  const elevation = mapElevationOf(map, location), root = rootByLayer.get(layer);
+  return /* alloc */ {
+    x: (point.x - origin.x) * metres,
+    y: (point.y - origin.y) * metres,
+    ground: Number.isFinite(elevation) && Number.isFinite(root.position[1])
+      ? elevation - root.position[1] : 0,
+  };
+}