leaflet-city-mapper 0.0.2 → 0.0.4

package/src/core/uploadCanvasTexture.js

@@ -0,0 +1,22 @@
+import { current } from './current.js';
+import { refreshNativeLayer } from './refreshNativeLayer.js';
+
+export async function uploadCanvasTexture(state, key, texture, image, device, width, height) {
+  let bitmap;
+  try {
+    bitmap = await createImageBitmap(image);
+    if (!current(state) || state.textures.get(key) !== texture) return;
+    device.queue.copyExternalImageToTexture(
+      /* alloc */ { source: bitmap },
+      /* alloc */ { texture: texture.texture },
+      /* alloc */ [width, height]);
+    texture.uploaded = image;
+    texture.pending = false;
+    refreshNativeLayer(state);
+  } catch (error) {
+    state.failed = true;
+    state.source.fire('error', /* alloc */ { error });
+  } finally {
+    bitmap?.close();
+  }
+}

package/src/core/uploadNativeImage.js

@@ -0,0 +1,13 @@
+export function uploadNativeImage(state, key, texture, image, device, width, height) {
+  try {
+    device.queue.copyExternalImageToTexture(
+      /* alloc */ { source: image },
+      /* alloc */ { texture: texture.texture },
+      /* alloc */ [width, height]);
+  } catch (error) {
+    texture.texture.destroy();
+    state.textures.delete(key);
+    throw error;
+  }
+  texture.uploaded = image;
+}

package/src/geometry/addBridges.js

@@ -0,0 +1,29 @@
+import { radians } from '../globals/radians.js';
+import { sceneByLayer } from '../globals/sceneByLayer.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(backend, geojson) {
+  const map = backend._map, crs = map.options.crs, zoom = sceneByLayer.get(backend)._terrainZoom;
+  const origin = crs.project(sceneByLayer.get(backend).location), metres = Math.cos(sceneByLayer.get(backend).location.lat * radians);
+  const base = sceneByLayer.get(backend).root.position[1];
+  const position = /* alloc */ [], normal = /* alloc */ [], color = /* alloc */ [];
+  sceneByLayer.get(backend)._bridges = /* alloc */ new Map();
+  const context = /* alloc */ { backend, 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) {
+    sceneByLayer.get(backend)._bridgeMesh = createMesh(backend, /* alloc */ { position, normal, color });
+  }
+}

package/src/geometry/below.js

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

package/src/geometry/box.js

@@ -0,0 +1,8 @@
+export function box(x0, x1, z0, 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

@@ -0,0 +1,21 @@
+/** 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 bucket) {
+    if (point.x < bridge.min[0] || point.x > bridge.max[0] || point.y < bridge.min[1] || point.y > bridge.max[1]) {
+      continue;
+    }
+    for ([a, b, c] of bridge.triangles) {
+      d = (b[1] - c[1]) * (a[0] - c[0]) + (c[0] - b[0]) * (a[1] - c[1]);
+      u = ((b[1] - c[1]) * (point.x - c[0]) + (c[0] - b[0]) * (point.y - c[1])) / d;
+      v = ((c[1] - a[1]) * (point.x - c[0]) + (a[0] - c[0]) * (point.y - c[1])) / d;
+      if (u >= 0 && v >= 0 && u + v <= 1) {
+        return u * a[2] + v * b[2] + (1 - u - v) * c[2];
+      }
+    }
+  }
+  return null;
+}

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/bridgeLocal.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/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 './bridgeLocal.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, 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(backend, 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/build.js

@@ -0,0 +1,23 @@
+import { triangle } from './triangle.js';
+
+export function build(parts) {
+  const position = /* alloc */ [];
+  const normal = /* alloc */ [];
+  const color = /* alloc */ [];
+  const low = /* alloc */ [];
+  const high = /* alloc */ [];
+  let ring, bottom, top, tint, topRing, x, z, i, j;
+  for ([ring, bottom, top, tint, topRing = ring] of parts) {
+    low.length = high.length = 0;
+    for ([x, z] of ring) low.push(/* alloc */ [x, bottom, z]);
+    for ([x, z] of topRing) high.push(/* alloc */ [x, top, z]);
+    for (i = 0; i < ring.length; i++) {
+      j = (i + 1) % ring.length;
+      triangle(position, normal, color, low[i], low[j], high[j], tint); triangle(position, normal, color, low[i], high[j], high[i], tint);
+    }
+    for (i = 1; i < ring.length - 1; i++) {
+      triangle(position, normal, color, high[0], high[i], high[i + 1], tint); triangle(position, normal, color, low[0], low[i + 1], low[i], tint);
+    }
+  }
+  return /* alloc */ { position, normal, color };
+}

package/src/geometry/circleAt.js

@@ -0,0 +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 * 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

@@ -0,0 +1,23 @@
+import { samePoint } from './samePoint.js';
+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 = /* alloc */ [];
+  let current;
+  let i, segment;
+  for (i = 1; i < line.length; i++) {
+    if (samePoint(line[i - 1], line[i])) continue;
+    segment = clipSegment(line[i - 1], line[i], bounds);
+    if (!segment) {
+      current = null;
+      continue;
+    }
+    if (current && samePoint(current.at(-1), segment[0])) current.push(segment[1]);
+    else {
+      current = segment;
+      pieces.push(current);
+    }
+  }
+  return pieces;
+}

package/src/geometry/clipSegment.js

@@ -0,0 +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];
+  let start = 0, end = 1;
+  let i, t, p, q;
+  for (i = 0; i < 4; i++) {
+    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 / 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 /* alloc */ [
+    /* alloc */ [a[0] + start * dx, a[1] + start * dy],
+    /* alloc */ [a[0] + end * dx, a[1] + end * dy],
+  ];
+}

package/src/geometry/computeBounds.js

@@ -0,0 +1,38 @@
+/** Cache local AABB and center for ray picking and transparent mesh sorting. */
+
+export function computeBounds(geometry) {
+  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]);
+    max[i % 3] = Math.max(max[i % 3], data[i]);
+  }
+  const instances = geometry.attributes.instanceOffset;
+  if (instances) {
+    let axis, offset, low, high;
+    for (axis = 0; axis < 3; axis++) {
+      low = Infinity;
+      high = -Infinity;
+      for (offset = axis; offset < instances.data.length; offset += instances.size) {
+        low = Math.min(low, instances.data[offset]);
+        high = Math.max(high, instances.data[offset]);
+      }
+      min[axis] = Math.fround(min[axis] + low);
+      max[axis] = Math.fround(max[axis] + high);
+    }
+  }
+  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 = /* alloc */ { min, max, center, radius };
+}

package/src/geometry/conformModelToTerrain.js

@@ -0,0 +1,72 @@
+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';
+
+export function conformModelToTerrain(layer, terrain) {
+  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 (!sceneByLayer.get(terrain)?._terrainReady || !layer.options.terrainConform) {
+    for (mesh of meshes) {
+      positions = mesh.geometry._terrainBasePositions;
+      if (!positions) continue;
+      geometry = mesh.geometry, position = geometry.attributes.position;
+      position.data.set(positions);
+      mesh.device.queue.writeBuffer(position.buffer, 0, positions);
+      normals = geometry._terrainBaseNormals;
+      if (normals) {
+        geometry.attributes.normal.data.set(normals);
+        mesh.device.queue.writeBuffer(geometry.attributes.normal.buffer, 0, normals);
+      }
+      computeBounds(geometry);
+    }
+    return;
+  }
+
+  updateWorldMatrix(sceneByLayer.get(layer).root);
+  const map = layer._map, crs = map.options.crs;
+  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;
+    geometry._terrainBasePositions ||= attribute.data.slice();
+    normal = geometry.attributes.normal;
+    geometry._terrainBaseNormals ||= normal.data.slice();
+    attribute.data.set(geometry._terrainBasePositions);
+    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 - 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(/* alloc */ new L.Point(
+        origin.x + worldX / metres, origin.y - worldZ / metres), pixelScale);
+      elevation = getElevation(terrain, point);
+      if (!Number.isFinite(elevation)) continue;
+      offset = (elevation - worldY) * weight;
+      attribute.data[i] += inverse[4] * offset;
+      attribute.data[i + 1] += inverse[5] * offset;
+      attribute.data[i + 2] += inverse[6] * offset;
+    }
+    mesh.device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+    normal.data.set(vertexNormals(attribute.data, geometry.attributes.index?.data));
+    mesh.device.queue.writeBuffer(normal.buffer, 0, normal.data);
+    computeBounds(geometry);
+  }
+  update(layer);
+}

package/src/geometry/cross.js

@@ -0,0 +1,7 @@
+export function cross(a, b) {
+  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/disk.js

@@ -0,0 +1,11 @@
+import { triangle } from './nativeTriangle.js';
+import { diskAt } from './diskAt.js';
+
+export function disk(point, center, radius, target, radiusY = radius) {
+  if (!(radius > 0) || !(radiusY > 0)) return;
+  const count = Math.max(12, Math.min(128, Math.ceil(Math.PI * Math.sqrt(radius))));
+  let i;
+  for (i = 0; i < count; i++) {
+    triangle(point, target, center, diskAt(center, radius, radiusY, count, i), diskAt(center, radius, radiusY, count, i + 1));
+  }
+}

package/src/geometry/diskAt.js

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

package/src/geometry/dot.js

@@ -0,0 +1,6 @@
+export function dot(a, b) {
+  let sum = 0;
+  let i;
+  for (i = 0; i < a.length; i++) sum += a[i] * b[i];
+  return sum;
+}

package/src/geometry/emitter.js

@@ -0,0 +1,8 @@
+export function emitter(point, u, v, axis) {
+  const r = 0.65;
+  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: /* 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

@@ -0,0 +1,30 @@
+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 /* alloc */ new Error('Invalid lamp pole radius');
+  }
+  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];
+      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);
+      addTriangle(center, low, b, low, a, low, 0, -1, 0, color);
+    }
+  }
+}

package/src/geometry/lampRing.js

@@ -0,0 +1,14 @@
+import { lampDirections } from '../globals/lampDirections.js';
+
+export function ring(point, radius) {
+  const points = /* alloc */ new Array(lampDirections.length);
+  let i;
+  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

@@ -0,0 +1,15 @@
+import { parseColor } from "../utils/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 /* 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 === 2 ? 1 : 0, axis === 0 ? 1 : 0, axis === 1 ? 1 : 0);
+  }
+}

package/src/geometry/line.js

@@ -0,0 +1,21 @@
+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);
+  }
+}