leaflet-city-mapper 0.0.3 → 0.0.5

package/src/core/markerSetPos.js

@@ -1,12 +1,17 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
-import { displayPoint } from '../camera/displayPoint.js';
+import { markerMethods } from '../globals/markerMethods.js';
+
+import { markerCameraIconPoint } from '../projections/markerCameraIconPoint.js';
+
+import { displayPoint } from '../projections/displayContainerPoint.js';
 
 export function markerSetPos(point) {
-  mapCameraState.markerMethods._setPos.call(this, displayPoint(this._map, point));
-  let element, key, direction, options, anchor;
-  for ([element, key] of [[this._icon, 'iconAnchor'], [this._shadow, 'shadowAnchor']]) {
+  markerMethods.value._setPos.call(this, displayPoint(this._map, point));
+  let i, element, key, direction, options, anchor;
+  for (i = 0; i < 2; i++) {
+    element = i ? this._shadow : this._icon;
+    key = i ? 'shadowAnchor' : 'iconAnchor';
     if (!element) continue;
-    direction = this._cameraIconPoint(1, 0), options = this.options.icon.options;
+    direction = markerCameraIconPoint(this, 1, 0), options = this.options.icon.options;
     anchor = options[key] || options.iconAnchor;
     element.style.transformOrigin = anchor ? `${anchor.x ?? anchor[0]}px ${anchor.y ?? anchor[1]}px` : 'center';
     element.style.transform += ` rotate(${Math.atan2(direction.y, direction.x)}rad) scale(${this.options.scale})`;

package/src/core/markerSetRotation.js

@@ -1,7 +1,9 @@
-export function markerSetRotation(rotation) {
-  if (!Number.isFinite(rotation)) throw new TypeError('Marker rotation must be finite');
-  this.options.rotation = rotation;
-  this.update();
-  this._nativeGPU?.refresh?.();
-  return this;
-}
+import { refreshNativeLayerContract } from '../native/refreshNativeLayerContract.js';
+
+export function markerSetRotation(marker, rotation) {
+  if (!Number.isFinite(rotation)) throw /* alloc */ new TypeError('Marker rotation must be finite');
+  marker.options.rotation = rotation;
+  marker.update();
+  refreshNativeLayerContract(marker);
+  return marker;
+}

package/src/core/markerUpdateZIndex.js

@@ -1,8 +1,13 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { cameraZIndexOffsetByLayer } from '../weakmaps/cameraZIndexOffsetByLayer.js';
+
+import { markerMethods } from '../globals/markerMethods.js';
+
+
 
 export function markerUpdateZIndex(offset) {
-  mapCameraState.markerMethods._updateZIndex.call(this, offset);
-  const changed = this._cameraZIndexOffset !== offset;
-  this._cameraZIndexOffset = offset;
-  if (changed) this._nativeGPU?.refresh?.();
+  markerMethods.value._updateZIndex.call(this, offset);
+  const changed = cameraZIndexOffsetByLayer.get(this) !== offset;
+  cameraZIndexOffsetByLayer.set(this, offset);
+  if (changed) refreshNativeLayerContract(this);
 }
+import { refreshNativeLayerContract } from '../native/refreshNativeLayerContract.js';

package/src/core/popupAdjustPan.js

@@ -1,23 +1,29 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
-import { pointOf } from '../camera/pointOf.js';
+import { popupPan } from '../globals/popupPan.js';
+
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+import { pointOf } from '../projections/toPoint.js';
 
 export function popupAdjustPan() {
-  const map = this._map;
-  if (!map.getPitch() && !map.getBearing()) return mapCameraState.popupPan.call(this);
-  if (!this.options.autoPan) return;
-  if (map._panAnim) map._panAnim.stop();
-  if (this._autopanning) { this._autopanning = false; return; }
-  const rect = this._container.getBoundingClientRect(), container = map.getContainer().getBoundingClientRect();
-  const min = pointOf(this.options.autoPanPaddingTopLeft || this.options.autoPanPadding);
-  const max = map.getSize().subtract(pointOf(this.options.autoPanPaddingBottomRight || this.options.autoPanPadding));
-  const left = rect.left - container.left, top = rect.top - container.top;
-  const right = rect.right - container.left, bottom = rect.bottom - container.top;
-  const dx = Math.min(0, left - min.x) || Math.max(0, right - max.x);
-  const dy = Math.min(0, top - min.y) || Math.max(0, bottom - max.y);
-  if (!dx && !dy) return;
-  if (this.options.keepInView) this._autopanning = true;
-  const screen = map.latLngToContainerPoint(this._latlng).subtract(new L.Point(dx, dy));
-  const delta = map.latLngToLayerPoint(this._latlng).subtract(map.containerPointToLayerPoint(screen));
-  map.fire('autopanstart');
+  const map = this._map;
+  if (!mapGetPitch(map) && !mapGetBearing(map)) return popupPan.value.call(this);
+  if (!this.options.autoPan) return;
+  if (map._panAnim) map._panAnim.stop();
+  if (this._autopanning) { this._autopanning = false; return; }
+  const rect = this._container.getBoundingClientRect(), container = map.getContainer().getBoundingClientRect();
+  const min = pointOf(this.options.autoPanPaddingTopLeft || this.options.autoPanPadding);
+  const max = map.getSize().subtract(pointOf(this.options.autoPanPaddingBottomRight || this.options.autoPanPadding));
+  const left = rect.left - container.left, top = rect.top - container.top;
+  const right = rect.right - container.left, bottom = rect.bottom - container.top;
+  const dx = Math.min(0, left - min.x) || Math.max(0, right - max.x);
+  const dy = Math.min(0, top - min.y) || Math.max(0, bottom - max.y);
+  if (!dx && !dy) return;
+  if (this.options.keepInView) this._autopanning = true;
+  const screen = map.latLngToContainerPoint(this._latlng);
+  screen.x -= dx;
+  screen.y -= dy;
+  const delta = map.latLngToLayerPoint(this._latlng).subtract(map.containerPointToLayerPoint(screen));
+  map.fire('autopanstart');
   map.panTo(map.unproject(map.project(map.getCenter()).add(delta)));
 }

package/src/core/popupGetEvents.js

@@ -1,5 +1,8 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { popupEvents } from '../globals/popupEvents.js';
+
 
 export function popupGetEvents() {
-  return { ...mapCameraState.popupEvents.call(this), rotate: this._updatePosition, pitch: this._updatePosition, move: this._updatePosition };
+  const events = popupEvents.value.call(this);
+  events.rotate = events.pitch = events.move = this._updatePosition;
+  return events;
 }

package/src/core/popupUpdatePosition.js

@@ -1,8 +1,11 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
-import { displayPoint } from '../camera/displayPoint.js';
+import { L } from '../globals/L.js';
+import { popupPosition } from '../globals/popupPosition.js';
+
+
+import { displayPoint } from '../projections/displayContainerPoint.js';
 
 export function popupUpdatePosition() {
-  mapCameraState.popupPosition.call(this);
+  popupPosition.value.call(this);
   if (!this._map) return;
   const point = this._map.latLngToLayerPoint(this._latlng), delta = displayPoint(this._map, point).subtract(point);
   if (this._zoomAnimated) {

package/src/core/redrawPath.js

@@ -0,0 +1,6 @@
+import { refreshNativeLayerContract } from '../native/refreshNativeLayerContract.js';
+
+export function redrawPath() {
+  refreshNativeLayerContract(this);
+  return this;
+}

package/src/core/removeLayer.js

@@ -0,0 +1,23 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
+import { L } from '../globals/L.js';
+import { removeLayer as sharedRemoveLayer } from '../globals/removeLayer.js';
+
+import { removeSceneLayer } from '../scene/removeSceneLayer.js';
+
+
+
+export function removeLayer(layer) {
+  const id = L.Util.stamp(layer);
+  if (!this._layers[id]) return this;
+
+  if (!kindByLayer.get(layer)) return sharedRemoveLayer.value.call(this, layer);
+  if (this._loaded) removeSceneLayer(layer, this);
+  delete this._layers[id];
+  if (this._loaded) {
+    this.fire('layerremove', /* alloc */ { layer });
+    layer.fire('remove');
+  }
+  layer._map = layer._mapToAdd = null;
+  return this;
+}

package/src/core/setRotation.js

@@ -0,0 +1,5 @@
+import { markerSetRotation } from './markerSetRotation.js';
+
+export function setRotation(rotation) {
+  return markerSetRotation(this, rotation);
+}

package/src/core/tooltipGetEvents.js

@@ -1,5 +1,8 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { tooltipEvents } from '../globals/tooltipEvents.js';
+
 
 export function tooltipGetEvents() {
-  return { ...mapCameraState.tooltipEvents.call(this), rotate: this._updatePosition, pitch: this._updatePosition, move: this._updatePosition };
+  const events = tooltipEvents.value.call(this);
+  events.rotate = events.pitch = events.move = this._updatePosition;
+  return events;
 }

package/src/core/tooltipSetPosition.js

@@ -1,8 +1,11 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
-import { displayPoint } from '../camera/displayPoint.js';
+import { L } from '../globals/L.js';
+import { tooltipPosition } from '../globals/tooltipPosition.js';
+
+
+import { displayPoint } from '../projections/displayContainerPoint.js';
 
 export function tooltipSetPosition(point) {
-  mapCameraState.tooltipPosition.call(this, point);
+  tooltipPosition.value.call(this, point);
   const delta = displayPoint(this._map, point).subtract(point);
   L.DomUtil.setPosition(this._container, L.DomUtil.getPosition(this._container).add(delta));
 }

package/src/core/updateGridOpacity.js

@@ -1,12 +1,15 @@
-import { cancelGridFade } from './cancelGridFade.js';
-import { scheduleGridFade } from './scheduleGridFade.js';
+
+import { cancelGridFade } from '../animations/cancelGridFade.js';
+import { scheduleGridFade } from '../animations/scheduleGridFade.js';
 
 export function updateGridOpacity() {
   if (!this._map) return;
   const layer = this, now = Date.now();
   let fading = false, prune = false;
-  let tile;
-  for (tile of Object.values(this._tiles || {})) {
+  let key, tile;
+  for (key in this._tiles) {
+    if (!Object.hasOwn(this._tiles, key)) continue;
+    tile = this._tiles[key];
     if (!tile.current || !tile.loaded) continue;
     tile._gpuOpacity = this._map._fadeAnimated ? Math.min(1, (now - tile.loaded) / 200) : 1;
     if (tile._gpuOpacity < 1) fading = true;
@@ -17,7 +20,8 @@ export function updateGridOpacity() {
     }
   }
   if (prune && !this._noPrune) this._pruneTiles();
-  this._nativeGPU?.refresh?.();
+  refreshNativeLayerContract(this);
   cancelGridFade(layer);
   if (fading) scheduleGridFade(layer);
 }
+import { refreshNativeLayerContract } from '../native/refreshNativeLayerContract.js';

package/src/core/whenReady.js

@@ -0,0 +1,11 @@
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+import { cameraReadyByMap } from '../weakmaps/cameraReadyByMap.js';
+
+
+
+
+
+export function ready(instance) {
+  return readyByLayer.get(instance) ||
+    cameraReadyByMap.get(instance) || Promise.resolve(instance);
+}

package/src/geometry/addBridges.js

@@ -1,88 +1,34 @@
-import { createMesh } from '../rendering/createMesh.js';
-import { triangulate } from '../triangulation/triangulate.js';
-import { local } from './bridgeLocal.js';
-import { push } from './push.js';
-import { below } from './below.js';
+import { bridgeMeshByLayer } from '../weakmaps/bridgeMeshByLayer.js';
+import { bridgesByLayer } from '../weakmaps/bridgesByLayer.js';
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { terrainZoomByLayer } from '../weakmaps/terrainZoomByLayer.js';
 
-/**
- * Bare-earth DEMs drop bridges: `getElevation` returns the deck height inside these polygons (GeoJSON
- * Polygon/MultiPolygon with Z, e.g. IGN BD TOPO), and one mesh draws the 1.2 m thick decks.
- * ponytail: anything under a deck (quays, boats asking `getElevation`) also gets the deck height.
- */
-
-export function addBridges(backend, geojson) {
-  const map = backend._map, crs = map.options.crs, zoom = backend._terrainZoom;
-  const origin = crs.project(backend.location), metres = Math.cos(backend.location.lat * Math.PI / 180);
-  const base = backend.root.position[1], position = [], normal = [], color = [];
-  backend._bridges = new Map();
-  let geometry, polygons, polygon, rings, ring, path, pixels, points, lng, lat, z, p, coordinate;
-  let triangles, paths, start, i, contour, holes, bridgeTriangles, xs, ys, t, triangle, bridge, x, y;
-  let key, a, b, c, pa, pb, pc, start2, q, length, n, corner;
-  for ({ geometry } of geojson.features) {
-    polygons = geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.type === 'MultiPolygon' ? geometry.coordinates : [];
-    for (polygon of polygons) {
-      rings = [];
-      for (ring of polygon) {
-        path = ring.slice(0, -1);
-        if (path.length >= 3) rings.push(path);
-      }
-      if (!rings.length) continue;
-      pixels = [], points = [];
-      for (ring of rings) for ([lng, lat, z] of ring) {
-        p = map.project([lat, lng], zoom);
-        pixels.push([p.x, p.y, z]);
-      }
-      for (ring of rings) for (coordinate of ring) points.push(local(coordinate, crs, origin, metres, base));
-      triangles = void 0;
-      try {
-        paths = [];
-        start = 0;
-        for (ring of rings) {
-          path = [];
-          for (i = 0; i < ring.length; i++) path.push({ x: pixels[start + i][0], y: pixels[start + i][1] });
-          paths.push(path);
-          start += ring.length;
-        }
-        [contour, ...holes] = paths;
-        triangles = triangulate(contour, holes);
-      } catch { continue; }
-      bridgeTriangles = [], xs = [], ys = [];
-      for (t of triangles) {
-        triangle = [];
-        for (i of t) triangle.push(pixels[i]);
-        bridgeTriangles.push(triangle);
-      }
-      for (p of pixels) { xs.push(p[0]); ys.push(p[1]); }
-      bridge = {
-        triangles: bridgeTriangles,
-        min: [Math.min(...xs), Math.min(...ys)],
-        max: [Math.max(...xs), Math.max(...ys)],
-      };
-      for (x = Math.floor(bridge.min[0] / 64); x <= Math.floor(bridge.max[0] / 64); x++) {
-        for (y = Math.floor(bridge.min[1] / 64); y <= Math.floor(bridge.max[1] / 64); y++) {
-          key = `${x}/${y}`;
-          backend._bridges.set(key, [...backend._bridges.get(key) || [], bridge]);
-        }
-      }
-      for ([a, b, c] of triangles) {
-        // Counter-clockwise seen from above, so double-sided shading keeps the top lit.
-        [pa, pb, pc] = [points[a], points[b], points[c]];
-        if ((pb[2] - pa[2]) * (pc[0] - pa[0]) - (pb[0] - pa[0]) * (pc[2] - pa[2]) < 0) [b, c] = [c, b];
-        for (i of [a, b, c]) push(position, normal, color, points[i], [0, 1, 0]);
-        for (i of [a, c, b]) push(position, normal, color, below(points[i]), [0, -1, 0]);
-      }
-      start2 = 0;
-      for (ring of rings) {
-        for (i = 0; i < ring.length; i++) {
-          p = points[start2 + i], q = points[start2 + (i + 1) % ring.length];
-          length = Math.hypot(q[0] - p[0], q[2] - p[2]) || 1, n = [(q[2] - p[2]) / length, 0, -(q[0] - p[0]) / length];
-          for (corner of [p, q, below(q), p, below(q), below(p)]) push(position, normal, color, corner, n);
-        }
-        start2 += ring.length;
-      }
-    }
-  }
-  if (position.length) {
-    backend._bridgeMesh = createMesh(backend, { position, normal, color });
-  }
-}
+import { radians } from '../globals/radians.js';
+import { createMesh } from '../rendering/createMesh.js';
+import { bridgePolygon } from './bridgePolygon.js';
+
+/**
+ * Bare-earth DEMs drop bridges: `getElevation` returns the deck height inside these polygons (GeoJSON
+ * Polygon/MultiPolygon with Z, e.g. IGN BD TOPO), and one mesh draws the 1.2 m thick decks.
+ * ponytail: anything under a deck (quays, boats asking `getElevation`) also gets the deck height.
+ */
+export function addBridges(layer, geojson) {
+  const map = layer._map, crs = map.options.crs, zoom = terrainZoomByLayer.get(layer);
+  const origin = crs.project(locationByLayer.get(layer)), metres = Math.cos(locationByLayer.get(layer).lat * radians);
+  const base = rootByLayer.get(layer).position[1];
+  const position = /* alloc */ [], normal = /* alloc */ [], color = /* alloc */ [];
+  bridgesByLayer.set(layer, /* alloc */ new Map());
+  const context = /* alloc */ { backend: layer, map, crs, zoom, origin, metres, base, position, normal, color };
+  let geometry, polygons, polygonIndex;
+  for ({ geometry } of geojson.features) {
+    if (geometry.type !== 'Polygon' && geometry.type !== 'MultiPolygon') continue;
+    polygons = geometry.coordinates;
+    for (polygonIndex = 0; polygonIndex < (geometry.type === 'Polygon' ? 1 : polygons.length); polygonIndex++) {
+      bridgePolygon(context, geometry.type === 'Polygon' ? polygons : polygons[polygonIndex]);
+    }
+  }
+  if (position.length) {
+    bridgeMeshByLayer.set(layer, createMesh(layer, /* alloc */ { position, normal, color }));
+  }
+}

package/src/geometry/addGeneratedTriangle.js

@@ -0,0 +1,7 @@
+import { triangleContexts } from '../globals/triangleContexts.js';
+
+import { addTriangle } from './appendAreaTriangle.js';
+
+export function addGeneratedTriangle(...args) {
+  addTriangle(triangleContexts[triangleContexts.length - 1], ...args);
+}

package/src/{sources/addTriangle.js → geometry/appendAreaTriangle.js}

@@ -1,7 +1,7 @@
-import { groundOffset } from './groundOffset.js';
-
+import { groundOffset } from '../sources/groundOffset.js';
+
 export function addTriangle(context, a, ah, b, bh, c, ch, nx, ny, nz, color) {
-  const { backend, positions, normals, colors, uvs } = context;
+  const { backend: layer, positions, normals, colors, uvs } = context;
   const ux = b.x - a.x, uy = bh - ah, uz = a.y - b.y;
   const vx = c.x - a.x, vy = ch - ah, vz = a.y - c.y;
   if ((uy * vz - uz * vy) * nx + (uz * vx - ux * vz) * ny + (ux * vy - uy * vx) * nz < 0) {
@@ -13,5 +13,5 @@ export function addTriangle(context, a, ah, b, bh, c, ch, nx, ny, nz, color) {
     c.x, ch + groundOffset(c), -c.y);
   normals.push(nx, ny, nz, nx, ny, nz, nx, ny, nz);
   colors.push(color.r, color.g, color.b, color.r, color.g, color.b, color.r, color.g, color.b);
-  if (backend.options.nightLight) uvs.push(...a.uv, ...b.uv, ...c.uv);
-}
+  if (layer.options.nightLight) uvs.push(...a.uv, ...b.uv, ...c.uv);
+}

package/src/geometry/appendRouteDash.js

@@ -0,0 +1,15 @@
+export function appendRouteDash(position, normal, color, a, b, dx, dz, x, z, start, end, r, g, blue) {
+  const px = a[0] + dx * start, pz = a[1] + dz * start;
+  const py = a[2] + (b[2] - a[2]) * start + 0.4;
+  const qx = a[0] + dx * end, qz = a[1] + dz * end;
+  const qy = a[2] + (b[2] - a[2]) * end + 0.4;
+  let vertex;
+  for (vertex = 0; vertex < 6; vertex++) {
+    if (vertex === 0 || vertex === 3) position.push(px - x, py, pz - z);
+    else if (vertex === 1) position.push(px + x, py, pz + z);
+    else if (vertex === 5) position.push(qx - x, qy, qz - z);
+    else position.push(qx + x, qy, qz + z);
+    normal.push(0, 1, 0);
+    color.push(r, g, blue);
+  }
+}

package/src/geometry/appendRouteSegment.js

@@ -0,0 +1,15 @@
+import { appendRouteDash } from './appendRouteDash.js';
+
+export function appendRouteSegment(position, normal, color, points, lengths, i, r, g, blue) {
+  const a = points[i - 1], b = points[i];
+  const dx = b[0] - a[0], dz = b[1] - a[1], length = lengths[i] - lengths[i - 1];
+  if (!length) return;
+  const x = -dz / length * 2.5, z = dx / length * 2.5;
+  let distance, start, end;
+  for (distance = Math.floor(lengths[i - 1] / 30) * 30; distance < lengths[i]; distance += 30) {
+    start = Math.max(0, (distance - lengths[i - 1]) / length);
+    end = Math.min(1, (distance + 18 - lengths[i - 1]) / length);
+    if (end <= start) continue;
+    appendRouteDash(position, normal, color, a, b, dx, dz, x, z, start, end, r, g, blue);
+  }
+}

package/src/geometry/assembleAreaGeometry.js

@@ -0,0 +1,41 @@
+import { buildProjectedPolygon } from './buildProjectedPolygon.js';
+import { buildProjectedPoint } from './buildProjectedPoint.js';
+import { instanceAreaGeometry } from './instanceAreaGeometry.js';
+import { computeBounds } from './computeBounds.js';
+
+export function assembleAreaGeometry({ jobs, nightLight }) {
+  const context = /* alloc */ {
+    backend: /* alloc */ { options: /* alloc */ { nightLight } },
+    positions: /* alloc */ [], normals: /* alloc */ [], colors: /* alloc */ [], uvs: /* alloc */ [],
+    featureFaces: /* alloc */ [], lights: /* alloc */ [], supports: /* alloc */ new Set(),
+  };
+  let job, polygon, start, end;
+  for (job of jobs) {
+    start = context.positions.length / 3;
+    if (job.point) buildProjectedPoint(context, job.point, job.style, job.baseColor, job.support);
+    for (polygon of job.polygons) {
+      buildProjectedPolygon(context, polygon, job.style.top, job.style.bottom, job.baseColor);
+    }
+    end = context.positions.length / 3;
+    context.featureFaces.push(/* alloc */ { vertexStart: start, vertexEnd: end, faceStart: start / 3, faceEnd: end / 3 });
+  }
+  const data = instanceAreaGeometry(context);
+  const result = /* alloc */ {
+    positions: /* alloc */ new Float32Array(data.positions),
+    normals: /* alloc */ new Float32Array(data.normals),
+    colors: /* alloc */ new Float32Array(data.colors),
+    uvs: /* alloc */ new Float32Array(context.uvs),
+    instanceOffsets: data.instanceOffsets,
+    ranges: context.featureFaces,
+    lights: context.lights,
+  };
+  if (result.positions.length) {
+    const geometry = /* alloc */ { attributes: /* alloc */ {
+      position: /* alloc */ { data: result.positions },
+      instanceOffset: result.instanceOffsets ? /* alloc */ { data: result.instanceOffsets, size: 4 } : undefined,
+    } };
+    computeBounds(geometry);
+    result.bounds = geometry.bounds;
+  }
+  return result;
+}

package/src/geometry/boundsQuad.js

@@ -0,0 +1,12 @@
+import { localPosition } from '../projections/localPosition.js';
+
+export function boundsQuad(state, bounds) {
+  const positions = /* alloc */ [];
+  let i, corner;
+  for (i = 0; i < 4; i++) {
+    corner = i === 0 ? bounds.getNorthWest() : i === 1 ? bounds.getNorthEast()
+      : i === 2 ? bounds.getSouthWest() : bounds.getSouthEast();
+    positions.push(localPosition(state, corner));
+  }
+  return positions;
+}

package/src/geometry/box.js

@@ -1,3 +1,8 @@
 export function box(x0, x1, z0, z1) {
-  return [[x0, z0], [x1, z0], [x1, z1], [x0, z1]];
+  return /* alloc */ [
+    /* alloc */ [x0, z0],
+    /* alloc */ [x1, z0],
+    /* alloc */ [x1, z1],
+    /* alloc */ [x0, z1],
+  ];
 }

package/src/geometry/bridgeEdge.js

@@ -0,0 +1,11 @@
+export function bridgeEdge(context, p, q) {
+  const { position, normal, color } = context;
+  const length = Math.hypot(q[0] - p[0], q[2] - p[2]) || 1;
+  const nx = (q[2] - p[2]) / length, nz = -(q[0] - p[0]) / length;
+  let k, corner;
+  for (k = 0; k < 6; k++) {
+    corner = k === 0 || k === 3 || k === 5 ? p : q;
+    position.push(corner[0], corner[1] - (k === 2 || k >= 4 ? 1.2 : 0), corner[2]);
+    normal.push(nx, 0, nz); color.push(0.6, 0.58, 0.54);
+  }
+}

package/src/geometry/bridgeElevation.js

@@ -1,8 +1,10 @@
 /** Height inside a bridge deck, or null outside its triangles. */
 export function bridgeElevation(point, bridges) {
   // Bridges bucketed by 64 DEM pixels.
+  const bucket = bridges?.get(`${Math.floor(point.x / 64)}/${Math.floor(point.y / 64)}`);
+  if (!bucket) return null;
   let bridge, a, b, c, d, u, v;
-  for (bridge of bridges?.get(`${Math.floor(point.x / 64)}/${Math.floor(point.y / 64)}`) || []) {
+  for (bridge of bucket) {
     if (point.x < bridge.min[0] || point.x > bridge.max[0] || point.y < bridge.min[1] || point.y > bridge.max[1]) {
       continue;
     }

package/src/geometry/bridgeFaces.js

@@ -0,0 +1,15 @@
+export function bridgeFaces(context, points, triangles) {
+  const { position, normal, color } = context;
+  let a, b, c, pa, pb, pc, i, k, p;
+  for ([a, b, c] of triangles) {
+    // Counter-clockwise seen from above, so double-sided shading keeps the top lit.
+    pa = points[a]; pb = points[b]; pc = points[c];
+    if ((pb[2] - pa[2]) * (pc[0] - pa[0]) - (pb[0] - pa[0]) * (pc[2] - pa[2]) < 0) { i = b; b = c; c = i; }
+    for (k = 0; k < 6; k++) {
+      i = k === 0 || k === 3 ? a : k === 1 || k === 5 ? b : c;
+      p = points[i];
+      position.push(p[0], p[1] - (k >= 3 ? 1.2 : 0), p[2]);
+      normal.push(0, k >= 3 ? -1 : 1, 0); color.push(0.6, 0.58, 0.54);
+    }
+  }
+}

package/src/geometry/bridgePaths.js

@@ -0,0 +1,11 @@
+export function bridgePaths(rings, pixels) {
+  const paths = /* alloc */ [];
+  let start = 0, ring, path, i;
+  for (ring of rings) {
+    path = /* alloc */ [];
+    for (i = 0; i < ring.length; i++) path.push(/* alloc */ { x: pixels[start + i][0], y: pixels[start + i][1] });
+    paths.push(path);
+    start += ring.length;
+  }
+  return paths;
+}

package/src/geometry/bridgePolygon.js

@@ -0,0 +1,31 @@
+import { triangulate } from '../triangulation/triangulate.js';
+import { local } from '../projections/projectBridgePoint.js';
+import { bridgePaths } from './bridgePaths.js';
+import { indexBridge } from './indexBridge.js';
+import { bridgeFaces } from './bridgeFaces.js';
+import { bridgeSides } from './bridgeSides.js';
+
+export function bridgePolygon(context, polygon) {
+  const { backend: layer, map, zoom, crs, origin, metres, base } = context;
+  const rings = /* alloc */ [];
+  let ring, path, lng, lat, z, p, coordinate, paths, contour, holes, triangles;
+  for (ring of polygon) {
+    path = ring.slice(0, -1);
+    if (path.length >= 3) rings.push(path);
+  }
+  if (!rings.length) return;
+  const pixels = /* alloc */ [], points = /* alloc */ [];
+  for (ring of rings) for ([lng, lat, z] of ring) {
+    p = map.project(/* alloc */ [lat, lng], zoom);
+    pixels.push(/* alloc */ [p.x, p.y, z]);
+  }
+  for (ring of rings) for (coordinate of ring) points.push(local(coordinate, crs, origin, metres, base));
+  try {
+    paths = bridgePaths(rings, pixels);
+    [contour, ...holes] = paths;
+    triangles = triangulate(contour, holes);
+  } catch { return; }
+  indexBridge(layer, pixels, triangles);
+  bridgeFaces(context, points, triangles);
+  bridgeSides(context, points, rings);
+}

package/src/geometry/bridgeSides.js

@@ -0,0 +1,11 @@
+import { bridgeEdge } from './bridgeEdge.js';
+
+export function bridgeSides(context, points, rings) {
+  let start = 0, ring, i;
+  for (ring of rings) {
+    for (i = 0; i < ring.length; i++) {
+      bridgeEdge(context, points[start + i], points[start + (i + 1) % ring.length]);
+    }
+    start += ring.length;
+  }
+}

package/src/geometry/buildExtrudedPolygon.js

@@ -0,0 +1,10 @@
+import { projectRing } from '../projections/projectRing.js';
+import { buildProjectedPolygon } from './buildProjectedPolygon.js';
+
+export function buildAreaPolygon(context, rings, top, bottom, baseColor) {
+  if (!rings.length) throw /* alloc */ new Error('Empty GeoJSON polygon');
+  const paths = /* alloc */ [];
+  let ring;
+  for (ring of rings) paths.push(projectRing(context, ring));
+  buildProjectedPolygon(context, paths, top, bottom, baseColor);
+}