leaflet-city-mapper 0.0.1 → 0.0.3

package/src/traffic/toLanes.js

@@ -0,0 +1,16 @@
+// GeoJSON (Multi)LineStrings become lanes ({latlngs, properties, elevation?}); prepare() adds `points` ([x, z, ground]),
+// `lengths` and `length` in layer-local metres.
+
+export function toLanes({ features = [] }) {
+  const lanes = [];
+  let geometry, properties, lines, line, latlngs, lng, lat;
+  for ({ geometry, properties } of features) {
+    lines = geometry?.type === 'LineString' ? [geometry.coordinates] : geometry?.type === 'MultiLineString' ? geometry.coordinates : [];
+    for (line of lines) {
+      latlngs = [];
+      for ([lng, lat] of line) latlngs.push([lat, lng]);
+      lanes.push({ latlngs, properties: properties ?? {}, elevation: properties?.elevation });
+    }
+  }
+  return lanes;
+}

package/src/traffic/tooltip.js

@@ -0,0 +1,11 @@
+export function tooltip({ properties: p }) {
+  const content = document.createElement('div');
+  content.style.whiteSpace = 'pre-line';
+  const lines = [];
+  let line;
+  for (line of [p.name, p.departure && `Departure ${p.departure} ${p.timetable.timeZone}`, p.description]) {
+    if (line) lines.push(line);
+  }
+  content.textContent = lines.join('\n');
+  return content;
+}

package/src/traffic/trafficBounds.js

@@ -0,0 +1,17 @@
+import { computeBounds } from '../geometry/computeBounds.js';
+
+export function trafficBounds(state) {
+  let radius = 20, height = 5;
+  let i, lane, x, z, y;
+  for (i = 0; i < state.template.position.length; i += 3) {
+    radius = Math.max(radius, Math.hypot(state.template.position[i], state.template.position[i + 2]) + Math.abs(state.side));
+    height = Math.max(height, state.template.position[i + 1]);
+  }
+  const data = [];
+  for (lane of state.lanes) {
+    for ([x, z, y] of lane.points) data.push(x - radius, y, z - radius, x + radius, y + height, z + radius);
+  }
+  const extent = { attributes: { position: { data } } };
+  computeBounds(extent);
+  state.mesh.geometry.bounds = extent.bounds;
+}

package/src/traffic/trafficNow.js

@@ -0,0 +1,4 @@
+export function trafficNow(state) {
+  const control = state.layer._map?._timeControl || { live: true };
+  return { live: control.live, time: control.live ? new Date() : control.time };
+}

package/src/traffic/trafficStorage.js

@@ -0,0 +1,5 @@
+export function trafficStorage(device, data) {
+  const buffer = device.createBuffer({ size: Math.max(16, data.byteLength), usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+  device.queue.writeBuffer(buffer, 0, data);
+  return buffer;
+}

package/src/traffic/tripsAt.js

@@ -0,0 +1,27 @@
+import { vehicleOffsets } from "./vehicleOffsets.js";
+import { scheduledTrips } from "./scheduledTrips.js";
+
+// A lane with a `timetable` runs scheduled trips end to end; one with a `flow` (vehicles/h) loops evenly spaced vehicles.
+
+export function tripsAt(time, lanes, velocity) {
+  const trips = [];
+  let l, lane, timetable, flow, trip, travelled, offsets, k;
+  for (l = 0; l < lanes.length; l++) {
+    lane = lanes[l];
+    ({ timetable, flow = 0 } = lane.properties);
+    if (!lane.length) continue;
+    if (timetable) {
+      for (trip of scheduledTrips(time, timetable)) trips.push({
+        id: `${l}-${trip.id}`, lane, distance: trip.progress * lane.length, speed: lane.length / (timetable.duration * 60),
+        properties: { ...lane.properties, departure: trip.departure },
+      });
+    } else {
+      travelled = time / 1000 * velocity;
+      offsets = lane.offsets ||= vehicleOffsets(lane.length, flow, velocity);
+      for (k = 0; k < offsets.length; k++) trips.push({
+        id: `${l}-${k}`, lane, distance: (offsets[k] + travelled) % lane.length, speed: velocity, properties: lane.properties,
+      });
+    }
+  }
+  return trips;
+}

package/src/traffic/updateTraffic.js

@@ -0,0 +1,8 @@
+import { loadTraffic } from './loadTraffic.js';
+
+export function updateTraffic(state, event) {
+  if (event?.layer && !event.layer.control?.time) return;
+  cancelAnimationFrame(state.frame);
+  loadTraffic(state);
+  state.tick();
+}

package/src/traffic/updateTrafficTerrain.js

@@ -0,0 +1,12 @@
+import { disposeTrafficObject } from './disposeTrafficObject.js';
+import { groundTraffic } from './groundTraffic.js';
+import { trafficBounds } from './trafficBounds.js';
+
+export function updateTrafficTerrain(state) {
+  if (!state.lanes.length) return;
+  groundTraffic(state);
+  disposeTrafficObject(state, state.route);
+  state.route = null;
+  if (state.mesh) trafficBounds(state);
+  if (!state.frame) state.tick();
+}

package/src/traffic/vehicleOffsets.js

@@ -0,0 +1,11 @@
+import { speed } from "../constants/speed.js";
+
+/** Evenly spaced starting offsets (metres) for `flow` vehicles/h moving at `velocity` m/s on a `length` metres lane. */
+
+export function vehicleOffsets(length, flow, velocity = speed) {
+  const count = Math.round(length * flow / 3600 / velocity);
+  const offsets = Array.from({ length: count });
+  let i;
+  for (i = 0; i < offsets.length; i++) offsets[i] = (i + 0.5) * length / count;
+  return offsets;
+}

package/src/triangulation/area.js

@@ -0,0 +1,9 @@
+export function area(ring) {
+  let sum = 0;
+  let i, p, q;
+  for (i = 0; i < ring.length; i++) {
+    p = ring[i], q = ring[(i + 1) % ring.length];
+    sum += p.x * q.y - q.x * p.y;
+  }
+  return Math.abs(sum) / 2;
+}

package/src/triangulation/clean.js

@@ -0,0 +1,18 @@
+import { cross } from './cross.js';
+import { equal } from './equal.js';
+
+export function clean(ring) {
+  let changed = true;
+  let i, a, b, c;
+  while (changed && ring.length > 3) {
+    changed = false;
+    for (i = 0; i < ring.length; i++) {
+      a = ring[(i + ring.length - 1) % ring.length], b = ring[i], c = ring[(i + 1) % ring.length];
+      if (equal(a, b) || Math.abs(cross(a, b, c)) < 1e-10) {
+        ring.splice(i, 1); changed = true; break;
+      }
+    }
+  }
+  if (ring.length < 3) throw new Error('Degenerate polygon ring');
+  return ring;
+}

package/src/triangulation/containsVertex.js

@@ -0,0 +1,11 @@
+import { equal } from './equal.js';
+import { cross } from './cross.js';
+
+export function containsVertex(polygon, a, b, c) {
+  let p;
+  for (p of polygon) {
+    if (!equal(p, a) && !equal(p, b) && !equal(p, c) &&
+      cross(a, b, p) >= 0 && cross(b, c, p) >= 0 && cross(c, a, p) >= 0) return true;
+  }
+  return false;
+}

package/src/triangulation/cross.js

@@ -0,0 +1,3 @@
+export function cross(a, b, c) {
+  return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+}

package/src/triangulation/crossesBoundary.js

@@ -0,0 +1,8 @@
+import { crossesRing } from './crossesRing.js';
+
+export function crossesBoundary(a, b, polygon, rings) {
+  if (crossesRing(a, b, polygon)) return true;
+  let i;
+  for (i = 1; i < rings.length; i++) if (crossesRing(a, b, rings[i])) return true;
+  return false;
+}

package/src/triangulation/crossesRing.js

@@ -0,0 +1,9 @@
+import { intersects } from './intersects.js';
+
+export function crossesRing(a, b, ring) {
+  let i;
+  for (i = 0; i < ring.length; i++) {
+    if (intersects(a, b, ring[i], ring[(i + 1) % ring.length])) return true;
+  }
+  return false;
+}

package/src/triangulation/equal.js

@@ -0,0 +1,3 @@
+export function equal(a, b) {
+  return a.x === b.x && a.y === b.y;
+}

package/src/triangulation/inside.js

@@ -0,0 +1,10 @@
+export function inside(point, ring) {
+  let result = false;
+  let i, j, a, b;
+  for (i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    a = ring[i], b = ring[j];
+    if ((a.y > point.y) !== (b.y > point.y) &&
+      point.x < (b.x - a.x) * (point.y - a.y) / (b.y - a.y) + a.x) result = !result;
+  }
+  return result;
+}

package/src/triangulation/insideHole.js

@@ -0,0 +1,7 @@
+import { inside } from './inside.js';
+
+export function insideHole(point, rings) {
+  let i;
+  for (i = 1; i < rings.length; i++) if (inside(point, rings[i])) return true;
+  return false;
+}

package/src/triangulation/intersects.js

@@ -0,0 +1,11 @@
+import { equal } from './equal.js';
+import { cross } from './cross.js';
+import { on } from './on.js';
+
+export function intersects(a, b, c, d) {
+  if (equal(a, c) || equal(a, d) || equal(b, c) || equal(b, d)) return false;
+  const abC = cross(a, b, c), abD = cross(a, b, d), cdA = cross(c, d, a), cdB = cross(c, d, b);
+  return abC * abD < 0 && cdA * cdB < 0 ||
+    abC === 0 && on(a, b, c) || abD === 0 && on(a, b, d) ||
+    cdA === 0 && on(c, d, a) || cdB === 0 && on(c, d, b);
+}

package/src/triangulation/isClockWise.js

@@ -0,0 +1,13 @@
+/**
+ * @returns {boolean} Whether the `{x, y}` points are in clockwise order.
+ */
+
+export function isClockWise(points) {
+  let area = 0;
+  let i, a, b;
+  for (i = 0; i < points.length; i++) {
+    a = points[i], b = points[(i + 1) % points.length];
+    area += a.x * b.y - b.x * a.y;
+  }
+  return area < 0;
+}

package/src/triangulation/minimumX.js

@@ -0,0 +1,6 @@
+export function minimumX(ring) {
+  const values = [];
+  let point;
+  for (point of ring) values.push(point.x);
+  return Math.min(...values);
+}

package/src/triangulation/on.js

@@ -0,0 +1,4 @@
+export function on(p, q, r) {
+  return Math.min(p.x, q.x) <= r.x && r.x <= Math.max(p.x, q.x) &&
+    Math.min(p.y, q.y) <= r.y && r.y <= Math.max(p.y, q.y);
+}

package/src/triangulation/sortHoles.js

@@ -0,0 +1,26 @@
+import { minimumX } from './minimumX.js';
+
+export function sortHoles(holes) {
+  const buffer = new Array(holes.length), entries = [];
+  let ring, width, start, middle, end, left, right, output, previous, i;
+  for (ring of holes) entries.push({ ring, x: minimumX(ring) });
+  let source = entries, target = buffer;
+  for (width = 1; width < entries.length; width *= 2) {
+    for (start = 0; start < entries.length; start += width * 2) {
+      middle = Math.min(start + width, entries.length), end = Math.min(start + width * 2, entries.length);
+      left = start, right = middle;
+      for (output = start; output < end; output++) {
+        if (left < middle && (right >= end || source[left].x <= source[right].x)) {
+          target[output] = source[left++];
+        } else {
+          target[output] = source[right++];
+        }
+      }
+    }
+    previous = source;
+    source = target;
+    target = previous;
+  }
+  for (i = 0; i < holes.length; i++) holes[i] = source[i].ring;
+  return holes;
+}

package/src/triangulation/triangulate.js

@@ -0,0 +1,86 @@
+import { isClockWise } from "./isClockWise.js";
+import { cross } from './cross.js';
+import { clean } from './clean.js';
+import { inside } from './inside.js';
+import { insideHole } from './insideHole.js';
+import { crossesBoundary } from './crossesBoundary.js';
+import { containsVertex } from './containsVertex.js';
+import { area } from './area.js';
+import { sortHoles } from './sortHoles.js';
+
+/**
+ * Triangulates a polygon given as `{x, y}` points.
+ * Rings omit the repeated closing point; winding is normalized internally.
+ * Vertex indices remain relative to the original inputs after duplicate/collinear
+ * cleanup. Hole bridges duplicate endpoints, not source vertices.
+ * @param {Object[]} contour Outer boundary.
+ * @param {Object[][]} [holes] Interior boundaries.
+ *
+ * @returns {number[][]} Triangles as indices in `[...contour, ...holes.flat()]`.
+ */
+
+export function triangulate(contour, holes = []) {
+  const points = [contour, ...holes].flat();
+  let p, index, path, ring, hole, bridge, distance, h, a, b, d, mid, h2, p2, clipped, i, c, triangle2;
+  for (p of points) {
+    if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) throw new Error('Invalid polygon coordinates');
+  }
+  // Translate near the origin to avoid cancellation with geographic coordinates.
+  const vertices = [];
+  for (index = 0; index < points.length; index++) {
+    p = points[index];
+    vertices.push({ x: p.x - contour[0].x, y: p.y - contour[0].y, index });
+  }
+  // Remove zero-area corners before connecting holes; keep original vertex indices.
+  let offset = 0;
+  const rings = [], paths = [contour, ...holes];
+  for (index = 0; index < paths.length; index++) {
+    path = paths[index];
+    ring = clean(vertices.slice(offset, offset += path.length));
+    if (isClockWise(ring) !== Boolean(index)) ring.reverse();
+    rings.push(ring);
+  }
+  let polygon = rings[0].slice();
+  // A bridge must stay inside the outer boundary, outside every hole, and cross no edge.
+  // ponytail: quadratic ear clipping for building footprints; use spatial indexing for large rings.
+  const holesToConnect = sortHoles(rings.slice(1));
+  for (hole of holesToConnect) {
+    bridge = void 0, distance = Infinity;
+    for (h = 0; h < hole.length; h++) for (p = 0; p < polygon.length; p++) {
+      a = hole[h], b = polygon[p], d = (a.x - b.x) ** 2 + (a.y - b.y) ** 2;
+      if (d >= distance) continue;
+      mid = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+      if (!inside(mid, rings[0]) || insideHole(mid, rings)) continue;
+      if (crossesBoundary(a, b, polygon, rings)) continue;
+      bridge = [h, p]; distance = d;
+    }
+    if (!bridge) throw new Error('Unable to connect polygon hole');
+    [h2, p2] = bridge;
+    polygon = [...polygon.slice(0, p2 + 1), ...hole.slice(h2), ...hole.slice(0, h2 + 1),
+    polygon[p2], ...polygon.slice(p2 + 1)];
+  }
+  // Clip a convex corner only when no other vertex is inside/on its triangle.
+  const result = [];
+  while (polygon.length > 3) {
+    clipped = false;
+    for (i = 0; i < polygon.length; i++) {
+      a = polygon[(i + polygon.length - 1) % polygon.length], b = polygon[i], c = polygon[(i + 1) % polygon.length];
+      if (cross(a, b, c) <= 1e-10) continue;
+      if (containsVertex(polygon, a, b, c)) continue;
+      result.push([a.index, b.index, c.index]); polygon.splice(i, 1); clipped = true; break;
+    }
+    if (!clipped) throw new Error('Unable to triangulate polygon: invalid or self-intersecting rings');
+  }
+  if (cross(...polygon) > 1e-10) {
+    const triangle = [];
+    for (p of polygon) triangle.push(p.index);
+    result.push(triangle);
+  }
+  // Reject incomplete coverage instead of silently emitting a partial roof.
+  let holeArea = 0, actual = 0;
+  for (i = 1; i < rings.length; i++) holeArea += area(rings[i]);
+  const expected = area(rings[0]) - holeArea;
+  for (triangle2 of result) actual += cross(vertices[triangle2[0]], vertices[triangle2[1]], vertices[triangle2[2]]) / 2;
+  if (expected <= 0 || Math.abs(actual - expected) > Math.max(1e-7, expected * 1e-8)) throw new Error('Polygon triangulation area mismatch');
+  return result;
+}

package/src/utils/channel.js

@@ -0,0 +1,4 @@
+export function channel(n, h, l, a) {
+  const k = (n + h * 12) % 12;
+  return l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1));
+}

package/src/utils/compareDistance.js

@@ -0,0 +1,3 @@
+export function compareDistance(a, b) {
+  return a.distance - b.distance;
+}

package/src/utils/noOperation.js

@@ -0,0 +1 @@
+export function noOperation() {}

package/src/utils/parseColor.js

@@ -0,0 +1,42 @@
+import { toSRGB } from "./toSRGB.js";
+import { channel } from "./channel.js";
+
+/**
+ * HSL inputs are linear-space to preserve the original building styling.
+ * Numeric/CSS/RGB inputs are already sRGB; CSS alpha is not used for extrusion.
+ * @param {number|string|Object} value 0xRRGGBB, CSS color, {r,g,b}, or {h,s,l} in 0..1.
+ * @returns {Object} sRGB {r,g,b} components in 0..1.
+ */
+
+export function parseColor(value) {
+  if (value && typeof value === 'object' && 'h' in value) {
+    const a = value.s * Math.min(value.l, 1 - value.l);
+    return {
+      r: toSRGB(channel(0, value.h, value.l, a)),
+      g: toSRGB(channel(8, value.h, value.l, a)),
+      b: toSRGB(channel(4, value.h, value.l, a))
+    };
+  }
+  if (value && typeof value === 'object' && 'r' in value) {
+    return value;
+  }
+  if (typeof value === 'number') {
+    return {
+      r: (value >> 16 & 255) / 255,
+      g: (value >> 8 & 255) / 255,
+      b: (value & 255) / 255,
+    };
+  }
+  if (typeof value !== 'string' || !CSS.supports('color', value)) {
+    throw new Error('Invalid 3D color');
+  }
+  const context = document.createElement('canvas').getContext('2d');
+  context.fillStyle = value;
+  context.fillRect(0, 0, 1, 1);
+  const [r, g, b] = context.getImageData(0, 0, 1, 1).data;
+  return {
+    r: r / 255,
+    g: g / 255,
+    b: b / 255
+  };
+}

package/src/utils/toSRGB.js

@@ -0,0 +1,3 @@
+export function toSRGB(value) {
+  return value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055;
+}

package/src/utils/wrap.js

@@ -0,0 +1,3 @@
+export function wrap(angle) {
+  return Math.atan2(Math.sin(angle), Math.cos(angle));
+}

package/src/vehicles/bicycleModel.js

@@ -0,0 +1,23 @@
+import { box } from '../geometry/box.js';
+import { skin } from '../constants/skin.js';
+import { trousers } from '../constants/trousers.js';
+import { dark } from '../constants/dark.js';
+import { paints } from '../constants/paints.js';
+
+export function bicycleModel(index) {
+  const paint = paints[index % paints.length];
+  return [
+    [box(-0.045, 0.045, -0.85, -0.25), 0.02, 0.62, dark],
+    [box(-0.045, 0.045, 0.25, 0.85), 0.02, 0.62, dark],
+    [box(-0.06, 0.06, -0.5, 0.5), 0.4, 0.65, paint],
+    [box(-0.32, 0.32, -0.58, -0.5), 0.95, 1.02, dark],
+    [box(-0.1, 0.1, 0.15, 0.4), 0.85, 0.92, dark],
+    [box(-0.18, 0.18, -0.12, 0.28), 1, 1.5, paint],
+    [box(-0.11, 0.11, -0.22, 0), 1.5, 1.72, skin],
+    [box(-0.13, 0.13, -0.23, 0.01), 1.72, 1.8, paint],
+    [box(-0.25, -0.15, -0.5, -0.05), 1, 1.25, skin],
+    [box(0.15, 0.25, -0.5, -0.05), 1, 1.25, skin],
+    [box(-0.2, -0.08, 0, 0.32), 0.3, 1, trousers],
+    [box(0.08, 0.2, -0.25, 0.07), 0.3, 1, trousers],
+  ];
+}

package/src/vehicles/boatBenches.js

@@ -0,0 +1,8 @@
+import { mirror } from './mirror.js';
+
+export function boatBenches() {
+  const benches = [];
+  let i;
+  for (i = 0; i < 12; i++) benches.push(...mirror(0.5, 3.8, -12 + i * 3, -11.3 + i * 3, 3.9, 4.4, [0.62, 0.1, 0.1]));
+  return benches;
+}

package/src/vehicles/boatModel.js

@@ -0,0 +1,27 @@
+import { hull } from '../constants/hull.js';
+import { box } from '../geometry/box.js';
+import { glass } from '../constants/glass.js';
+import { mirror } from './mirror.js';
+import { white } from '../constants/white.js';
+import { boatBenches } from './boatBenches.js';
+
+// Panoramic river cruiser, about 60 x 11 m.
+export function boatModel() {
+  return [
+    [hull, 0, 0.8, [0.1, 0.16, 0.26]],
+    [hull, 0.8, 1.4, white],
+    [box(-5, 5, -18, 26), 1.4, 3.7, glass, box(-4.6, 4.6, -17.4, 25.6)],
+    ...mirror(4.64, 4.74, -17, 25, 3.25, 3.45, [1.6, 1.25, 0.8]),
+    [box(-4.8, 4.8, -17.8, 25.8), 3.7, 3.9, white],
+    ...boatBenches(),
+    ...mirror(4.65, 4.8, -13.6, 25.8, 3.9, 4.8, white),
+    [box(-4.8, 4.8, 25.65, 25.8), 3.9, 4.8, white],
+    [box(-2.2, 2.2, -17.6, -14), 3.9, 4.7, white],
+    [box(-2.2, 2.2, -17.6, -14), 4.7, 5.5, glass],
+    [box(-2.5, 2.5, -18, -13.6), 5.5, 5.7, white],
+    [box(-2.45, -2.2, -16.2, -15.8), 5, 5.3, [2, 0.15, 0.1]],
+    [box(2.2, 2.45, -16.2, -15.8), 5, 5.3, [0.1, 2, 0.4]],
+    [box(-0.1, 0.1, -15.9, -15.7), 5.7, 6.6, white],
+    [box(-0.15, 0.15, -15.95, -15.65), 6.6, 6.8, [2, 2, 1.9]],
+  ];
+}

package/src/vehicles/busModel.js

@@ -0,0 +1,6 @@
+import { routeColor } from '../traffic/routeColor.js';
+import { carriage } from './carriage.js';
+
+export function busModel(index, properties) {
+  return carriage(0, 12, routeColor(properties));
+}

package/src/vehicles/carModel.js

@@ -0,0 +1,22 @@
+import { box } from '../geometry/box.js';
+import { glass } from '../constants/glass.js';
+import { tyre } from '../constants/tyre.js';
+import { mirror } from './mirror.js';
+import { paints } from '../constants/paints.js';
+import { headlight } from '../constants/headlight.js';
+import { taillight } from '../constants/taillight.js';
+
+export function carModel(i) {
+  const paint = paints[i % paints.length];
+  return [
+    ...mirror(0.7, 0.92, -1.68, -1.02, 0, 0.64, tyre),
+    ...mirror(0.7, 0.92, 1.02, 1.68, 0, 0.64, tyre),
+    [[[-0.9, -1.95], [-0.72, -2.25], [0.72, -2.25], [0.9, -1.95], [0.9, 2.05], [0.76, 2.25], [-0.76, 2.25], [-0.9, 2.05]],
+      0.28, 0.82, paint],
+    // Greenhouse: the windscreen leans back, the rear window less.
+    [box(-0.84, 0.84, -0.75, 1.6), 0.82, 1.38, glass, box(-0.7, 0.7, -0.05, 1.3)],
+    [box(-0.71, 0.71, -0.06, 1.31), 1.38, 1.46, paint],
+    ...mirror(0.38, 0.8, -2.3, -2.16, 0.56, 0.76, headlight),
+    [box(-0.78, 0.78, 2.16, 2.3), 0.6, 0.76, taillight],
+  ];
+}

package/src/vehicles/carriage.js

@@ -0,0 +1,19 @@
+import { box } from '../geometry/box.js';
+import { glass } from '../constants/glass.js';
+import { tyre } from '../constants/tyre.js';
+import { white } from '../constants/white.js';
+import { headlight } from '../constants/headlight.js';
+import { taillight } from '../constants/taillight.js';
+
+export function carriage(center, length, color) {
+  const front = center - length / 2, rear = center + length / 2;
+  return [
+    [box(-1.25, 1.25, front, rear), 0.45, 1.25, color],
+    [box(-1.2, 1.2, front + 0.15, rear - 0.15), 1.25, 2.65, glass],
+    [box(-1.25, 1.25, front, rear), 2.65, 3.1, white],
+    [box(-1.15, -0.85, front + 1, front + 2), 0, 0.7, tyre],
+    [box(0.85, 1.15, rear - 2, rear - 1), 0, 0.7, tyre],
+    [box(-0.9, 0.9, front - 0.03, front), 0.8, 1.05, headlight],
+    [box(-0.9, 0.9, rear, rear + 0.03), 0.8, 1.05, taillight],
+  ];
+}

package/src/vehicles/metroModel.js

@@ -0,0 +1,9 @@
+import { routeColor } from '../traffic/routeColor.js';
+import { carriage } from './carriage.js';
+
+export function metroModel(index, properties) {
+  const color = routeColor(properties), parts = [];
+  let car;
+  for (car = 0; car < 5; car++) parts.push(...carriage((car - 2) * 15, 14, color));
+  return parts;
+}

package/src/vehicles/mirror.js

@@ -0,0 +1,8 @@
+import { box } from "../geometry/box.js";
+
+export function mirror(x0, x1, z0, z1, ...rest) {
+  return [
+    [box(x0, x1, z0, z1), ...rest],
+    [box(-x1, -x0, z0, z1), ...rest]
+  ];
+}

package/src/vehicles/pedestrianModel.js

@@ -0,0 +1,17 @@
+import { box } from '../geometry/box.js';
+import { parts } from '../constants/parts.js';
+import { skin } from '../constants/skin.js';
+import { trousers } from '../constants/trousers.js';
+import { paints } from '../constants/paints.js';
+
+export function pedestrianModel(index) {
+  const model = parts.body.slice();
+  model[1] = [model[1][0], model[1][1], model[1][2], paints[index % paints.length]];
+  model.push(
+    [box(-0.16, -0.02, -0.07, 0.07), 0.08, 0.9, trousers],
+    [box(0.02, 0.16, -0.07, 0.07), 0.08, 0.9, trousers],
+    [box(-0.3, -0.2, -0.05, 0.05), 0.76, 1.42, skin],
+    [box(0.2, 0.3, -0.05, 0.05), 0.76, 1.42, skin],
+  );
+  return model;
+}

package/src/vehicles/tramModel.js

@@ -0,0 +1,9 @@
+import { routeColor } from '../traffic/routeColor.js';
+import { carriage } from './carriage.js';
+
+export function tramModel(index, properties) {
+  const color = routeColor(properties), parts = [];
+  let car;
+  for (car = 0; car < 5; car++) parts.push(...carriage((car - 2) * 6.5, 6, color));
+  return parts;
+}

package/src/walk/blocked.js

@@ -0,0 +1,6 @@
+import { hit } from '../picking/hit.js';
+
+export function blocked(east, north, feet) {
+  const length = Math.hypot(east, north);
+  return length > 1e-6 && hit(this.layer, feet[0], feet[1], feet[2], east / length, -north / length, length + 0.3);
+}