leaflet-city-mapper 0.0.3 → 0.0.5

package/src/geometry/lampPostGeometry.js

@@ -1,20 +1,26 @@
-import { parseColor } from "../utils/parseColor.js";
-import { ring } from './lampRing.js';
+import { parseColor } from "../colors/parseColor.js";
+import { ring } from './createLampRing.js';
+import { lampDirections } from '../globals/lampDirections.js';
 
 /** Schematic support and lamp head; wall-mounted fixtures do not get an invented pole. */
 
 export function lampPostGeometry(point, style, addTriangle) {
   const color = parseColor(0x50565a), radius = style.poleRadius;
   if (!Number.isFinite(radius) || radius <= 0) {
-    throw new Error('Invalid lamp pole radius');
+    throw /* alloc */ new Error('Invalid lamp pole radius');
   }
-  const center = { ...point, uv: [3, 3] };
-  let r, low, high, points, i, a, b, angle, nx, nz;
-  for ([r, low, high] of [[radius, 0, style.top], [radius * 2.5, style.top - 0.25, style.top + 0.15]]) {
+  const center = /* alloc */ {
+    ...point, uv: /* alloc */ [3, 3],
+  };
+  let r, low, high, points, i, a, b, nx, nz, section;
+  for (section = 0; section < 2; section++) {
+    r = section ? radius * 2.5 : radius;
+    low = section ? style.top - 0.25 : 0;
+    high = section ? style.top + 0.15 : style.top;
     points = ring(point, r);
     for (i = 0; i < 6; i++) {
-      a = points[i], b = points[(i + 1) % 6], angle = (i + 0.5) * Math.PI / 3;
-      nx = Math.cos(angle), nz = -Math.sin(angle);
+      a = points[i], b = points[(i + 1) % 6];
+      nx = lampDirections[i].nx, nz = lampDirections[i].nz;
       addTriangle(a, low, b, low, b, high, nx, 0, nz, color);
       addTriangle(a, low, b, high, a, high, nx, 0, nz, color);
       addTriangle(center, high, a, high, b, high, 0, 1, 0, color);

package/src/geometry/lightGeometry.js

@@ -1,15 +1,15 @@
-import { parseColor } from "../utils/parseColor.js";
+import { parseColor } from "../colors/parseColor.js";
 import { quad } from './quad.js';
 import { emitter } from './emitter.js';
 
 /** Three crossed emitter discs; illumination itself is evaluated on receiving surfaces. */
 
 export function lightGeometry(point, style, addTriangle) {
-  if (!Number.isFinite(style.lightRadius) || style.lightRadius <= 0) throw new Error('Invalid light radius');
+  if (!Number.isFinite(style.lightRadius) || style.lightRadius <= 0) throw /* alloc */ new Error('Invalid light radius');
   const color = parseColor(style.color);
   let axis;
   for (axis = 0; axis < 3; axis++) {
     quad(addTriangle, color, emitter(point, -1, -1, axis), emitter(point, 1, -1, axis), emitter(point, 1, 1, axis), emitter(point, -1, 1, axis),
-      style.top, axis === 0 ? [0, 1, 0] : axis === 1 ? [0, 0, 1] : [1, 0, 0]);
+      style.top, axis === 2 ? 1 : 0, axis === 0 ? 1 : 0, axis === 1 ? 1 : 0);
   }
 }

package/src/geometry/line.js

@@ -1,54 +1,21 @@
-import { triangle } from './nativeTriangle.js';
-import { disk } from './disk.js';
-import { segment } from './segment.js';
-
-export function line(context, points, closed) {
-  const { options, width, dash, stroke, point } = context;
-  if (!options.stroke || width <= 0 || points.length < 2) return;
-  const radius = width / 2;
-  let distance = Number(options.dashOffset) || 0;
-  let period = 0;
-  let value, i, a, b, length, previous, previousLength, incoming, outgoing, side, n1, n2, from, to;
-  let denominator, miter, offset, phase, index, end, delta;
-  for (value of dash) period += value;
-  for (i = 0; i < points.length - (closed ? 0 : 1); i++) {
-    a = points[i], b = points[(i + 1) % points.length], length = a.distanceTo(b);
-    if (!dash.length) {
-      segment(context, a, b, !closed && i === 0, !closed && i === points.length - 2);
-      if (closed || i > 0) {
-        if (options.lineJoin === 'round') disk(point, a, radius, stroke);
-        else {
-          previous = a.subtract(points[(i + points.length - 1) % points.length]);
-          previousLength = Math.hypot(previous.x, previous.y);
-          if (previousLength && length) {
-            incoming = previous.divideBy(previousLength);
-            outgoing = b.subtract(a).divideBy(length);
-            side = incoming.x * outgoing.y - incoming.y * outgoing.x > 0 ? -1 : 1;
-            n1 = new L.Point(-incoming.y * side, incoming.x * side);
-            n2 = new L.Point(-outgoing.y * side, outgoing.x * side);
-            from = a.add(n1.multiplyBy(radius)), to = a.add(n2.multiplyBy(radius));
-            denominator = 1 + n1.x * n2.x + n1.y * n2.y;
-            miter = denominator > 0 ? n1.add(n2).multiplyBy(radius / denominator) : null;
-            triangle(point, stroke, from, a, to);
-            if (options.lineJoin === 'miter' && miter && Math.hypot(miter.x, miter.y) <= radius * 4) {
-              triangle(point, stroke, from, a.add(miter), to);
-            }
-          }
-        }
-      }
-    } else {
-      offset = 0;
-      while (offset < length) {
-        phase = ((distance + offset) % period + period) % period, index = 0;
-        while (phase >= dash[index]) phase -= dash[index++];
-        end = Math.min(length, offset + dash[index] - phase);
-        if (index % 2 === 0) {
-          delta = b.subtract(a).divideBy(length);
-          segment(context, a.add(delta.multiplyBy(offset)), a.add(delta.multiplyBy(end)), true, true);
-        }
-        offset = end;
-      }
-    }
-    distance += length;
-  }
-}
+import { segment } from './segment.js';
+import { lineJoin } from './lineJoin.js';
+import { dashedSegment } from './dashedSegment.js';
+
+export function line(context, points, closed) {
+  const { options, width, dash } = context;
+  if (!options.stroke || width <= 0 || points.length < 2) return;
+  let distance = Number(options.dashOffset) || 0;
+  let period = 0, value, i, a, b, length;
+  for (value of dash) period += value;
+  for (i = 0; i < points.length - (closed ? 0 : 1); i++) {
+    a = points[i], b = points[(i + 1) % points.length], length = a.distanceTo(b);
+    if (!dash.length) {
+      segment(context, a, b, !closed && i === 0, !closed && i === points.length - 2);
+      if (closed || i > 0) lineJoin(context, points, i, b, length);
+    } else {
+      dashedSegment(context, a, b, length, distance, period);
+    }
+    distance += length;
+  }
+}

package/src/geometry/lineJoin.js

@@ -0,0 +1,26 @@
+import { L } from '../globals/L.js';
+import { triangle } from './appendNativeTriangle.js';
+import { disk } from './disk.js';
+
+export function lineJoin(context, points, i, b, length) {
+  const { options, width, point, stroke } = context;
+  const a = points[i], radius = width / 2;
+  if (options.lineJoin === 'round') {
+    disk(point, a, radius, stroke);
+    return;
+  }
+  const previous = a.subtract(points[(i + points.length - 1) % points.length]);
+  const previousLength = Math.hypot(previous.x, previous.y);
+  if (!previousLength || !length) return;
+  const incoming = previous.divideBy(previousLength), outgoing = b.subtract(a).divideBy(length);
+  const side = incoming.x * outgoing.y - incoming.y * outgoing.x > 0 ? -1 : 1;
+  const n1 = /* alloc */ new L.Point(-incoming.y * side, incoming.x * side);
+  const n2 = /* alloc */ new L.Point(-outgoing.y * side, outgoing.x * side);
+  const from = a.add(n1.multiplyBy(radius)), to = a.add(n2.multiplyBy(radius));
+  const denominator = 1 + n1.x * n2.x + n1.y * n2.y;
+  const miter = denominator > 0 ? n1.add(n2).multiplyBy(radius / denominator) : null;
+  triangle(point, stroke, from, a, to);
+  if (options.lineJoin === 'miter' && miter && Math.hypot(miter.x, miter.y) <= radius * 4) {
+    triangle(point, stroke, from, a.add(miter), to);
+  }
+}

package/src/geometry/markerImageBounds.js

@@ -0,0 +1,11 @@
+export function markerImageBounds(state, key, image) {
+  const options = state.source.options.icon.options;
+  const dimensions = options[key === 'shadow' ? 'shadowSize' : 'iconSize'];
+  const bounds = state.markerImageBounds ||= /* alloc */ [0, 0, 0, 0];
+  bounds[0] = dimensions ? dimensions.x ?? dimensions[0] : image.naturalWidth;
+  bounds[1] = dimensions ? dimensions.y ?? dimensions[1] : image.naturalHeight;
+  const anchor = (key === 'shadow' && options.shadowAnchor) || options.iconAnchor;
+  bounds[2] = anchor ? anchor.x ?? anchor[0] : Math.floor(bounds[0] / 2);
+  bounds[3] = anchor ? anchor.y ?? anchor[1] : Math.floor(bounds[1] / 2);
+  return bounds;
+}

package/src/geometry/markerQuadCorners.js

@@ -0,0 +1,51 @@
+import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
+import { coreMatrixKeys } from '../globals/coreMatrixKeys.js';
+import { markerCameraIconPoint } from '../projections/markerCameraIconPoint.js';
+
+import { localPosition } from '../projections/localPosition.js';
+
+import { transformNativePoint } from '../transforms/transformNativePoint.js';
+import { markerImageBounds } from './markerImageBounds.js';
+
+export function markerQuadCorners(state, key, image) {
+  const { source, map, backend: layer } = state;
+
+  const position = localPosition(state, source.getLatLng());
+  const size = map.getSize();
+  const matrices = state.markerMatrices ||= /* alloc */ {
+    root: /* alloc */ new DOMMatrix(),
+    camera: /* alloc */ new DOMMatrix(),
+    point: /* alloc */ { x: 0, y: 0, z: 0, w: 1 },
+  };
+  const root = matrices.root, camera = matrices.camera, point = matrices.point;
+  const worldMatrix = rootByLayer.get(layer).worldMatrix, projection = cameraByLayer.get(layer).projectionViewMatrix;
+  let i, keyName;
+  for (i = 0; i < 16; i++) {
+    keyName = coreMatrixKeys[i];
+    root[keyName] = worldMatrix[i];
+    camera[keyName] = projection[i];
+  }
+  transformNativePoint(point, root, position[0], position[1], position[2], 1);
+  transformNativePoint(point, camera, point.x, point.y, point.z, point.w);
+  const clipX = point.x, clipY = point.y, clipZ = point.z, clipW = point.w;
+  camera.invertSelf();
+  root.invertSelf();
+  const [width, height, anchorX, anchorY] = markerImageBounds(state, key, image);
+  const centerX = (clipX / clipW + 1) * size.x / 2, centerY = (1 - clipY / clipW) * size.y / 2;
+  const left = centerX - anchorX;
+  const top = centerY - anchorY;
+  const corners = /* alloc */ [];
+  let pointX, pointY, offset, x, y;
+  for (i = 0; i < 4; i++) {
+    pointX = left + (i % 2 ? width : 0);
+    pointY = top + (i < 2 ? 0 : height);
+    offset = markerCameraIconPoint(source, pointX - centerX, pointY - centerY);
+    x = centerX + offset.x, y = centerY + offset.y;
+    transformNativePoint(point, camera, x / size.x * 2 - 1, 1 - y / size.y * 2, clipZ / clipW, 1);
+    transformNativePoint(point, root, point.x / point.w, point.y / point.w, point.z / point.w, 1);
+    corners.push(/* alloc */ [point.x, point.y, point.z]);
+  }
+  return corners;
+}

package/src/geometry/meshShadowBounds.js

@@ -0,0 +1,24 @@
+export function meshShadowBounds(mesh, bounds, matrix) {
+  let cached = mesh._shadowBounds;
+  if (!cached || cached.version !== mesh._worldMatrixVersion || cached.bounds !== bounds) {
+    cached ||= mesh._shadowBounds = /* alloc */ {
+      min: /* alloc */ [Infinity, Infinity, Infinity],
+      max: /* alloc */ [-Infinity, -Infinity, -Infinity],
+    };
+    cached.version = mesh._worldMatrixVersion;
+    cached.bounds = bounds;
+    cached.min.fill(Infinity); cached.max.fill(-Infinity);
+    let i, x, y, z, w, axis, value;
+    for (i = 0; i < 8; i++) {
+      x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
+      z = i & 4 ? bounds.max[2] : bounds.min[2];
+      w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
+      for (axis = 0; axis < 3; axis++) {
+        value = (matrix[axis] * x + matrix[axis + 4] * y + matrix[axis + 8] * z + matrix[axis + 12]) / w;
+        cached.min[axis] = Math.min(cached.min[axis], value);
+        cached.max[axis] = Math.max(cached.max[axis], value);
+      }
+    }
+  }
+  return cached;
+}

package/src/geometry/nativeGeometry.js

@@ -1,55 +1,21 @@
-import { triangulate } from '../triangulation/triangulate.js';
-import { disk } from './disk.js';
-import { circleAt } from './circleAt.js';
-import { line } from './line.js';
-import { visit } from './visit.js';
+import { L } from '../globals/L.js';
+import { visit } from './visitNativeCoordinates.js';
+import { dashValues } from './dashValues.js';
+import { circleGeometry } from './circleGeometry.js';
 
 /** Leaflet paths become flat triangles; pixel-sized strokes are rebuilt on zoom. */
 export function nativeGeometry(source, map, point) {
-  const fill = [], stroke = [], options = source.options;
+  const fill = /* alloc */ [];
+  const stroke = /* alloc */ [];
+  const options = source.options;
   const width = Number(options.weight) || 0;
-  const values = Array.isArray(options.dashArray) ? options.dashArray :
-    String(options.dashArray || '').trim().split(/[ ,]+/);
-  const dash = [];
-  let value, index, i;
-  for (value of values) dash.push(Number(value));
-  let allZero = true;
-  for (value of dash) {
-    if (!Number.isFinite(value) || value < 0) throw new Error('Invalid Leaflet dashArray');
-    if (value !== 0) allZero = false;
-  }
-  if (allZero) dash.length = 0;
-  if (dash.length % 2) dash.push(...dash);
-  const context = { fill, stroke, options, width, dash, point, map };
+  const dash = dashValues(options);
+  const context = /* alloc */ { fill, stroke, options, width, dash, point, map };
   if (source instanceof L.CircleMarker) {
-    const center = map.project(source.getLatLng());
-    let radius = source.getRadius(), radiusY = radius;
-    if (source instanceof L.Circle) {
-      source._project();
-      const projected = source._point.add(map.getPixelOrigin());
-      center.x = projected.x;
-      center.y = projected.y;
-      radius = source._radius;
-      radiusY = source._radiusY || radius;
-    }
-    if (options.fill) disk(point, center, radius, fill, radiusY);
-    const count = Math.max(12, Math.min(128, Math.ceil(Math.PI * Math.sqrt(Math.max(radius, radiusY)))));
-    if (dash.length) {
-      const points = [];
-      for (index = 0; index < count; index++) points.push(circleAt(center, radius, radiusY, count, index));
-      line(context, points, true);
-    }
-    else if (options.stroke && width > 0) {
-      for (i = 0; i < count; i++) {
-        triangle(point, stroke, circleAt(center, radius, radiusY, count, i, width / 2),
-          circleAt(center, radius, radiusY, count, i, -width / 2), circleAt(center, radius, radiusY, count, i + 1, width / 2));
-        triangle(point, stroke, circleAt(center, radius, radiusY, count, i + 1, width / 2),
-          circleAt(center, radius, radiusY, count, i, -width / 2), circleAt(center, radius, radiusY, count, i + 1, -width / 2));
-      }
-    }
+    circleGeometry(source, context);
   } else {
     const closed = source instanceof L.Polygon;
     visit(context, source.getLatLngs(), closed);
   }
-  return { fill, stroke };
+  return /* alloc */ { fill, stroke };
 }

package/src/geometry/offsetBelowGround.js

@@ -0,0 +1,3 @@
+export function below(p) {
+  return /* alloc */ [p[0], p[1] - 1.2, p[2]];
+}

package/src/geometry/polygon.js

@@ -1,17 +1,18 @@
-import { triangle } from './nativeTriangle.js';
+import { triangle } from './appendNativeTriangle.js';
 import { line } from './line.js';
 import { triangulate } from '../triangulation/triangulate.js';
 
 export function polygon(context, rings, closed) {
-  const { options, fill, point, map } = context, projected = [];
+  const { options, fill, point, map } = context;
+  const projected = /* alloc */ [];
   let ring, path, latlng, indices;
   for (ring of rings) {
-    path = [];
+    path = /* alloc */ [];
     for (latlng of ring) path.push(map.project(latlng));
     projected.push(path);
   }
   if (closed && options.fill && projected[0]?.length >= 3) {
-    const valid = [];
+    const valid = /* alloc */ [];
     for (ring of projected) if (ring.length >= 3) valid.push(ring);
     const vertices = valid.flat();
     for (indices of triangulate(valid[0], valid.slice(1))) {

package/src/geometry/quad.js

@@ -1,4 +1,9 @@
-export function quad(addTriangle, color, a, b, c, d, height, normal) {
-  addTriangle(a, height, b, height, c, height, ...normal, color);
-  addTriangle(a, height, c, height, d, height, ...normal, color);
+export function quad(addTriangle, color, a, b, c, d, height, nx, ny, nz) {
+  if (typeof nx !== 'number') {
+    addTriangle(a, height, b, height, c, height, ...nx, color);
+    addTriangle(a, height, c, height, d, height, ...nx, color);
+  } else {
+    addTriangle(a, height, b, height, c, height, nx, ny, nz, color);
+    addTriangle(a, height, c, height, d, height, nx, ny, nz, color);
+  }
 }

package/src/geometry/restoreGeometry.js

@@ -0,0 +1,23 @@
+export function restoreGeometry(geometry, device) {
+  if (geometry.attributes.index?.data instanceof Uint8Array) {
+    geometry.attributes.index.data = /* alloc */ new Uint16Array(geometry.attributes.index.data);
+  }
+  let name, attribute, oldBuffer;
+  for (name in geometry.attributes) {
+    attribute = geometry.attributes[name];
+    attribute.size ||= 1;
+    attribute.count = attribute.data.length / attribute.size;
+    attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
+    oldBuffer = attribute.buffer;
+    attribute.buffer = device.createBuffer(/* alloc */ {
+      size: Math.max(4, attribute.data.byteLength),
+      usage: name === 'index'
+        ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+        : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+    oldBuffer?.destroy();
+  }
+  geometry.device = device;
+  geometry.drawRange.count = geometry.attributes.index?.count || geometry.attributes.position.count;
+}

package/src/geometry/roofCoverage.js

@@ -1,52 +1,26 @@
-/** Test the mesh's ground footprint against loaded imagery, including coarse parent tiles. */
-export function roofCoverage(mesh, backend, rasters) {
-  const map = backend._map, bounds = mesh.geometry.bounds, world = mesh.worldMatrix;
-  let intersectsArchive = false;
-  let layer, zoom, origin, scale, min, max, i, x, y, z, px, py, nw, se, remaining, tile, size, left;
-  let top, pieces, x0, y0, x1, y1, l, t, r, b;
-  for (layer of rasters) {
-    zoom = layer._tileZoom, origin = map.project(backend._sceneOrigin, zoom);
-    scale = map.options.crs.scale(zoom) / (40075016.68557849 * Math.cos(backend._sceneOrigin.lat * Math.PI / 180));
-    min = [Infinity, Infinity], max = [-Infinity, -Infinity];
-    for (i = 0; i < 8; i++) {
-      x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
-      z = i & 4 ? bounds.max[2] : bounds.min[2];
-      px = origin.x + (world[0] * x + world[4] * y + world[8] * z + world[12]) * scale;
-      py = origin.y + (world[2] * x + world[6] * y + world[10] * z + world[14]) * scale;
-      min[0] = Math.min(min[0], px); min[1] = Math.min(min[1], py);
-      max[0] = Math.max(max[0], px); max[1] = Math.max(max[1], py);
-    }
-    if (layer.header.maxLat !== undefined && layer.header.minLon !== undefined &&
-      layer.header.minLat !== undefined && layer.header.maxLon !== undefined) {
-      nw = map.project([layer.header.maxLat, layer.header.minLon], zoom);
-      se = map.project([layer.header.minLat, layer.header.maxLon], zoom);
-      min[0] = Math.max(min[0], nw.x); min[1] = Math.max(min[1], nw.y);
-      max[0] = Math.min(max[0], se.x); max[1] = Math.min(max[1], se.y);
-      if (min[0] >= max[0] || min[1] >= max[1]) continue;
-    }
-    intersectsArchive = true;
-    remaining = [[min[0], min[1], max[0], max[1]]];
-    for (tile of layer._rasterTiles.values()) {
-      // Failed imagery already reports an error; do not hide the building indefinitely.
-      if (!tile.done && !tile.error) continue;
-      size = 256 * 2 ** (zoom - tile.coords.z);
-      left = tile.coords.x * size, top = tile.coords.y * size;
-      pieces = [];
-      for ([x0, y0, x1, y1] of remaining) {
-        l = Math.max(x0, left), t = Math.max(y0, top);
-        r = Math.min(x1, left + size), b = Math.min(y1, top + size);
-        if (l >= r || t >= b) {
-          pieces.push([x0, y0, x1, y1]);
-          continue;
-        }
-        if (y0 < t) pieces.push([x0, y0, x1, t]);
-        if (b < y1) pieces.push([x0, b, x1, y1]);
-        if (x0 < l) pieces.push([x0, t, l, b]);
-        if (r < x1) pieces.push([r, t, x1, b]);
-      }
-      remaining = pieces;
-      if (!remaining.length) return true;
-    }
-  }
-  return !intersectsArchive;
-}
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { tileZoomByLayer } from '../weakmaps/tileZoomByLayer.js';
+
+import { roofFootprint } from './roofFootprint.js';
+import { subtractRoofTile } from './subtractRoofTile.js';
+
+/** Test the mesh's ground footprint against loaded imagery, including coarse parent tiles. */
+export function roofCoverage(mesh, layer, rasters) {
+  let intersectsArchive = false, pending = false;
+  let rasterLayer, footprint, remaining, tile;
+  for (rasterLayer of rasters) {
+    if (!headerByLayer.get(rasterLayer)) { pending = true; continue; }
+    footprint = roofFootprint(mesh, layer, rasterLayer);
+    if (!footprint) continue;
+    intersectsArchive = true;
+    remaining = /* alloc */ [footprint];
+    for (tile of rasterTilesByLayer.get(rasterLayer).values()) {
+      // Failed imagery already reports an error; do not hide the building indefinitely.
+      if (!tile.done && !tile.error) continue;
+      remaining = subtractRoofTile(remaining, tile, tileZoomByLayer.get(rasterLayer));
+      if (!remaining.length) return true;
+    }
+  }
+  return !intersectsArchive && !pending;
+}

package/src/geometry/roofFootprint.js

@@ -0,0 +1,32 @@
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
+import { tileZoomByLayer } from '../weakmaps/tileZoomByLayer.js';
+
+import { radians } from '../globals/radians.js';
+import { earthCirc } from '../globals/earthCirc.js';
+
+export function roofFootprint(mesh, layer, rasterLayer) {
+  const map = layer._map, bounds = mesh.geometry.bounds, world = mesh.worldMatrix;
+  const zoom = tileZoomByLayer.get(rasterLayer)
+  const origin = map.project(sceneOriginByLayer.get(layer), zoom);
+  const scale = map.options.crs.scale(zoom) / (earthCirc * Math.cos(sceneOriginByLayer.get(layer).lat * radians));
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let i, x, y, z, px, py, nw, se;
+  for (i = 0; i < 8; i++) {
+    x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
+    z = i & 4 ? bounds.max[2] : bounds.min[2];
+    px = origin.x + (world[0] * x + world[4] * y + world[8] * z + world[12]) * scale;
+    py = origin.y + (world[2] * x + world[6] * y + world[10] * z + world[14]) * scale;
+    minX = Math.min(minX, px); minY = Math.min(minY, py);
+    maxX = Math.max(maxX, px); maxY = Math.max(maxY, py);
+  }
+  if (headerByLayer.get(rasterLayer).maxLat !== undefined && headerByLayer.get(rasterLayer).minLon !== undefined &&
+    headerByLayer.get(rasterLayer).minLat !== undefined && headerByLayer.get(rasterLayer).maxLon !== undefined) {
+    nw = map.project(/* alloc */ [headerByLayer.get(rasterLayer).maxLat, headerByLayer.get(rasterLayer).minLon], zoom);
+    se = map.project(/* alloc */ [headerByLayer.get(rasterLayer).minLat, headerByLayer.get(rasterLayer).maxLon], zoom);
+    minX = Math.max(minX, nw.x); minY = Math.max(minY, nw.y);
+    maxX = Math.min(maxX, se.x); maxY = Math.min(maxY, se.y);
+    if (minX >= maxX || minY >= maxY) return null;
+  }
+  return /* alloc */ [minX, minY, maxX, maxY];
+}

package/src/geometry/routeGeometry.js

@@ -0,0 +1,21 @@
+import { appendRouteSegment } from './appendRouteSegment.js';
+
+/** Dashed lane outline, in layer-local metres. */
+
+export function routeGeometry(lanes) {
+  const position = /* alloc */ [];
+  const normal = /* alloc */ [];
+  const color = /* alloc */ [];
+  let points, lengths, properties, raw, rgb, r, g, blue, i;
+  for ({ points, lengths, properties } of lanes) {
+    raw = properties?.route_color;
+    rgb = /^[\da-f]{6}$/i.test(raw) ? Number.parseInt(raw, 16) : null;
+    r = rgb === null ? 0.08 : (rgb >> 16 & 255) / 255;
+    g = rgb === null ? 0.7 : (rgb >> 8 & 255) / 255;
+    blue = rgb === null ? 0.85 : (rgb & 255) / 255;
+    for (i = 1; i < points.length; i++) {
+      appendRouteSegment(position, normal, color, points, lengths, i, r, g, blue);
+    }
+  }
+  return /* alloc */ { position, normal, color };
+}

package/src/geometry/segment.js

@@ -1,4 +1,5 @@
-import { triangle } from './nativeTriangle.js';
+import { L } from '../globals/L.js';
+import { triangle } from './appendNativeTriangle.js';
 import { disk } from './disk.js';
 
 export function segment(context, a, b, startCap, endCap) {
@@ -7,7 +8,7 @@ export function segment(context, a, b, startCap, endCap) {
   const length = a.distanceTo(b);
   if (!length) return;
   const direction = b.subtract(a).divideBy(length);
-  const normal = new L.Point(-direction.y * radius, direction.x * radius);
+  const normal = /* alloc */ new L.Point(-direction.y * radius, direction.x * radius);
   if (options.lineCap === 'square') {
     if (startCap) a = a.subtract(direction.multiplyBy(radius));
     if (endCap) b = b.add(direction.multiplyBy(radius));

package/src/geometry/setVertexColor.js

@@ -7,9 +7,11 @@
  */
 
 export function setVertexColor(mesh, start, end, color) {
+  const rgb = /* alloc */ [];
   let i;
   for (i = start; i < end; i++) {
-    mesh.geometry.attributes.color.data.set([color.r, color.g, color.b], i * 3);
+    rgb[0] = color.r; rgb[1] = color.g; rgb[2] = color.b;
+    mesh.geometry.attributes.color.data.set(rgb, i * 3);
   }
   mesh.geometry.attributes.color.needsUpdate = true;
 }

package/src/geometry/shadowBounds.js

@@ -0,0 +1,23 @@
+import { computeBounds } from './computeBounds.js';
+import { meshShadowBounds } from './meshShadowBounds.js';
+
+export function shadowBounds(meshes, output = /* alloc */ {
+  min: /* alloc */ [Infinity, Infinity, Infinity],
+  max: /* alloc */ [-Infinity, -Infinity, -Infinity],
+}) {
+  const { min, max } = output;
+  min.fill(Infinity); max.fill(-Infinity);
+  let mesh, bounds, matrix, cached, axis;
+  for (mesh of meshes) {
+    if (!mesh.geometry.bounds || mesh.geometry.attributes.position.needsUpdate) computeBounds(mesh.geometry);
+    bounds = mesh.geometry.bounds, matrix = mesh.worldMatrix;
+    cached = meshShadowBounds(mesh, bounds, matrix);
+    for (axis = 0; axis < 3; axis++) {
+      min[axis] = Math.min(min[axis], cached.min[axis]);
+      max[axis] = Math.max(max[axis], cached.max[axis]);
+    }
+  }
+  // Include ground receivers below/around the loaded buildings and trees.
+  min[1] = Math.min(0, min[1]);
+  return output;
+}

package/src/geometry/subtractRoofTile.js

@@ -0,0 +1,19 @@
+export function subtractRoofTile(remaining, tile, zoom) {
+  const size = 256 * 2 ** (zoom - tile.coords.z);
+  const left = tile.coords.x * size, top = tile.coords.y * size;
+  const pieces = /* alloc */ [];
+  let x0, y0, x1, y1, l, t, r, b;
+  for ([x0, y0, x1, y1] of remaining) {
+    l = Math.max(x0, left), t = Math.max(y0, top);
+    r = Math.min(x1, left + size), b = Math.min(y1, top + size);
+    if (l >= r || t >= b) {
+      pieces.push(/* alloc */ [x0, y0, x1, y1]);
+      continue;
+    }
+    if (y0 < t) pieces.push(/* alloc */ [x0, y0, x1, t]);
+    if (b < y1) pieces.push(/* alloc */ [x0, b, x1, y1]);
+    if (x0 < l) pieces.push(/* alloc */ [x0, t, l, b]);
+    if (r < x1) pieces.push(/* alloc */ [r, t, x1, b]);
+  }
+  return pieces;
+}

package/src/geometry/subtractVector.js

@@ -0,0 +1,6 @@
+export function sub(a, b) {
+  const result = /* alloc */ new Array(a.length);
+  let i;
+  for (i = 0; i < result.length; i++) result[i] = a[i] - b[i];
+  return result;
+}

package/src/geometry/surface.js

@@ -1,5 +1,6 @@
-import { ring } from './treeRing.js';
-import { ringDirections } from '../constants/ringDirections.js';
+import { ringDirections } from '../globals/ringDirections.js';
+
+import { ring } from './createTreeRing.js';
 
 export function surface(point, addTriangle, lowRadius, low, highRadius, high, color) {
   const lower = ring(point, lowRadius), upper = ring(point, highRadius);