leaflet-city-mapper 0.0.9 → 0.1.1

package/src/geometry/circleGeometry.js

@@ -1,35 +1,41 @@
-import { L } from '../globals/L.js';
-import { disk } from './disk.js';
-import { circleAt } from './circleAt.js';
-import { line } from './line.js';
-import { triangle } from './appendNativeTriangle.js';
-import { projectNativePath } from '../core/projectNativePath.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) {
-    projectNativePath(source);
-    const projected = source._point.add(map.getPixelOrigin());
-    center.x = projected.x;
-    center.y = projected.y;
-    radius = source._pxRadius ?? source._radius;
-    radiusY = source._pxRadiusY ?? 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));
-    }
-  }
-}
+import { L } from '../globals/L.js';
+import { disk } from './disk.js';
+import { circleAt } from './circleAt.js';
+import { line } from './line.js';
+import { triangle } from './appendNativeTriangle.js';
+import { projectNativePath } from '../core/projectNativePath.js';
+
+/**
+ * Generate native circle or ellipse fill and stroke triangles.
+ *
+ * @param {L.Circle|L.CircleMarker} source Native circle layer.
+ * @param {Object} context Projection, style and destination buffers.
+ */
+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) {
+    projectNativePath(source);
+    const projected = source._point.add(map.getPixelOrigin());
+    center.x = projected.x;
+    center.y = projected.y;
+    radius = source._pxRadius ?? source._radius;
+    radiusY = source._pxRadiusY ?? 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

@@ -1,7 +1,14 @@
 import { samePoint } from './samePoint.js';
 import { clipSegment } from './clipSegment.js';
 
-/** Clip a geographic line to [west, south, east, north] without joining disjoint pieces. */
+/**
+ * Clip a geographic line to [west, south, east, north] without joining disjoint pieces.
+ *
+ * @param {Array<Array<number>>} line Geographic coordinates.
+ * @param {Array<number>} bounds West, south, east and north.
+ *
+ * @returns {Array<Array<Array<number>>>} Clipped line pieces.
+ */
 export function clipLine(line, bounds) {
   const pieces = /* alloc */ [];
   let current;

package/src/geometry/clipSegment.js

@@ -1,3 +1,12 @@
+/**
+ * Clip a segment to geographic bounds, discarding zero-length results.
+ *
+ * @param {Array<number>} a Segment start.
+ * @param {Array<number>} b Segment end.
+ * @param {Array<number>} bounds West, south, east and north.
+ *
+ * @returns {Array<Array<number>>|null} Clipped endpoints, or null if outside.
+ */
 export function clipSegment(a, b, bounds) {
   const [west, south, east, north] = bounds;
   const dx = b[0] - a[0], dy = b[1] - a[1];

package/src/geometry/computeBounds.js

@@ -1,5 +1,8 @@
-/** Cache local AABB and center for ray picking and transparent mesh sorting. */
-
+/**
+ * Cache local bounds, center and bounding radius, including any instance offsets.
+ *
+ * @param {Object} geometry Geometry with position and optional instance-offset attributes.
+ */
 export function computeBounds(geometry) {
   const min = /* alloc */ [Infinity, Infinity, Infinity];
   const max = /* alloc */ [-Infinity, -Infinity, -Infinity];

package/src/geometry/conformModelToTerrain.js

@@ -4,12 +4,9 @@ import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
 import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
 import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
 import { terrainZoomByLayer } from '../weakmaps/terrainZoomByLayer.js';
-
 import { radians } from '../globals/radians.js';
 import { L } from '../globals/L.js';
 import { HEIGHT } from '../globals/HEIGHT.js';
-
-
 import { computeBounds } from './computeBounds.js';
 import { getElevation } from '../terrain/getElevation.js';
 import { update } from '../scene/scheduleSceneUpdate.js';
@@ -17,6 +14,12 @@ import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
 import { vertexNormals } from './vertexNormals.js';
 import { collectMeshes } from '../collision/collectMeshes.js';
 
+/**
+ * Conform model vertices to terrain or restore their original positions when disabled.
+ *
+ * @param {L.Layer} layer Model layer.
+ * @param {L.Layer} terrain Terrain layer, if available.
+ */
 export function conformModelToTerrain(layer, terrain) {
   if (!modelByLayer.get(layer)) return;
   const meshes = /* alloc */ [];

package/src/geometry/createLampRing.js

@@ -1,5 +1,13 @@
 import { lampDirections } from '../globals/lampDirections.js';
 
+/**
+ * Create a ring of lamp points with ground height and fixed UVs.
+ *
+ * @param {Object} point Ring center and ground height.
+ * @param {number} radius Ring radius.
+ *
+ * @returns {Array<Object>} Lamp ring points.
+ */
 export function ring(point, radius) {
   const points = /* alloc */ new Array(lampDirections.length);
   let i;

package/src/geometry/createModelGeometry.js

@@ -1,34 +1,44 @@
-import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-
-import { createProgram } from '../materials/createProgram.js';
-
-export function createModelGeometry(context, primitive, attributes) {
-  const style = context.materials[primitive.material] || /* alloc */ {
-    color: /* alloc */ [1, 1, 1], metallic: 1,
-  };
-  if ((style.baseTexture || style.metalTexture || style.emissiveTexture || style.occlusionTexture) && !attributes.uv) {
-    throw /* alloc */ new Error('Textured model mesh requires UV coordinates');
-  }
-  const program = createProgram(context.backend, style);
-  context.resources.push(program);
-  const device = rendererByLayer.get(context.backend).device;
-  let name, attribute;
-  for ([name, attribute] of Object.entries(attributes)) {
-    attribute.size ||= 1;
-    attribute.count = attribute.data.length / attribute.size;
-    attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
-    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);
-  }
-  const geometry = /* alloc */ {
-    device, attributes,
-    drawRange: /* alloc */ { start: 0, count: attributes.index?.count || attributes.position.count },
-  };
-  context.resources.push(geometry);
-  return /* alloc */ { device, geometry, program };
-}
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { createProgram } from '../materials/createProgram.js';
+
+/**
+ * Create GPU buffers and a material program for a model primitive.
+ *
+ * @param {Object} context Model context tracking materials and resources.
+ * @param {Object} primitive glTF primitive specification.
+ * @param {Object} attributes Prepared geometry attributes.
+ *
+ * @returns {Object} Device, geometry and program.
+ *
+ * @throws {Error} If a textured material has no UV attribute.
+ */
+export function createModelGeometry(context, primitive, attributes) {
+  const style = context.materials[primitive.material] || /* alloc */ {
+    color: /* alloc */ [1, 1, 1], metallic: 1,
+  };
+  if ((style.baseTexture || style.metalTexture || style.emissiveTexture || style.occlusionTexture) && !attributes.uv) {
+    throw /* alloc */ new Error('Textured model mesh requires UV coordinates');
+  }
+  const program = createProgram(context.backend, style);
+  context.resources.push(program);
+  const device = rendererByLayer.get(context.backend).device;
+  let name, attribute;
+  for ([name, attribute] of Object.entries(attributes)) {
+    attribute.size ||= 1;
+    attribute.count = attribute.data.length / attribute.size;
+    attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
+    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);
+  }
+  const geometry = /* alloc */ {
+    device, attributes,
+    drawRange: /* alloc */ { start: 0, count: attributes.index?.count || attributes.position.count },
+  };
+  context.resources.push(geometry);
+  return /* alloc */ { device, geometry, program };
+}

package/src/geometry/createRasterQuadGeometry.js

@@ -4,7 +4,13 @@ import { rasterNormals } from '../globals/rasterNormals.js';
 import { rasterUVs } from '../globals/rasterUVs.js';
 import { rasterIndices } from '../globals/rasterIndices.js';
 
-
+/**
+ * Create GPU geometry for a shared indexed raster quad.
+ *
+ * @param {GPUDevice} device Device owning the buffers.
+ *
+ * @returns {Object} Quad geometry and attributes.
+ */
 export function createGeometry(device) {
   const attributes = /* alloc */ {
     position: /* alloc */ { size: 3, data: /* alloc */ new Float32Array(rasterPositions) },

package/src/geometry/createTreeRing.js

@@ -1,6 +1,13 @@
 import { ringDirections } from '../globals/ringDirections.js';
 
-
+/**
+ * Create a ring of projected tree points around a center.
+ *
+ * @param {Object} point Ring center and ground height.
+ * @param {number} radius Ring radius.
+ *
+ * @returns {Array<Object>} Tree ring points.
+ */
 export function ring(point, radius) {
   const result = /* alloc */ new Array(ringDirections.length);
   let i;

package/src/geometry/crossVector.js

@@ -1,7 +1,15 @@
-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]
-  ];
-}
+/**
+ * Compute the cross product of two three-dimensional vectors.
+ *
+ * @param {ArrayLike<number>} a First vector.
+ * @param {ArrayLike<number>} b Second vector.
+ *
+ * @returns {Array<number>} Cross product.
+ */
+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

@@ -1,14 +1,23 @@
-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;
-}
+/**
+ * Parse a Leaflet dash array into a validated even-length numeric pattern.
+ *
+ * @param {Object} options Leaflet path options.
+ *
+ * @returns {Array<number>} Dash pattern, or an empty array for a solid line.
+ *
+ * @throws {Error} If a dash value is negative or non-finite.
+ */
+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

@@ -1,21 +1,33 @@
-import { segment } from './segment.js';
-
-export function dashedSegment(context, a, b, length, distance, period) {
-  const dash = context.dash;
-  let offset = 0, phase = ((distance % period) + period) % period, index = 0, end, delta, skipped = 0;
-  while (index < dash.length - 1 && phase >= dash[index]) phase -= dash[index++];
-  let remaining = Math.max(0, dash[index] - phase);
-  while (offset < length) {
-    end = Math.min(length, offset + remaining);
-    if (end > offset && index % 2 === 0) {
-      delta = b.subtract(a).divideBy(length);
-      segment(context, a.add(delta.multiplyBy(offset)), a.add(delta.multiplyBy(end)), true, true);
-    }
-    if (end <= offset) {
-      if (++skipped >= dash.length) throw /* alloc */ new Error('Leaflet dashArray is too small for these coordinates');
-    } else skipped = 0;
-    offset = end;
-    index = (index + 1) % dash.length;
-    remaining = dash[index];
-  }
-}
+import { segment } from './segment.js';
+
+/**
+ * Append dashed geometry along a segment while preserving the pattern phase.
+ *
+ * @param {Object} context Line geometry context and dash pattern.
+ * @param {L.Point} a Segment start.
+ * @param {L.Point} b Segment end.
+ * @param {number} length Segment length.
+ * @param {number} distance Distance at the start of the segment.
+ * @param {number} period Dash pattern period.
+ *
+ * @throws {Error} If dash lengths cannot advance at these coordinates.
+ */
+export function dashedSegment(context, a, b, length, distance, period) {
+  const dash = context.dash;
+  let offset = 0, phase = ((distance % period) + period) % period, index = 0, end, delta, skipped = 0;
+  while (index < dash.length - 1 && phase >= dash[index]) phase -= dash[index++];
+  let remaining = Math.max(0, dash[index] - phase);
+  while (offset < length) {
+    end = Math.min(length, offset + remaining);
+    if (end > offset && index % 2 === 0) {
+      delta = b.subtract(a).divideBy(length);
+      segment(context, a.add(delta.multiplyBy(offset)), a.add(delta.multiplyBy(end)), true, true);
+    }
+    if (end <= offset) {
+      if (++skipped >= dash.length) throw /* alloc */ new Error('Leaflet dashArray is too small for these coordinates');
+    } else skipped = 0;
+    offset = end;
+    index = (index + 1) % dash.length;
+    remaining = dash[index];
+  }
+}

package/src/geometry/disk.js

@@ -1,6 +1,15 @@
 import { triangle } from './appendNativeTriangle.js';
 import { diskAt } from './diskAt.js';
 
+/**
+ * Append a triangle fan for a filled elliptical disk.
+ *
+ * @param {Function} point Vertex projection function.
+ * @param {L.Point} center Disk center.
+ * @param {number} radius Horizontal radius.
+ * @param {Array<number>} target Destination vertices.
+ * @param {number} [radiusY] Vertical radius.
+ */
 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))));

package/src/geometry/diskAt.js

@@ -1,6 +1,18 @@
 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));
-}
+
+/**
+ * Compute a point on an elliptical disk perimeter.
+ *
+ * @param {L.Point} center Disk center.
+ * @param {number} radius Horizontal radius.
+ * @param {number} radiusY Vertical radius.
+ * @param {number} count Perimeter subdivision count.
+ * @param {number} index Perimeter point index.
+ *
+ * @returns {L.Point} Perimeter point.
+ */
+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/emitter.js

@@ -1,8 +1,18 @@
-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],
-  };
-}
+/**
+ * Construct a point on one axis-aligned plane of a light emitter.
+ *
+ * @param {Object} point Projected center and ground height.
+ * @param {number} u First local coordinate.
+ * @param {number} v Second local coordinate.
+ * @param {number} axis Plane axis index.
+ *
+ * @returns {Object} Projected point with ground height and UV coordinates.
+ */
+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/fillNativePolygon.js

@@ -1,20 +1,28 @@
-import { triangle } from './appendNativeTriangle.js';
-import { triangulate } from '../triangulation/triangulate.js';
-
-export function fillNativePolygon(context, projected) {
-  const { options, fill, point } = context;
-  if (options.triangulated) {
-    if (projected.length !== 1 || projected[0].length !== 3) {
-      throw /* alloc */ new Error('triangulated polygons require three vertices per polygon and no holes');
-    }
-    triangle(point, fill, projected[0][0], projected[0][1], projected[0][2]);
-    return;
-  }
-  const valid = /* alloc */ [];
-  let ring, indices;
-  for (ring of projected) if (ring.length >= 3) valid.push(ring);
-  const vertices = valid.flat();
-  for (indices of triangulate(valid[0], valid.slice(1))) {
-    triangle(point, fill, vertices[indices[0]], vertices[indices[1]], vertices[indices[2]]);
-  }
-}
+import { triangle } from './appendNativeTriangle.js';
+import { triangulate } from '../triangulation/triangulate.js';
+
+/**
+ * Append fill triangles for a native polygon, respecting pre-triangulated input.
+ *
+ * @param {Object} context Projection, style and fill buffer.
+ * @param {Array<Array<L.Point>>} projected Projected polygon rings.
+ *
+ * @throws {Error} If a pre-triangulated polygon does not have exactly three vertices and no holes.
+ */
+export function fillNativePolygon(context, projected) {
+  const { options, fill, point } = context;
+  if (options.triangulated) {
+    if (projected.length !== 1 || projected[0].length !== 3) {
+      throw /* alloc */ new Error('triangulated polygons require three vertices per polygon and no holes');
+    }
+    triangle(point, fill, projected[0][0], projected[0][1], projected[0][2]);
+    return;
+  }
+  const valid = /* alloc */ [];
+  let ring, indices;
+  for (ring of projected) if (ring.length >= 3) valid.push(ring);
+  const vertices = valid.flat();
+  for (indices of triangulate(valid[0], valid.slice(1))) {
+    triangle(point, fill, vertices[indices[0]], vertices[indices[1]], vertices[indices[2]]);
+  }
+}

package/src/geometry/generateTreeGeometry.js

@@ -1,13 +1,19 @@
 import { triangleContexts } from '../globals/triangleContexts.js';
-
-
 import { addGeneratedTriangle } from './addGeneratedTriangle.js';
 
-export function generateTreeGeometry(context, generator, point, style) {
-  triangleContexts.push(context);
-  try {
-    generator(point, style, addGeneratedTriangle);
-  } finally {
-    triangleContexts.pop();
-  }
+/**
+ * Run a point geometry generator with the current triangle destination context.
+ *
+ * @param {Object} context Destination area geometry.
+ * @param {Function} generator Point geometry generator.
+ * @param {Object} point Projected point.
+ * @param {Object} style Geometry style.
+ */
+export function generateTreeGeometry(context, generator, point, style) {
+  triangleContexts.push(context);
+  try {
+    generator(point, style, addGeneratedTriangle);
+  } finally {
+    triangleContexts.pop();
+  }
 }

package/src/geometry/indexBridge.js

@@ -1,30 +1,36 @@
 import { bridgesByLayer } from '../weakmaps/bridgesByLayer.js';
 
-
-export function indexBridge(layer, 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 = bridgesByLayer.get(layer).get(key);
-      if (!bucket) bridgesByLayer.get(layer).set(key, bucket = /* alloc */ []);
-      bucket.push(bridge);
-    }
-  }
-}
+/**
+ * Index bridge triangles in 64-pixel buckets for elevation lookup.
+ *
+ * @param {L.Layer} layer Terrain layer owning the bridge index.
+ * @param {Array<Array<number>>} pixels Projected vertices including elevation.
+ * @param {Array<Array<number>>} triangles Triangle vertex indices.
+ */
+export function indexBridge(layer, 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 = bridgesByLayer.get(layer).get(key);
+      if (!bucket) bridgesByLayer.get(layer).set(key, bucket = /* alloc */ []);
+      bucket.push(bridge);
+    }
+  }
+}