leaflet-city-mapper 0.0.3 → 0.0.5

package/src/traffic/trafficStatusText.js

@@ -0,0 +1,5 @@
+export function trafficStatusText(state, valid) {
+  if (!valid) return `${state.vehicle}: select a valid simulation date`;
+  if (!state.loaded) return `${state.vehicle}: loading…`;
+  return `${state.trips.length} ${state.vehicle === 'boat' ? 'boats' : state.vehicle}`;
+}

package/src/traffic/trafficStorage.js

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

package/src/traffic/trafficTooltip.js

@@ -0,0 +1,9 @@
+export function tooltip({ properties: p }) {
+  const content = document.createElement('div');
+  content.style.whiteSpace = 'pre-line';
+  let text = p.name ? String(p.name) : '';
+  if (p.departure) text += `${text ? '\n' : ''}Departure ${p.departure} ${p.timetable.timeZone}`;
+  if (p.description) text += `${text ? '\n' : ''}${p.description}`;
+  content.textContent = text;
+  return content;
+}

package/src/traffic/tripsAt.js

@@ -4,21 +4,21 @@ 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 = [];
+  const trips = /* alloc */ [];
   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({
+      for (trip of scheduledTrips(time, timetable)) trips.push(/* alloc */ {
         id: `${l}-${trip.id}`, lane, distance: trip.progress * lane.length, speed: lane.length / (timetable.duration * 60),
-        properties: { ...lane.properties, departure: trip.departure },
+        properties: /* alloc */ { ...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({
+      for (k = 0; k < offsets.length; k++) trips.push(/* alloc */ {
         id: `${l}-${k}`, lane, distance: (offsets[k] + travelled) % lane.length, speed: velocity, properties: lane.properties,
       });
     }

package/src/traffic/updateTraffic.js

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

package/src/traffic/updateTrafficLights.js

@@ -0,0 +1,18 @@
+import { locateTraffic } from './locateTraffic.js';
+
+export function updateTrafficLights(state) {
+  state.litAt = performance.now();
+  const lights = /* alloc */ [];
+  const target = state.position ||= /* alloc */ {};
+  let trip, x, y, z, dx, dz, lx, ly, lz, light;
+  for (trip of state.trips) {
+    ({ x, y, z, dx, dz } = locateTraffic(state, trip, target));
+    for (light of state.lights) {
+      [lx, ly, lz] = light.position;
+      lights.push(/* alloc */ {
+        ...light, position: /* alloc */ [x - lx * dz - lz * dx, y + ly, z + lx * dx - lz * dz],
+      });
+    }
+  }
+  state.mesh.extras.lights = lights;
+}

package/src/traffic/updateTrafficPose.js

@@ -0,0 +1,8 @@
+import { moveTraffic } from './moveTraffic.js';
+import { updateTrafficLights } from './updateTrafficLights.js';
+
+export function updateTrafficPose(state, ms, live) {
+  if (!state.mesh) return;
+  moveTraffic(state, (ms - state.rebasedAt) / 1000);
+  if (state.lights && (!live || !(performance.now() - state.litAt < 100))) updateTrafficLights(state);
+}

package/src/traffic/uploadTrafficLanes.js

@@ -0,0 +1,21 @@
+import { trafficStorage } from './trafficStorage.js';
+
+export function uploadTrafficLanes(state, device) {
+  let lane, i, point, count = 0;
+  for (lane of state.lanes) count += lane.points.length;
+  const data = /* alloc */ new Float32Array(count * 4);
+  let offset = 0;
+  for (lane of state.lanes) {
+    lane.start = offset / 4;
+    for (i = 0; i < lane.points.length; i++) {
+      point = lane.points[i];
+      data[offset++] = point[0];
+      data[offset++] = point[1];
+      data[offset++] = point[2];
+      data[offset++] = lane.lengths[i];
+    }
+  }
+  state.gpu.points?.destroy();
+  state.gpu.points = trafficStorage(device, data);
+  state.lanesDirty = false;
+}

package/src/traffic/vehicleOffsets.js

@@ -1,10 +1,11 @@
-import { speed } from "../constants/speed.js";
+import { speed } from '../globals/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 });
+  const offsets = Array.from(/* alloc */ { length: count });
   let i;
   for (i = 0; i < offsets.length; i++) offsets[i] = (i + 0.5) * length / count;
   return offsets;

package/src/transforms/composeLocalTransform.js

@@ -0,0 +1,16 @@
+import { degrees } from '../globals/degrees.js';
+
+export function composeLocalTransform(node) {
+  const matrix = node._localTransform ||= /* alloc */ new DOMMatrix();
+  matrix.m11 = 1, matrix.m12 = 0, matrix.m13 = 0, matrix.m14 = 0;
+  matrix.m21 = 0, matrix.m22 = 1, matrix.m23 = 0, matrix.m24 = 0;
+  matrix.m31 = 0, matrix.m32 = 0, matrix.m33 = 1, matrix.m34 = 0;
+  matrix.m41 = 0, matrix.m42 = 0, matrix.m43 = 0, matrix.m44 = 1;
+  matrix.translateSelf(node.position[0], node.position[1], node.position[2]);
+  // Node rotations use YXZ, as did the previous renderer.
+  matrix.rotateAxisAngleSelf(0, 1, 0, node.rotation[1] * degrees);
+  matrix.rotateAxisAngleSelf(1, 0, 0, node.rotation[0] * degrees);
+  matrix.rotateAxisAngleSelf(0, 0, 1, node.rotation[2] * degrees);
+  matrix.scaleSelf(node.scale[0], node.scale[1], node.scale[2]);
+  return matrix;
+}

package/src/{models/nodeMatrix.js → transforms/modelNodeMatrix.js}

@@ -1,10 +1,15 @@
+import { geometryQuaternion } from '../globals/geometryQuaternion.js';
+import { geometryScale } from '../globals/geometryScale.js';
+import { geometryTranslation } from '../globals/geometryTranslation.js';
 /** glTF quaternion/translation/scale to a column-major matrix. */
 
+
 export function nodeMatrix(spec) {
   if (spec.matrix) return Array.from(spec.matrix);
   // glTF stores quaternions [x,y,z,w]; convert directly to a scaled column-major matrix.
-  const [x, y, z, w] = spec.rotation || [0, 0, 0, 1], [sx, sy, sz] = spec.scale || [1, 1, 1];
-  return [
+  const [x, y, z, w] = spec.rotation || geometryQuaternion;
+  const [sx, sy, sz] = spec.scale || geometryScale;
+  return /* alloc */ [
     (1 - 2 * (y * y + z * z)) * sx,
     2 * (x * y + z * w) * sx,
     2 * (x * z - y * w) * sx,
@@ -16,7 +21,7 @@ export function nodeMatrix(spec) {
     2 * (y * z - x * w) * sz,
     (1 - 2 * (x * x + y * y)) * sz,
     0,
-    ...(spec.translation || [0, 0, 0]),
+    ...(spec.translation || geometryTranslation),
     1,
   ];
 }

package/src/transforms/transformNativePoint.js

@@ -0,0 +1,7 @@
+export function transformNativePoint(target, matrix, x, y, z, w) {
+  target.x = matrix.m11 * x + matrix.m21 * y + matrix.m31 * z + matrix.m41 * w;
+  target.y = matrix.m12 * x + matrix.m22 * y + matrix.m32 * z + matrix.m42 * w;
+  target.z = matrix.m13 * x + matrix.m23 * y + matrix.m33 * z + matrix.m43 * w;
+  target.w = matrix.m14 * x + matrix.m24 * y + matrix.m34 * z + matrix.m44 * w;
+  return target;
+}

package/src/transforms/updateWorldMatrix.js

@@ -0,0 +1,43 @@
+import { worldMatrixChanged } from './worldMatrixChanged.js';
+import { composeLocalTransform } from './composeLocalTransform.js';
+
+/** Compose parent*local matrices; a node.matrix overrides its position/rotation/scale. */
+
+export function updateWorldMatrix(node) {
+  const parent = node.parent;
+  const parentVersion = parent?._worldMatrixVersion || 0;
+  const matrixMode = Boolean(node.matrix);
+  let changed = node._worldParent !== parent || node._parentWorldVersion !== parentVersion ||
+    node._worldMatrixMode !== matrixMode;
+  let child;
+  changed = worldMatrixChanged(node, changed);
+  if (!changed) {
+    for (child of node.children) updateWorldMatrix(child);
+    return;
+  }
+  let local, world;
+  if (node.matrix) local = node.matrix;
+  else local = composeLocalTransform(node);
+  world = node._worldTransform ||= /* alloc */ new DOMMatrix();
+  if (local instanceof DOMMatrix) {
+    world.m11 = local.m11, world.m12 = local.m12, world.m13 = local.m13, world.m14 = local.m14;
+    world.m21 = local.m21, world.m22 = local.m22, world.m23 = local.m23, world.m24 = local.m24;
+    world.m31 = local.m31, world.m32 = local.m32, world.m33 = local.m33, world.m34 = local.m34;
+    world.m41 = local.m41, world.m42 = local.m42, world.m43 = local.m43, world.m44 = local.m44;
+  } else {
+    world.m11 = local[0], world.m12 = local[1], world.m13 = local[2], world.m14 = local[3];
+    world.m21 = local[4], world.m22 = local[5], world.m23 = local[6], world.m24 = local[7];
+    world.m31 = local[8], world.m32 = local[9], world.m33 = local[10], world.m34 = local[11];
+    world.m41 = local[12], world.m42 = local[13], world.m43 = local[14], world.m44 = local[15];
+  }
+  if (parent) world.preMultiplySelf(parent._worldTransform);
+  node.worldMatrix[0] = world.m11, node.worldMatrix[1] = world.m12, node.worldMatrix[2] = world.m13, node.worldMatrix[3] = world.m14;
+  node.worldMatrix[4] = world.m21, node.worldMatrix[5] = world.m22, node.worldMatrix[6] = world.m23, node.worldMatrix[7] = world.m24;
+  node.worldMatrix[8] = world.m31, node.worldMatrix[9] = world.m32, node.worldMatrix[10] = world.m33, node.worldMatrix[11] = world.m34;
+  node.worldMatrix[12] = world.m41, node.worldMatrix[13] = world.m42, node.worldMatrix[14] = world.m43, node.worldMatrix[15] = world.m44;
+  node._worldParent = parent;
+  node._parentWorldVersion = parentVersion;
+  node._worldMatrixMode = matrixMode;
+  node._worldMatrixVersion = (node._worldMatrixVersion || 0) + 1;
+  for (child of node.children) updateWorldMatrix(child);
+}

package/src/transforms/worldMatrixChanged.js

@@ -0,0 +1,18 @@
+export function worldMatrixChanged(node, changed) {
+  let i, value;
+  if (node.matrix) {
+    const state = node._matrixState ||= /* alloc */ new Float64Array(16);
+    for (i = 0; i < 16; i++) {
+      if (state[i] !== node.matrix[i]) changed = true;
+      state[i] = node.matrix[i];
+    }
+  } else {
+    const state = node._transformState ||= /* alloc */ new Float64Array(9);
+    for (i = 0; i < 9; i++) {
+      value = i < 3 ? node.position[i] : i < 6 ? node.rotation[i - 3] : node.scale[i - 6];
+      if (state[i] !== value) changed = true;
+      state[i] = value;
+    }
+  }
+  return changed;
+}

package/src/triangulation/clean.js

@@ -13,6 +13,6 @@ export function clean(ring) {
       }
     }
   }
-  if (ring.length < 3) throw new Error('Degenerate polygon ring');
+  if (ring.length < 3) throw /* alloc */ new Error('Degenerate polygon ring');
   return ring;
 }

package/src/triangulation/clipEars.js

@@ -0,0 +1,23 @@
+import { cross } from './cross.js';
+import { containsVertex } from './containsVertex.js';
+
+export function clipEars(polygon) {
+  const result = /* alloc */ [];
+  let clipped, i, a, b, c, p;
+  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(/* alloc */ [a.index, b.index, c.index]); polygon.splice(i, 1); clipped = true; break;
+    }
+    if (!clipped) throw /* alloc */ new Error('Unable to triangulate polygon: invalid or self-intersecting rings');
+  }
+  if (cross(...polygon) > 1e-10) {
+    const triangle = /* alloc */ [];
+    for (p of polygon) triangle.push(p.index);
+    result.push(triangle);
+  }
+  return result;
+}

package/src/triangulation/connectHole.js

@@ -0,0 +1,18 @@
+import { inside } from './inside.js';
+import { insideHole } from './insideHole.js';
+import { crossesBoundary } from './crossesBoundary.js';
+
+export function connectHole(polygon, hole, rings, mid) {
+  let h2 = -1, p2 = -1, distance = Infinity, h, p, a, b, d;
+  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; mid.y = (a.y + b.y) / 2;
+    if (!inside(mid, rings[0]) || insideHole(mid, rings)) continue;
+    if (crossesBoundary(a, b, polygon, rings)) continue;
+    h2 = h; p2 = p; distance = d;
+  }
+  if (h2 < 0) throw /* alloc */ new Error('Unable to connect polygon hole');
+  return /* alloc */ [...polygon.slice(0, p2 + 1), ...hole.slice(h2), ...hole.slice(0, h2 + 1),
+    polygon[p2], ...polygon.slice(p2 + 1)];
+}

package/src/triangulation/mergeHoles.js

@@ -0,0 +1,11 @@
+export function mergeHoles(source, target, start, width) {
+  const middle = Math.min(start + width, source.length), end = Math.min(start + width * 2, source.length);
+  let left = start, right = middle, output;
+  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++];
+    }
+  }
+}

package/src/triangulation/minimumX.js

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

package/src/triangulation/polygonRings.js

@@ -0,0 +1,14 @@
+import { clean } from './clean.js';
+import { isClockWise } from './isClockWise.js';
+
+export function polygonRings(paths, vertices) {
+  const rings = /* alloc */ [];
+  let offset = 0, index, path, ring;
+  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);
+  }
+  return rings;
+}

package/src/triangulation/sortHoles.js

@@ -1,21 +1,16 @@
 import { minimumX } from './minimumX.js';
+import { mergeHoles } from './mergeHoles.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) });
+  if (holes.length < 2) return holes;
+  const buffer = /* alloc */ new Array(holes.length);
+  const entries = /* alloc */ [];
+  let ring, width, start, previous, i;
+  for (ring of holes) entries.push(/* alloc */ { 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++];
-        }
-      }
+      mergeHoles(source, target, start, width);
     }
     previous = source;
     source = target;

package/src/triangulation/triangulate.js

@@ -1,12 +1,10 @@
-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 { geometryEmpty } from '../globals/geometryEmpty.js';
 import { sortHoles } from './sortHoles.js';
+import { polygonRings } from './polygonRings.js';
+import { connectHole } from './connectHole.js';
+import { clipEars } from './clipEars.js';
+import { validateArea } from './validateArea.js';
+
 
 /**
  * Triangulates a polygon given as `{x, y}` points.
@@ -19,68 +17,32 @@ import { sortHoles } from './sortHoles.js';
  * @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;
+export function triangulate(contour, holes = geometryEmpty) {
+  const paths = /* alloc */ [contour, ...holes];
+  const points = paths.flat();
+  let p, index, hole;
   for (p of points) {
-    if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) throw new Error('Invalid polygon coordinates');
+    if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) throw /* alloc */ new Error('Invalid polygon coordinates');
   }
   // Translate near the origin to avoid cancellation with geographic coordinates.
-  const vertices = [];
+  const vertices = /* alloc */ [];
   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 });
+    vertices.push(/* alloc */ { 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);
-  }
+  const rings = polygonRings(paths, vertices);
   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));
+  const mid = holesToConnect.length ? /* alloc */ { x: 0, y: 0 } : null;
   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)];
+    polygon = connectHole(polygon, hole, rings, mid);
   }
   // 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);
-  }
+  const result = clipEars(polygon);
   // 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');
+  validateArea(rings, vertices, result);
   return result;
 }

package/src/triangulation/validateArea.js

@@ -0,0 +1,10 @@
+import { area } from './area.js';
+import { cross } from './cross.js';
+
+export function validateArea(rings, vertices, result) {
+  let holeArea = 0, actual = 0, i, triangle;
+  for (i = 1; i < rings.length; i++) holeArea += area(rings[i]);
+  const expected = area(rings[0]) - holeArea;
+  for (triangle of result) actual += cross(vertices[triangle[0]], vertices[triangle[1]], vertices[triangle[2]]) / 2;
+  if (expected <= 0 || Math.abs(actual - expected) > Math.max(1e-7, expected * 1e-8)) throw /* alloc */ new Error('Polygon triangulation area mismatch');
+}

package/src/vehicles/bicycleModel.js

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

package/src/vehicles/boatBenches.js

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

package/src/vehicles/boatModel.js

@@ -1,27 +1,35 @@
-import { hull } from '../constants/hull.js';
+import { hull } from '../globals/hull.js';
+import { white } from '../globals/white.js';
+import { glass } from '../globals/glass.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 { mirror } from './mirrorVehiclePart.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],
+  return /* alloc */ [
+    /* alloc */ [
+      hull, 0, 0.8, /* alloc */ [0.1, 0.16, 0.26]],
+    /* alloc */ [hull, 0.8, 1.4, white],
+    /* alloc */ [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, /* alloc */ [1.6, 1.25, 0.8]),
+    /* alloc */ [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]],
+    /* alloc */ [box(-4.8, 4.8, 25.65, 25.8), 3.9, 4.8, white],
+    /* alloc */ [box(-2.2, 2.2, -17.6, -14), 3.9, 4.7, white],
+    /* alloc */ [box(-2.2, 2.2, -17.6, -14), 4.7, 5.5, glass],
+    /* alloc */ [box(-2.5, 2.5, -18, -13.6), 5.5, 5.7, white],
+    /* alloc */ [
+      box(-2.45, -2.2, -16.2, -15.8), 5, 5.3, /* alloc */ [2, 0.15, 0.1]],
+    /* alloc */ [
+      box(2.2, 2.45, -16.2, -15.8), 5, 5.3, /* alloc */ [0.1, 2, 0.4]],
+    /* alloc */ [box(-0.1, 0.1, -15.9, -15.7), 5.7, 6.6, white],
+    /* alloc */ [
+      box(-0.15, 0.15, -15.95, -15.65), 6.6, 6.8, /* alloc */ [2, 2, 1.9]],
   ];
 }

package/src/vehicles/buildCarriage.js

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

package/src/vehicles/busModel.js

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