leaflet-city-mapper 0.0.3 → 0.0.5

package/src/geometry/{build.js → buildGeometryParts.js}

@@ -1,12 +1,16 @@
 import { triangle } from './triangle.js';
 
 export function build(parts) {
-  const position = [], normal = [], color = [];
-  let ring, bottom, top, tint, topRing, low, high, x, z, i, j;
+  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 = [], high = [];
-    for ([x, z] of ring) low.push([x, bottom, z]);
-    for ([x, z] of topRing) high.push([x, top, z]);
+    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);
@@ -15,5 +19,5 @@ export function build(parts) {
       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 { position, normal, color };
+  return /* alloc */ { position, normal, color };
 }

package/src/geometry/buildProjectedPoint.js

@@ -0,0 +1,21 @@
+import { generateTreeGeometry } from './generateTreeGeometry.js';
+import { lampPostGeometry } from './lampPostGeometry.js';
+import { lightGeometry } from './lightGeometry.js';
+import { treeGeometry } from './treeGeometry.js';
+
+export function buildProjectedPoint(context, projected, style, baseColor, support) {
+  const { top } = style;
+  if (context.backend.options.nightLight) {
+    if (!Number.isFinite(style.lightFlux) || style.lightFlux <= 0) throw /* alloc */ new Error('Invalid light flux');
+    if (style.poleRadius > 0 && !context.supports.has(support)) {
+      generateTreeGeometry(context, lampPostGeometry, projected, style);
+      context.supports.add(support);
+    }
+    generateTreeGeometry(context, lightGeometry, projected, style);
+    context.lights.push(/* alloc */ {
+      position: /* alloc */ [projected.x, projected.ground + top, -projected.y],
+      radius: Math.hypot(top, style.lightRadius), color: /* alloc */ [baseColor.r, baseColor.g, baseColor.b],
+      flux: style.lightFlux,
+    });
+  } else generateTreeGeometry(context, treeGeometry, projected, style);
+}

package/src/{sources/buildAreaPolygon.js → geometry/buildProjectedPolygon.js}

@@ -1,29 +1,25 @@
-import { projectRing } from './projectRing.js';
-import { triangulate } from '../triangulation/triangulate.js';
-import { addTriangle } from './addTriangle.js';
-import { isClockWise } from '../triangulation/isClockWise.js';
-
-export function buildAreaPolygon(context, rings, top, bottom, baseColor) {
-  if (!rings.length) throw new Error('Empty GeoJSON polygon');
-  const paths = [];
-  let ring, path, point, a, b, c, index, sign, i, length, nx, nz;
-  for (ring of rings) paths.push(projectRing(context, ring));
-  const points = [];
-  for (path of paths) for (point of path) points.push(point);
-  for ([a, b, c] of triangulate(paths[0], paths.slice(1))) {
-    addTriangle(context, points[a], top, points[b], top, points[c], top, 0, 1, 0, baseColor);
-    if (bottom > 0) addTriangle(context, points[a], bottom, points[b], bottom, points[c], bottom, 0, -1, 0, baseColor);
-  }
-  for (index = 0; index < paths.length; index++) {
-    path = paths[index];
-    sign = isClockWise(path) === (index === 0) ? -1 : 1;
-    for (i = 0; i < path.length; i++) {
-      a = path[i], b = path[(i + 1) % path.length];
-      length = Math.hypot(b.x - a.x, b.y - a.y);
-      if (!length) continue;
-      nx = sign * (b.y - a.y) / length, nz = sign * (b.x - a.x) / length;
-      addTriangle(context, a, bottom, b, bottom, b, top, nx, 0, nz, baseColor);
-      addTriangle(context, a, bottom, b, top, a, top, nx, 0, nz, baseColor);
-    }
-  }
-}
+import { triangulate } from '../triangulation/triangulate.js';
+import { addTriangle } from './appendAreaTriangle.js';
+import { isClockWise } from '../triangulation/isClockWise.js';
+
+export function buildProjectedPolygon(context, paths, top, bottom, baseColor) {
+  const points = /* alloc */ [];
+  let path, point, a, b, c, index, sign, i, length, nx, nz;
+  for (path of paths) for (point of path) points.push(point);
+  for ([a, b, c] of triangulate(paths[0], paths.slice(1))) {
+    addTriangle(context, points[a], top, points[b], top, points[c], top, 0, 1, 0, baseColor);
+    if (bottom > 0) addTriangle(context, points[a], bottom, points[b], bottom, points[c], bottom, 0, -1, 0, baseColor);
+  }
+  for (index = 0; index < paths.length; index++) {
+    path = paths[index];
+    sign = isClockWise(path) === (index === 0) ? -1 : 1;
+    for (i = 0; i < path.length; i++) {
+      a = path[i], b = path[(i + 1) % path.length];
+      length = Math.hypot(b.x - a.x, b.y - a.y);
+      if (!length) continue;
+      nx = sign * (b.y - a.y) / length, nz = sign * (b.x - a.x) / length;
+      addTriangle(context, a, bottom, b, bottom, b, top, nx, 0, nz, baseColor);
+      addTriangle(context, a, bottom, b, top, a, top, nx, 0, nz, baseColor);
+    }
+  }
+}

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 './appendNativeTriangle.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,11 +1,15 @@
 /** 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;
-  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 min = /* alloc */ [Infinity, Infinity, Infinity];
+  const max = /* alloc */ [-Infinity, -Infinity, -Infinity];
+  const data = geometry.attributes.position.data;
+  let i, x, y, z;
+  for (i = 0; i < data.length; i += 3) {
+    x = data[i], y = data[i + 1], z = data[i + 2];
+    min[0] = Math.min(min[0], x), max[0] = Math.max(max[0], x);
+    min[1] = Math.min(min[1], y), max[1] = Math.max(max[1], y);
+    min[2] = Math.min(min[2], z), max[2] = Math.max(max[2], z);
   }
   const instances = geometry.attributes.instanceOffset;
   if (instances) {
@@ -21,13 +25,25 @@ 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);
-  let radius = instances ? Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) / 2 : 0;
+  const center = /* alloc */ [
+    (min[0] + max[0]) / 2,
+    (min[1] + max[1]) / 2,
+    (min[2] + max[2]) / 2,
+  ];
+  let radiusSquared = 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]
-    ));
+    x = data[i] - center[0], y = data[i + 1] - center[1], z = data[i + 2] - center[2];
+    radiusSquared = Math.max(radiusSquared, x * x + y * y + z * z);
   }
-  geometry.bounds = { min, max, center, radius };
+  let radius = instances ? Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) / 2
+    : Math.sqrt(radiusSquared);
+  // Preserve hypot's scaling for extreme coordinates in non-Float32 CPU geometry.
+  if (!instances && (radiusSquared === Infinity || radiusSquared < Number.MIN_VALUE / Number.EPSILON)) {
+    radius = 0;
+    for (i = 0; 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

@@ -1,18 +1,29 @@
+import { modelByLayer } from '../weakmaps/modelByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+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/update.js';
-import { updateWorldMatrix } from '../scene/updateWorldMatrix.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
+import { updateWorldMatrix } from '../transforms/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 (!modelByLayer.get(layer)) return;
+  const meshes = /* alloc */ [];
+  collectMeshes(modelByLayer.get(layer), 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 (!terrainReadyByLayer.get(terrain) || !layer.options.terrainConform) {
     for (mesh of meshes) {
       positions = mesh.geometry._terrainBasePositions;
       if (!positions) continue;
@@ -29,11 +40,11 @@ export function conformModelToTerrain(layer, terrain) {
     return;
   }
 
-  updateWorldMatrix(layer.root);
+  updateWorldMatrix(rootByLayer.get(layer));
   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(sceneOriginByLayer.get(sharedByLayer.get(layer)));
+  const metres = Math.cos(sceneOriginByLayer.get(sharedByLayer.get(layer)).lat * radians);
+  const pixelScale = crs.scale(terrainZoomByLayer.get(terrain));
 
   for (mesh of meshes) {
     geometry = mesh.geometry, attribute = geometry.attributes.position;
@@ -41,15 +52,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 - rootByLayer.get(layer).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/createLampRing.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/createModelGeometry.js

@@ -0,0 +1,41 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
+import { vertexNormals } from './vertexNormals.js';
+import { createProgram } from '../materials/createProgram.js';
+
+export function createModelGeometry(context, primitive, attributes) {
+  let normals;
+  if (!attributes.normal) {
+    normals = vertexNormals(attributes.position.data, attributes.index?.data);
+    attributes.normal = /* alloc */ { size: 3, data: normals };
+  }
+  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;
+  if (attributes.index?.data instanceof Uint8Array) attributes.index.data = Uint16Array.from(attributes.index.data);
+  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

@@ -0,0 +1,29 @@
+import { rasterBuffer } from '../globals/rasterBuffer.js';
+import { rasterPositions } from '../globals/rasterPositions.js';
+import { rasterNormals } from '../globals/rasterNormals.js';
+import { rasterUVs } from '../globals/rasterUVs.js';
+import { rasterIndices } from '../globals/rasterIndices.js';
+
+
+export function createGeometry(device) {
+  const attributes = /* alloc */ {
+    position: /* alloc */ { size: 3, data: /* alloc */ new Float32Array(rasterPositions) },
+    normal: /* alloc */ { size: 3, data: /* alloc */ new Float32Array(rasterNormals) },
+    uv: /* alloc */ { size: 2, data: /* alloc */ new Float32Array(rasterUVs) },
+    index: /* alloc */ { data: /* alloc */ new Uint16Array(rasterIndices) },
+  };
+  let name, attribute;
+  for ([name, attribute] of Object.entries(attributes)) {
+    attribute.count = attribute.data.length / (attribute.size || 1);
+    attribute.indexFormat = 'uint16';
+    attribute.buffer = device.createBuffer((
+      rasterBuffer.size = attribute.data.byteLength,
+      rasterBuffer.usage = name === 'index' ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+        : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+      rasterBuffer
+    ));
+
+    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+  }
+  return /* alloc */ { device, attributes, drawRange: /* alloc */ { start: 0, count: attributes.index.count } };
+}

package/src/geometry/createTreeRing.js

@@ -0,0 +1,15 @@
+import { ringDirections } from '../globals/ringDirections.js';
+
+
+export function ring(point, radius) {
+  const result = /* alloc */ new Array(ringDirections.length);
+  let i;
+  for (i = 0; i < result.length; i++) {
+    result[i] = /* alloc */ {
+      x: point.x + ringDirections[i].x * radius,
+      y: point.y + ringDirections[i].y * radius,
+      ground: point.ground,
+    };
+  }
+  return result;
+}

package/src/geometry/crossVector.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

@@ -1,4 +1,4 @@
-import { triangle } from './nativeTriangle.js';
+import { triangle } from './appendNativeTriangle.js';
 import { diskAt } from './diskAt.js';
 
 export function disk(point, center, radius, target, radiusY = radius) {

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/{sources → geometry}/generateTreeGeometry.js

@@ -1,11 +1,13 @@
-import { pumpState } from '../constants/pumpState.js';
+import { triangleContexts } from '../globals/triangleContexts.js';
+
+
 import { addGeneratedTriangle } from './addGeneratedTriangle.js';
 
 export function generateTreeGeometry(context, generator, point, style) {
-  pumpState.triangleContexts.push(context);
+  triangleContexts.push(context);
   try {
     generator(point, style, addGeneratedTriangle);
   } finally {
-    pumpState.triangleContexts.pop();
+    triangleContexts.pop();
   }
 }

package/src/geometry/indexBridge.js

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

package/src/{sources → geometry}/instanceAreaGeometry.js

@@ -5,16 +5,18 @@ export function instanceAreaGeometry(context) {
   const vertices = featureFaces[0].vertexEnd;
   const length = vertices * 3;
   if (!vertices || positions.length !== length * featureFaces.length) return context;
-  const origin = [Math.trunc(positions[0]), Math.trunc(positions[1]), Math.trunc(positions[2])];
-  const template = new Float32Array(length);
-  let i, instance, axis, face, start;
-  for (i = 0; i < length; i++) template[i] = positions[i] - origin[i % 3];
-  const offsets = new Float32Array(featureFaces.length * 4);
+  const originX = Math.trunc(positions[0]), originY = Math.trunc(positions[1]), originZ = Math.trunc(positions[2]);
+  const template = /* alloc */ new Float32Array(length);
+  let i, instance, face, start;
+  for (i = 0; i < length; i++) template[i] = positions[i] - (i % 3 === 0 ? originX : i % 3 === 1 ? originY : originZ);
+  const offsets = /* alloc */ new Float32Array(featureFaces.length * 4);
   for (instance = 0; instance < featureFaces.length; instance++) {
     face = featureFaces[instance];
     start = instance * length;
     if (face.vertexStart !== instance * vertices || face.vertexEnd !== (instance + 1) * vertices) return context;
-    for (axis = 0; axis < 3; axis++) offsets[instance * 4 + axis] = origin[axis] + positions[start + axis] - positions[axis];
+    offsets[instance * 4] = originX + positions[start] - positions[0];
+    offsets[instance * 4 + 1] = originY + positions[start + 1] - positions[1];
+    offsets[instance * 4 + 2] = originZ + positions[start + 2] - positions[2];
     offsets[instance * 4 + 3] = instance * vertices;
     for (i = 0; i < length; i++) {
       if (Math.fround(template[i] + offsets[instance * 4 + i % 3]) !== Math.fround(positions[start + i]) ||
@@ -22,7 +24,7 @@ export function instanceAreaGeometry(context) {
           Math.fround(colors[i]) !== Math.fround(colors[start + i])) return context;
     }
   }
-  return {
+  return /* alloc */ {
     positions: template, normals: normals.slice(0, length), colors: colors.slice(0, length),
     instanceOffsets: offsets,
   };

package/src/{traffic/along.js → geometry/interpolateRoute.js}

@@ -1,6 +1,6 @@
 /** Point and unit direction at distance `s` along `points` ([x, z, y?]) with cumulative `lengths`. */
 
-export function along(points, lengths, s) {
+export function along(points, lengths, s, target) {
   let i = 1, end = lengths.length - 1;
   let middle;
   while (i < end) {
@@ -10,5 +10,11 @@ export function along(points, lengths, s) {
   }
   const a = points[i - 1], b = points[i], d = lengths[i] - lengths[i - 1] || 1;
   const t = (s - lengths[i - 1]) / d;
-  return { x: a[0] + (b[0] - a[0]) * t, y: (a[2] ?? 0) + ((b[2] ?? 0) - (a[2] ?? 0)) * t, z: a[1] + (b[1] - a[1]) * t, dx: (b[0] - a[0]) / d, dz: (b[1] - a[1]) / d };
+  target ||= /* alloc */ {};
+  target.x = a[0] + (b[0] - a[0]) * t;
+  target.y = (a[2] ?? 0) + ((b[2] ?? 0) - (a[2] ?? 0)) * t;
+  target.z = a[1] + (b[1] - a[1]) * t;
+  target.dx = (b[0] - a[0]) / d;
+  target.dz = (b[1] - a[1]) / d;
+  return target;
 }