leaflet-city-mapper 0.0.3 → 0.0.4

package/src/geometry/circleAt.js

@@ -1,5 +1,7 @@
+import { tau } from '../globals/tau.js';
+import { L } from '../globals/L.js';
 export function circleAt(center, radius, radiusY, count, index, offset = 0) {
-  const angle = index * Math.PI * 2 / count;
-  return new L.Point(center.x + Math.max(0, radius + offset) * Math.cos(angle),
+  const angle = index * tau / count;
+  return /* alloc */ new L.Point(center.x + Math.max(0, radius + offset) * Math.cos(angle),
     center.y + Math.max(0, radiusY + offset) * Math.sin(angle));
 }

package/src/geometry/circleGeometry.js

@@ -0,0 +1,34 @@
+import { L } from '../globals/L.js';
+import { disk } from './disk.js';
+import { circleAt } from './circleAt.js';
+import { line } from './line.js';
+import { triangle } from './nativeTriangle.js';
+
+export function circleGeometry(source, context) {
+  const { map, point, fill, stroke, options, dash, width } = context;
+  const center = map.project(source.getLatLng());
+  let radius = source.getRadius(), radiusY = radius, index, i;
+  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 = /* alloc */ [];
+    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));
+    }
+  }
+}

package/src/geometry/clipLine.js

@@ -3,7 +3,7 @@ import { clipSegment } from './clipSegment.js';
 
 /** Clip a geographic line to [west, south, east, north] without joining disjoint pieces. */
 export function clipLine(line, bounds) {
-  const pieces = [];
+  const pieces = /* alloc */ [];
   let current;
   let i, segment;
   for (i = 1; i < line.length; i++) {

package/src/geometry/clipSegment.js

@@ -1,19 +1,23 @@
 export function clipSegment(a, b, bounds) {
   const [west, south, east, north] = bounds;
   const dx = b[0] - a[0], dy = b[1] - a[1];
-  const p = [-dx, dx, -dy, dy], q = [a[0] - west, east - a[0], a[1] - south, north - a[1]];
   let start = 0, end = 1;
-  let i, t;
+  let i, t, p, q;
   for (i = 0; i < 4; i++) {
-    if (p[i] === 0) {
-      if (q[i] < 0) return null;
+    p = i === 0 ? -dx : i === 1 ? dx : i === 2 ? -dy : dy;
+    q = i === 0 ? a[0] - west : i === 1 ? east - a[0] : i === 2 ? a[1] - south : north - a[1];
+    if (p === 0) {
+      if (q < 0) return null;
     } else {
-      t = q[i] / p[i];
-      if (p[i] < 0) start = Math.max(start, t);
+      t = q / p;
+      if (p < 0) start = Math.max(start, t);
       else end = Math.min(end, t);
       if (start > end) return null;
     }
   }
   if (start === end || dx === 0 && dy === 0) return null;
-  return [[a[0] + start * dx, a[1] + start * dy], [a[0] + end * dx, a[1] + end * dy]];
+  return /* alloc */ [
+    /* alloc */ [a[0] + start * dx, a[1] + start * dy],
+    /* alloc */ [a[0] + end * dx, a[1] + end * dy],
+  ];
 }

package/src/geometry/computeBounds.js

@@ -1,7 +1,9 @@
 /** Cache local AABB and center for ray picking and transparent mesh sorting. */
 
 export function computeBounds(geometry) {
-  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity], data = geometry.attributes.position.data;
+  const min = /* alloc */ [Infinity, Infinity, Infinity];
+  const max = /* alloc */ [-Infinity, -Infinity, -Infinity];
+  const data = geometry.attributes.position.data;
   let i;
   for (i = 0; i < data.length; i++) {
     min[i % 3] = Math.min(min[i % 3], data[i]);
@@ -21,13 +23,16 @@ export function computeBounds(geometry) {
       max[axis] = Math.fround(max[axis] + high);
     }
   }
-  const center = [];
-  for (i = 0; i < min.length; i++) center.push((min[i] + max[i]) / 2);
+  const center = /* alloc */ [
+    (min[0] + max[0]) / 2,
+    (min[1] + max[1]) / 2,
+    (min[2] + max[2]) / 2,
+  ];
   let radius = instances ? Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) / 2 : 0;
   for (i = 0; !instances && i < data.length; i += 3) {
     radius = Math.max(radius, Math.hypot(
       data[i] - center[0], data[i + 1] - center[1], data[i + 2] - center[2]
     ));
   }
-  geometry.bounds = { min, max, center, radius };
+  geometry.bounds = /* alloc */ { min, max, center, radius };
 }

package/src/geometry/conformModelToTerrain.js

@@ -1,18 +1,23 @@
+import { radians } from '../globals/radians.js';
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { HEIGHT } from '../globals/HEIGHT.js';
+
+
 import { computeBounds } from './computeBounds.js';
 import { getElevation } from '../terrain/getElevation.js';
 import { update } from '../scene/update.js';
 import { updateWorldMatrix } from '../scene/updateWorldMatrix.js';
 import { vertexNormals } from './vertexNormals.js';
 import { collectMeshes } from '../collision/collectMeshes.js';
-import { HEIGHT } from '../constants/HEIGHT.js';
 
 export function conformModelToTerrain(layer, terrain) {
-  if (!layer.model) return;
-  const meshes = [];
-  collectMeshes(layer.model, meshes);
+  if (!sceneByLayer.get(layer).model) return;
+  const meshes = /* alloc */ [];
+  collectMeshes(sceneByLayer.get(layer).model, meshes);
   let mesh, positions, geometry, position, normals, attribute, normal, world, inverse, i, x, y, z;
   let worldY, weight, worldX, worldZ, point, elevation, offset;
-  if (!terrain?._terrainReady || !layer.options.terrainConform) {
+  if (!sceneByLayer.get(terrain)?._terrainReady || !layer.options.terrainConform) {
     for (mesh of meshes) {
       positions = mesh.geometry._terrainBasePositions;
       if (!positions) continue;
@@ -29,11 +34,11 @@ export function conformModelToTerrain(layer, terrain) {
     return;
   }
 
-  updateWorldMatrix(layer.root);
+  updateWorldMatrix(sceneByLayer.get(layer).root);
   const map = layer._map, crs = map.options.crs;
-  const origin = crs.project(layer._shared._sceneOrigin);
-  const metres = Math.cos(layer._shared._sceneOrigin.lat * Math.PI / 180);
-  const pixelScale = crs.scale(terrain._terrainZoom);
+  const origin = crs.project(sceneByLayer.get(sceneByLayer.get(layer)._shared)._sceneOrigin);
+  const metres = Math.cos(sceneByLayer.get(sceneByLayer.get(layer)._shared)._sceneOrigin.lat * radians);
+  const pixelScale = crs.scale(sceneByLayer.get(terrain)._terrainZoom);
 
   for (mesh of meshes) {
     geometry = mesh.geometry, attribute = geometry.attributes.position;
@@ -41,15 +46,15 @@ export function conformModelToTerrain(layer, terrain) {
     normal = geometry.attributes.normal;
     geometry._terrainBaseNormals ||= normal.data.slice();
     attribute.data.set(geometry._terrainBasePositions);
-    world = mesh.worldMatrix, inverse = new DOMMatrix(world).inverse().toFloat64Array();
+    world = mesh.worldMatrix, inverse = /* alloc */ new DOMMatrix(world).inverse().toFloat64Array();
     for (i = 0; i < attribute.data.length; i += 3) {
       x = attribute.data[i], y = attribute.data[i + 1], z = attribute.data[i + 2];
       worldY = world[1] * x + world[5] * y + world[9] * z + world[13];
-      weight = Math.max(0, Math.min(1, 1 - (worldY - layer.root.position[1]) / HEIGHT));
+      weight = Math.max(0, Math.min(1, 1 - (worldY - sceneByLayer.get(layer).root.position[1]) / HEIGHT));
       if (!weight) continue;
       worldX = world[0] * x + world[4] * y + world[8] * z + world[12];
       worldZ = world[2] * x + world[6] * y + world[10] * z + world[14];
-      point = crs.transformation.transform(new L.Point(
+      point = crs.transformation.transform(/* alloc */ new L.Point(
         origin.x + worldX / metres, origin.y - worldZ / metres), pixelScale);
       elevation = getElevation(terrain, point);
       if (!Number.isFinite(elevation)) continue;

package/src/geometry/cross.js

@@ -1,3 +1,7 @@
 export function cross(a, b) {
-  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+  return /* alloc */ [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
 }

package/src/geometry/dashValues.js

@@ -0,0 +1,14 @@
+export function dashValues(options) {
+  const values = Array.isArray(options.dashArray) ? options.dashArray :
+    String(options.dashArray || '').trim().split(/[ ,]+/);
+  const dash = /* alloc */ [];
+  let value, allZero = true;
+  for (value of values) dash.push(Number(value));
+  for (value of dash) {
+    if (!Number.isFinite(value) || value < 0) throw /* alloc */ new Error('Invalid Leaflet dashArray');
+    if (value !== 0) allZero = false;
+  }
+  if (allZero) dash.length = 0;
+  if (dash.length % 2) dash.push(...dash);
+  return dash;
+}

package/src/geometry/dashedSegment.js

@@ -0,0 +1,16 @@
+import { segment } from './segment.js';
+
+export function dashedSegment(context, a, b, length, distance, period) {
+  const dash = context.dash;
+  let offset = 0, phase, index, end, delta;
+  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;
+  }
+}

package/src/geometry/diskAt.js

@@ -1,4 +1,6 @@
+import { tau } from '../globals/tau.js';
+import { L } from '../globals/L.js';
 export function diskAt(center, radius, radiusY, count, index) {
-  return new L.Point(center.x + radius * Math.cos(index * 2 * Math.PI / count),
-    center.y + radiusY * Math.sin(index * 2 * Math.PI / count));
+  return /* alloc */ new L.Point(center.x + radius * Math.cos(index * tau / count),
+    center.y + radiusY * Math.sin(index * tau / count));
 }

package/src/geometry/emitter.js

@@ -1,8 +1,8 @@
 export function emitter(point, u, v, axis) {
   const r = 0.65;
-  return {
+  return /* alloc */ {
     x: point.x + (axis === 2 ? 0 : u * r),
     y: point.y + (axis === 1 ? 0 : axis === 2 ? u * r : v * r),
-    ground: point.ground + (axis === 0 ? 0 : v * r), uv: [u, v],
+    ground: point.ground + (axis === 0 ? 0 : v * r), uv: /* alloc */ [u, v],
   };
 }

package/src/geometry/indexBridge.js

@@ -0,0 +1,29 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+export function indexBridge(backend, pixels, triangles) {
+  const bridgeTriangles = /* alloc */ [];
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let t, triangle, i, p, x, y, key, bucket;
+  for (t of triangles) {
+    triangle = /* alloc */ [];
+    for (i of t) triangle.push(pixels[i]);
+    bridgeTriangles.push(triangle);
+  }
+  for (p of pixels) {
+    minX = Math.min(minX, p[0]); minY = Math.min(minY, p[1]);
+    maxX = Math.max(maxX, p[0]); maxY = Math.max(maxY, p[1]);
+  }
+  const bridge = /* alloc */ {
+    triangles: bridgeTriangles,
+    min: /* alloc */ [minX, minY],
+    max: /* alloc */ [maxX, maxY],
+  };
+  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}`;
+      bucket = sceneByLayer.get(backend)._bridges.get(key);
+      if (!bucket) sceneByLayer.get(backend)._bridges.set(key, bucket = /* alloc */ []);
+      bucket.push(bridge);
+    }
+  }
+}

package/src/geometry/lampPostGeometry.js

@@ -1,20 +1,26 @@
 import { parseColor } from "../utils/parseColor.js";
 import { ring } from './lampRing.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/lampRing.js

@@ -1,11 +1,14 @@
+import { lampDirections } from '../globals/lampDirections.js';
+
 export function ring(point, radius) {
-  const points = [];
+  const points = /* alloc */ new Array(lampDirections.length);
   let i;
-  for (i = 0; i < 6; i++) {
-    points.push({
-      x: point.x + Math.cos(i * Math.PI / 3) * radius,
-      y: point.y + Math.sin(i * Math.PI / 3) * radius, ground: point.ground, uv: [3, 3],
-    });
+  for (i = 0; i < points.length; i++) {
+    points[i] = /* alloc */ {
+      x: point.x + lampDirections[i].x * radius,
+      y: point.y + lampDirections[i].y * radius, ground: point.ground,
+      uv: /* alloc */ [3, 3],
+    };
   }
   return points;
 }

package/src/geometry/lightGeometry.js

@@ -5,11 +5,11 @@ 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 './nativeTriangle.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/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 { L } from '../globals/L.js';
 import { visit } from './visit.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/polygon.js

@@ -3,15 +3,16 @@ 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/roofCoverage.js

@@ -1,52 +1,23 @@
-/** 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 { sceneByLayer } from '../globals/sceneByLayer.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, backend, rasters) {
+  let intersectsArchive = false, pending = false;
+  let layer, footprint, remaining, tile;
+  for (layer of rasters) {
+    if (!sceneByLayer.get(layer).header) { pending = true; continue; }
+    footprint = roofFootprint(mesh, backend, layer);
+    if (!footprint) continue;
+    intersectsArchive = true;
+    remaining = /* alloc */ [footprint];
+    for (tile of sceneByLayer.get(layer)._rasterTiles.values()) {
+      // Failed imagery already reports an error; do not hide the building indefinitely.
+      if (!tile.done && !tile.error) continue;
+      remaining = subtractRoofTile(remaining, tile, sceneByLayer.get(layer)._tileZoom);
+      if (!remaining.length) return true;
+    }
+  }
+  return !intersectsArchive && !pending;
+}