leaflet-city-mapper 0.0.1 → 0.0.3

package/src/utils/scene.js

@@ -1,102 +0,0 @@
-/** A fresh, empty scene-graph node. */
-export const emptyNode = () => ({
-  position: [0, 0, 0],
-  rotation: [0, 0, 0],
-  scale: [1, 1, 1],
-  worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-  children: [],
-  visible: true,
-});
-
-/** Reparent/detach scene data without drawing or disposing GPU resources. */
-export function setParent(node, parent) {
-  if (node.parent) node.parent.children.splice(node.parent.children.indexOf(node), 1);
-  node.parent = parent;
-  if (parent) parent.children.push(node);
-}
-
-/** Depth-first walk; a truthy callback result skips that node's descendants. */
-export function traverse(node, callback) {
-  if (callback(node)) return;
-  for (const child of node.children) traverse(child, callback);
-}
-
-/** 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;
-  if (node.matrix) {
-    const state = node._matrixState ||= new Float64Array(16);
-    for (let i = 0; i < 16; i++) {
-      if (state[i] !== node.matrix[i]) changed = true;
-      state[i] = node.matrix[i];
-    }
-  } else {
-    const state = node._transformState ||= new Float64Array(9);
-    for (let i = 0; i < 9; i++) {
-      const 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;
-    }
-  }
-  if (!changed) {
-    for (const child of node.children) updateWorldMatrix(child);
-    return;
-  }
-  let local;
-  if (node.matrix) local = node.matrix;
-  else {
-    const degrees = 180 / Math.PI;
-    const matrix = new DOMMatrix().translate(...node.position);
-    // 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);
-    local = matrix.scale(...node.scale).toFloat64Array();
-  }
-  const world = parent
-    ? new DOMMatrix(parent.worldMatrix).multiply(new DOMMatrix(local)).toFloat64Array()
-    : local;
-  for (let i = 0; i < 16; i++) node.worldMatrix[i] = world[i];
-  node._worldParent = parent;
-  node._parentWorldVersion = parentVersion;
-  node._worldMatrixMode = matrixMode;
-  node._worldMatrixVersion = (node._worldMatrixVersion || 0) + 1;
-  for (const child of node.children) updateWorldMatrix(child);
-}
-
-/** Orthonormal view basis plus perspective matrices, refreshed before projecting/drawing. */
-export function updateCamera(camera) {
-  const z       = camera.position.map((v, i) => v - camera.target[i]);
-  const zLength = Math.hypot(...z) || 1;
-  const cross   = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
-  for (let i = 0; i < 3; i++) {
-    z[i] /= zLength;
-  }
-  const x = cross(camera.up, z), xLength = Math.hypot(...x) || 1;
-  for (let i = 0; i < 3; i++) {
-    x[i] /= xLength;
-  }
-  const y = cross(z, x);
-  const view = new DOMMatrix([x[0], x[1], x[2], 0, y[0], y[1], y[2], 0, z[0], z[1], z[2], 0, ...camera.position, 1]).inverse().toFloat64Array();
-  if (![...view].every(Number.isFinite)) {
-    throw new Error('Singular 3D transform');
-  }
-  for (let i = 0; i < 16; i++) {
-    camera.viewMatrix[i] = view[i];
-  }
-  const f = 1 / Math.tan(camera.fov * Math.PI / 360),
-        n = camera.near,
-        r = camera.far;
-  const projection = [f / camera.aspect, 0, 0, 0, 0, f, 0, 0, 0, 0, r / (n - r), -1, 0, 0, r * n / (n - r), 0];
-  for (let i = 0; i < 16; i++) {
-    camera.projectionMatrix[i] = projection[i];
-  }
-  const projectionView = new DOMMatrix(camera.projectionMatrix).multiply(new DOMMatrix(camera.viewMatrix)).toFloat64Array();
-  for (let i = 0; i < 16; i++) {
-    camera.projectionViewMatrix[i] = projectionView[i];
-  }
-}

package/src/utils/sun.js

@@ -1,71 +0,0 @@
-// Solar centre, without atmospheric refraction.
-export function solarPosition(date, lat, lng) {
-  const time = new Date(date).getTime();
-  if (!Number.isFinite(time) || !Number.isFinite(lat) || Math.abs(lat) > 90 ||
-    !Number.isFinite(lng) || Math.abs(lng) > 180) throw new Error('Invalid solar date or location');
-  const rad = Math.PI / 180, d = time / 86400000 - 10957.5;
-  const mean = (357.5291 + 0.98560028 * d) * rad;
-  const longitude = mean + (1.9148 * Math.sin(mean) + 0.02 * Math.sin(2 * mean) +
-    0.0003 * Math.sin(3 * mean) + 102.9372 + 180) * rad;
-  const obliquity = 23.4397 * rad;
-  const declination = Math.asin(Math.sin(longitude) * Math.sin(obliquity));
-  const ascension = Math.atan2(Math.sin(longitude) * Math.cos(obliquity), Math.cos(longitude));
-  return horizontalPosition(d, lat, lng, ascension, declination);
-}
-
-function horizontalPosition(d, lat, lng, ascension, declination) {
-  const rad = Math.PI / 180;
-  const hourAngle = (280.16 + 360.9856235 * d + lng) * rad - ascension;
-  const latitude = lat * rad;
-  const altitude = Math.asin(Math.sin(latitude) * Math.sin(declination) +
-    Math.cos(latitude) * Math.cos(declination) * Math.cos(hourAngle));
-  const southAzimuth = Math.atan2(Math.sin(hourAngle),
-    Math.cos(hourAngle) * Math.sin(latitude) - Math.tan(declination) * Math.cos(latitude));
-  const azimuth = (southAzimuth / rad + 180 + 360) % 360;
-  return { altitude: altitude / rad, azimuth,
-    direction: [Math.sin(azimuth * rad) * Math.cos(altitude), Math.sin(altitude),
-      -Math.cos(azimuth * rad) * Math.cos(altitude)] };
-}
-
-// Low-precision geocentric lunar orbit; no parallax or atmospheric refraction.
-export function moonPosition(date, lat, lng) {
-  solarPosition(date, lat, lng);
-  const rad = Math.PI / 180, d = new Date(date).getTime() / 86400000 - 10957.5;
-  const anomaly = (134.963 + 13.064993 * d) * rad;
-  const longitude = (218.316 + 13.176396 * d + 6.289 * Math.sin(anomaly)) * rad;
-  const latitude = 5.128 * Math.sin((93.272 + 13.229350 * d) * rad) * rad;
-  const obliquity = 23.4397 * rad;
-  const x = Math.cos(latitude) * Math.cos(longitude);
-  const y = Math.cos(latitude) * Math.sin(longitude) * Math.cos(obliquity) - Math.sin(latitude) * Math.sin(obliquity);
-  const z = Math.cos(latitude) * Math.sin(longitude) * Math.sin(obliquity) + Math.sin(latitude) * Math.cos(obliquity);
-  return horizontalPosition(d, lat, lng, Math.atan2(y, x), Math.asin(z));
-}
-
-export function atmosphere(altitude) {
-  if (!Number.isFinite(altitude)) throw new Error('Invalid solar altitude');
-  const stops = [
-    [-18, [3, 7, 20], [17, 28, 54], [0.025, 0.04, 0.09]],
-    [-6, [37, 53, 84], [182, 106, 86], [0.12, 0.10, 0.14]],
-    [0, [101, 131, 171], [246, 170, 115], [0.38, 0.24, 0.18]],
-    [10, [74, 147, 208], [197, 221, 237], [0.80, 0.75, 0.68]],
-    [25, [53, 144, 213], [223, 238, 250], [1, 1, 1]],
-  ];
-  const upper = stops.findIndex(stop => stop[0] >= altitude);
-  const b = stops[upper < 0 ? stops.length - 1 : upper], a = stops[Math.max(0, upper - 1)];
-  const t = a === b || upper < 0 ? 1 : (altitude - a[0]) / (b[0] - a[0]);
-  const mix = index => a[index].map((value, i) => value + (b[index][i] - value) * t);
-  const rgb = values => `rgb(${values.map(Math.round).join(', ')})`;
-  return { background: `linear-gradient(${rgb(mix(1))}, ${rgb(mix(2))})`, tint: mix(3) };
-}
-
-/** Perspective projection of a celestial direction; null when behind the camera. */
-export function projectCelestialBody(direction, size, pitch, bearing) {
-  const [x, y, z] = direction;
-  const right = x * Math.cos(bearing) - z * Math.sin(bearing);
-  const up = -x * Math.sin(bearing) * Math.cos(pitch) + y * Math.sin(pitch) - z * Math.cos(bearing) * Math.cos(pitch);
-  const forward = -x * Math.sin(bearing) * Math.sin(pitch) - y * Math.cos(pitch) - z * Math.cos(bearing) * Math.sin(pitch);
-  if (forward <= 0) return null;
-  const left = size.x / 2 + size.y * 1.5 * right / forward;
-  const top = size.y / 2 - size.y * 1.5 * up / forward;
-  return { left, top };
-}

package/src/utils/terrain.js

@@ -1,78 +0,0 @@
-/** Height inside a bridge deck, or null outside its triangles. */
-export function bridgeElevation(point, bridges) {
-  // Bridges bucketed by 64 DEM pixels.
-  for (const bridge of bridges?.get(`${Math.floor(point.x / 64)}/${Math.floor(point.y / 64)}`) || []) {
-    if (point.x < bridge.min[0] || point.x > bridge.max[0] || point.y < bridge.min[1] || point.y > bridge.max[1]) continue;
-    for (const [a, b, c] of bridge.triangles) {
-      const d = (b[1] - c[1]) * (a[0] - c[0]) + (c[0] - b[0]) * (a[1] - c[1]);
-      const u = ((b[1] - c[1]) * (point.x - c[0]) + (c[0] - b[0]) * (point.y - c[1])) / d;
-      const v = ((c[1] - a[1]) * (point.x - c[0]) + (a[0] - c[0]) * (point.y - c[1])) / d;
-      if (u >= 0 && v >= 0 && u + v <= 1) return u * a[2] + v * b[2] + (1 - u - v) * c[2];
-    }
-  }
-  return null;
-}
-
-/** Bilinear DEM sampling, with the original first-valid-neighbour no-data rule. */
-export function terrainElevation(point, tiles) {
-  const x = point.x - 0.5, y = point.y - 0.5;
-  const x0 = Math.floor(x), y0 = Math.floor(y);
-  const fx = x - x0, fy = y - y0;
-  const sample = (px, py) => {
-    const tileX = Math.floor(px / 256), tileY = Math.floor(py / 256);
-    const tile = tiles.get(`${tileX}/${tileY}`);
-    if (!tile) return null;
-    const elevation = tile[(py - tileY * 256) * 256 + px - tileX * 256];
-    return Number.isFinite(elevation) && elevation > -1000 ? elevation : null;
-  };
-  const values = [sample(x0, y0), sample(x0 + 1, y0), sample(x0, y0 + 1), sample(x0 + 1, y0 + 1)];
-  const valid = values.map((value, i) => Number.isFinite(value) ? i : -1).filter(i => i >= 0);
-  if (!valid.length) return null;
-  if (valid.length < 4) return values[valid[0]];
-  return (values[0] * (1 - fx) + values[1] * fx) * (1 - fy) +
-    (values[2] * (1 - fx) + values[3] * fx) * fy;
-}
-
-/** Unit tile grid; the vertex shader supplies the elevation. */
-export function terrainGrid(divisions) {
-  const positions = [], normals = [], uvs = [], indices = [];
-  for (let row = 0; row <= divisions; row++) {
-    for (let column = 0; column <= divisions; column++) {
-      positions.push(column / divisions, 0, row / divisions);
-      normals.push(0, 1, 0);
-      uvs.push(column / divisions, row / divisions);
-      if (row < divisions && column < divisions) {
-        const a = row * (divisions + 1) + column;
-        const b = a + 1, c = a + divisions + 1, d = c + 1;
-        indices.push(a, c, b, b, c, d);
-      }
-    }
-  }
-  return {
-    position: { size: 3, data: new Float32Array(positions) },
-    normal:   { size: 3, data: new Float32Array(normals) },
-    uv:       { size: 2, data: new Float32Array(uvs) },
-    index:    { data: new Uint16Array(indices) },
-  };
-}
-
-/** Float32 DEM atlas; missing samples retain the shader no-data sentinel. */
-export function terrainAtlas(tiles, bounds) {
-  const columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
-  const elevations = new Float32Array(columns * rows * 65536).fill(-1e9);
-  let low = Infinity, high = -Infinity;
-  for (const [key, values] of tiles) {
-    const [x, y] = key.split('/').map(Number);
-    const start = (y - bounds.min.y) * 256 * columns * 256 + (x - bounds.min.x) * 256;
-    for (let row = 0; row < 256; row++) {
-      for (let column = 0; column < 256; column++) {
-        const value = values[row * 256 + column];
-        if (!Number.isFinite(value) || value <= -1000) continue;
-        elevations[start + row * columns * 256 + column] = value;
-        low = Math.min(low, value);
-        high = Math.max(high, value);
-      }
-    }
-  }
-  return { elevations, low, high };
-}

package/src/utils/traffic.js

@@ -1,90 +0,0 @@
-// Pure helpers of the 'traffic' type: lane interpolation and vehicle scheduling.
-
-/** Default urban speed (m/s) used to turn a lane's hourly `flow` into vehicles on the road. */
-export const speed = 8;
-
-/** 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);
-  return Array.from({ length: count }, (_, i) => (i + 0.5) * length / count);
-}
-
-/** Point and unit direction at distance `s` along `points` ([x, z, y?]) with cumulative `lengths`. */
-export function along(points, lengths, s) {
-  let i = 1;
-  while (i < lengths.length - 1 && lengths[i] < s) i++;
-  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 };
-}
-
-/**
- * Trips of a frequency-based timetable (like GTFS frequencies.txt) underway at `date`, in the timetable's local time.
- * @param {{timeZone: string, duration: number, services: Array<{from: string, to: string, every?: number, months?: number[], weekdays?: number[]}>}} timetable
- * `duration` and `every` are minutes; `from`/`to` are 'HH:MM' first/last departures; months are 1-12, weekdays 0 (Sunday)-6.
- * @returns {Array<{id: string, departure: string, progress: number}>} `progress` is 0-1 along the lane.
- */
-export function scheduledTrips(date, { timeZone, duration, services }) {
-  const time = new Date(date);
-  if (!Number.isFinite(time.getTime())) throw new Error('Invalid date');
-  const clock = new Intl.DateTimeFormat('en-GB', {
-    timeZone, year: 'numeric', month: '2-digit', day: '2-digit',
-    hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
-  });
-  const parts = Object.fromEntries(clock.formatToParts(time).filter(p => p.type !== 'literal').map(p => [p.type, Number(p.value)]));
-  const minute = parts.hour * 60 + parts.minute + (parts.second + time.getUTCMilliseconds() / 1000) / 60;
-  const weekday = new Date(Date.UTC(parts.year, parts.month - 1, parts.day)).getUTCDay();
-  const minutes = clockTime => clockTime.split(':').reduce((hours, value) => hours * 60 + Number(value));
-  const departures = [];
-  for (const { from, to, every = Infinity, months, weekdays } of services) {
-    if (months?.includes(parts.month) === false || weekdays?.includes(weekday) === false) continue;
-    for (let departure = minutes(from); departure <= minutes(to); departure += every) departures.push(departure);
-  }
-  return departures.sort((a, b) => a - b).filter(departure => minute >= departure && minute < departure + duration).map(departure => ({
-    id: `${parts.year}-${parts.month}-${parts.day}-${departure}`,
-    departure: `${String(Math.floor(departure / 60)).padStart(2, '0')}:${String(departure % 60).padStart(2, '0')}`,
-    progress: (minute - departure) / duration,
-  }));
-}
-
-// GeoJSON (Multi)LineStrings become lanes ({latlngs, properties, elevation?}); prepare() adds `points` ([x, z, ground]),
-// `lengths` and `length` in layer-local metres.
-export const toLanes = ({ features = [] }) => features.flatMap(({ geometry, properties }) => {
-  const lines = geometry?.type === 'LineString' ? [geometry.coordinates] : geometry?.type === 'MultiLineString' ? geometry.coordinates : [];
-  return lines.map(line => ({ latlngs: line.map(([lng, lat]) => [lat, lng]), properties: properties ?? {}, elevation: properties?.elevation }));
-});
-
-// A lane with a `timetable` runs scheduled trips end to end; one with a `flow` (vehicles/h) loops evenly spaced vehicles.
-export const tripsAt = (time, lanes, velocity) => lanes.flatMap((lane, l) => {
-  const { timetable, flow = 0 } = lane.properties;
-  if (!lane.length) return [];
-  if (timetable) return scheduledTrips(time, timetable).map(trip => ({
-    id: `${l}-${trip.id}`, lane, distance: trip.progress * lane.length, speed: lane.length / (timetable.duration * 60),
-    properties: { ...lane.properties, departure: trip.departure },
-  }));
-  const travelled = time / 1000 * velocity;
-  return (lane.offsets ||= vehicleOffsets(lane.length, flow, velocity))
-    .map((offset, k) => ({ id: `${l}-${k}`, lane, distance: (offset + travelled) % lane.length, speed: velocity, properties: lane.properties }));
-});
-
-/** Dashed lane outline, in layer-local metres. */
-export function routeGeometry(lanes) {
-  const position = [], normal = [], color = [];
-  for (const { points, lengths } of lanes) for (let i = 1; i < points.length; i++) {
-    const a = points[i - 1], b = points[i];
-    const dx = b[0] - a[0], dz = b[1] - a[1], length = lengths[i] - lengths[i - 1];
-    if (!length) continue;
-    const x = -dz / length * 2.5, z = dx / length * 2.5;
-    for (let distance = Math.floor(lengths[i - 1] / 30) * 30; distance < lengths[i]; distance += 30) {
-      const start = Math.max(0, (distance - lengths[i - 1]) / length);
-      const end = Math.min(1, (distance + 18 - lengths[i - 1]) / length);
-      if (end <= start) continue;
-      const p = [a[0] + dx * start, a[1] + dz * start], q = [a[0] + dx * end, a[1] + dz * end], y = a[2] + 0.4;
-      for (const point of [[p[0] - x, p[1] - z], [p[0] + x, p[1] + z], [q[0] + x, q[1] + z],
-        [p[0] - x, p[1] - z], [q[0] + x, q[1] + z], [q[0] - x, q[1] - z]]) {
-        position.push(point[0], y, point[1]); normal.push(0, 1, 0); color.push(0.08, 0.7, 0.85);
-      }
-    }
-  }
-  return { position, normal, color };
-}

package/src/utils/vehicles.js

@@ -1,69 +0,0 @@
-// Built-in vehicles for the 'traffic' type. Models are [ring of [x, z], bottom, top, rgb, topRing?] convex prisms in metres;
-// forward is -z, right is +x. `topRing` (same length as `ring`) tapers the prism; rgb components above 1 are self-lit lamps.
-const paints = [[0.86, 0.86, 0.88], [0.1, 0.1, 0.12], [0.5, 0.53, 0.57], [0.65, 0.1, 0.08], [0.12, 0.25, 0.55], [0.85, 0.7, 0.15]];
-export const box = (x0, x1, z0, z1) => [[x0, z0], [x1, z0], [x1, z1], [x0, z1]];
-const mirror = (x0, x1, z0, z1, ...rest) => [[box(x0, x1, z0, z1), ...rest], [box(-x1, -x0, z0, z1), ...rest]];
-const glass = [0.12, 0.15, 0.18], tyre = [0.05, 0.05, 0.05];
-const headlight = [1.9, 1.85, 1.7], taillight = [1.7, 0.06, 0.05];
-const car = 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],
-  ];
-};
-// Panoramic river cruiser, about 60 × 11 m: glass saloon, open upper deck with benches, wheelhouse forward.
-const white = [0.92, 0.93, 0.92], hull = [[-5.5, 30], [5.5, 30], [5.5, -20], [4, -26], [1.5, -30], [-1.5, -30], [-4, -26], [-5.5, -20]];
-const boat = () => [
-  [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],
-  ...Array.from({ length: 12 }, (_, i) => mirror(0.5, 3.8, -12 + i * 3, -11.3 + i * 3, 3.9, 4.4, [0.62, 0.1, 0.1])).flat(),
-  ...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]],
-];
-
-export const build = parts => {
-  const position = [], normal = [], color = [];
-  const triangle = (a, b, c, tint) => {
-    const u = b.map((v, i) => v - a[i]), v = c.map((w, i) => w - a[i]);
-    const n = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]], length = Math.hypot(...n);
-    for (const point of [a, b, c]) { position.push(...point); normal.push(...n.map(w => w / length)); color.push(...tint); }
-  };
-  for (const [ring, bottom, top, tint, topRing = ring] of parts) {
-    const low = ring.map(([x, z]) => [x, bottom, z]), high = topRing.map(([x, z]) => [x, top, z]);
-    for (let i = 0; i < ring.length; i++) {
-      const j = (i + 1) % ring.length;
-      triangle(low[i], low[j], high[j], tint); triangle(low[i], high[j], high[i], tint);
-    }
-    for (let i = 1; i < ring.length - 1; i++) {
-      triangle(high[0], high[i], high[i + 1], tint); triangle(low[0], low[i + 1], low[i], tint);
-    }
-  }
-  return { position, normal, color };
-};
-
-/**
- * `side`: default offset (metres) to the right of the lane centreline. `model(i)` gives the prisms of the i-th vehicle.
- * `lights`: night point lights in model space (see the night lighting grid), e.g. the pool cast by the headlights.
- */
-export const vehicles = {
-  car: { side: 1.8, model: car, lights: [{ position: [0, 1.2, -6], radius: 10, color: [1, 0.94, 0.82], flux: 800 }] },
-  boat: { side: 0, model: boat, lights: [{ position: [0, 8, 4], radius: 30, color: [1, 0.8, 0.55], flux: 20000 }] },
-};

package/src/utils/walk.js

@@ -1,72 +0,0 @@
-import { box } from './vehicles.js';
-
-// Pedestrian, about 1.77 m tall, prisms as in utils/vehicles.js (forward -z). Limbs hang from their pivot at y = 0.
-const skin = [0.85, 0.64, 0.5], shirt = [0.75, 0.2, 0.15], trousers = [0.16, 0.2, 0.32], dark = [0.08, 0.07, 0.06];
-export const parts = {
-  body: [
-    [box(-0.17, 0.17, -0.1, 0.1), 0.82, 0.95, trousers],
-    [box(-0.19, 0.19, -0.11, 0.11), 0.95, 1.44, shirt],
-    [box(-0.05, 0.05, -0.05, 0.05), 1.44, 1.5, skin],
-    [box(-0.1, 0.1, -0.11, 0.1), 1.5, 1.72, skin],
-    [box(-0.105, 0.105, -0.06, 0.115), 1.58, 1.77, dark],
-    [box(-0.105, 0.105, -0.115, -0.06), 1.7, 1.77, dark],
-  ],
-  leg: [[box(-0.07, 0.07, -0.07, 0.07), -0.82, 0, trousers], [box(-0.07, 0.07, -0.17, 0.07), -0.9, -0.82, dark]],
-  arm: [[box(-0.05, 0.05, -0.05, 0.05), -0.55, 0, shirt], [box(-0.045, 0.045, -0.045, 0.045), -0.66, -0.55, skin]],
-};
-// [part, pivot x, pivot y, swing sign]
-export const limbs = [['body', 0, 0, 0], ['leg', -0.09, 0.9, 1], ['leg', 0.09, 0.9, -1], ['arm', -0.25, 1.42, -1], ['arm', 0.25, 1.42, 1]];
-// Walls (non-horizontal triangles) of a mesh in world space, bucketed by 8 m cells; `origin` is the world translation
-// at build time, since layer roots only move vertically with the terrain afterwards.
-export const CELL = 8;
-const colliders = new WeakMap();
-export function collider(mesh) {
-  let c = colliders.get(mesh.geometry);
-  if (c) return c;
-  const m = mesh.worldMatrix, { position: { data: p }, index, normal, uv } = mesh.geometry.attributes;
-  const count = index ? index.count : p.length / 3, tri = [], nrm = [], cells = new Map(), v = [];
-  for (let i = 0; i < count; i += 3) {
-    const first = index ? index.data[i] : i;
-    // Streetlight halos (uv.x <= 2, see scene/picking.js) are light, not matter.
-    if (mesh.program.nightLight && uv && uv.data[first * 2] <= 2) continue;
-    for (let k = 0; k < 3; k++) {
-      const j = (index ? index.data[i + k] : i + k) * 3, x = p[j], y = p[j + 1], z = p[j + 2];
-      v[k * 3] = m[0] * x + m[4] * y + m[8] * z + m[12];
-      v[k * 3 + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
-      v[k * 3 + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
-    }
-    const ex = v[3] - v[0], ey = v[4] - v[1], ez = v[5] - v[2], fx = v[6] - v[0], fy = v[7] - v[1], fz = v[8] - v[2];
-    let nx = ey * fz - ez * fy, nz = ex * fy - ey * fx;
-    const ny = ez * fx - ex * fz, length = Math.hypot(nx, ny, nz);
-    if (!length || Math.abs(ny) > 0.9 * length) continue;
-    if (normal) {
-      // The stored normal tells the outside, whatever the winding.
-      const j = first * 3, a = normal.data;
-      if ((m[0] * a[j] + m[4] * a[j + 1] + m[8] * a[j + 2]) * nx + (m[2] * a[j] + m[6] * a[j + 1] + m[10] * a[j + 2]) * nz < 0) { nx = -nx; nz = -nz; }
-    }
-    const h = Math.hypot(nx, nz), t = nrm.length / 2;
-    tri.push(...v); nrm.push(nx / h, nz / h);
-    for (let ix = Math.floor(Math.min(v[0], v[3], v[6]) / CELL); ix <= Math.floor(Math.max(v[0], v[3], v[6]) / CELL); ix++)
-      for (let iz = Math.floor(Math.min(v[2], v[5], v[8]) / CELL); iz <= Math.floor(Math.max(v[2], v[5], v[8]) / CELL); iz++) {
-        const key = ix + ',' + iz;
-        if (!cells.has(key)) cells.set(key, []);
-        cells.get(key).push(t);
-      }
-  }
-  c = { tri: Float32Array.from(tri), nrm: Float32Array.from(nrm), cells, origin: [m[12], m[13], m[14]] };
-  colliders.set(mesh.geometry, c);
-  return c;
-}
-
-// Möller-Trumbore for the horizontal ray (ox, oy, oz) + d·(dx, 0, dz) against triangle t; returns d or -1.
-export function horizontalRay(v, t, ox, oy, oz, dx, dz) {
-  const i = t * 9, ex = v[i + 3] - v[i], ey = v[i + 4] - v[i + 1], ez = v[i + 5] - v[i + 2];
-  const fx = v[i + 6] - v[i], fy = v[i + 7] - v[i + 1], fz = v[i + 8] - v[i + 2];
-  const px = -dz * fy, py = dz * fx - dx * fz, pz = dx * fy, det = ex * px + ey * py + ez * pz;
-  if (Math.abs(det) < 1e-9) return -1;
-  const tx = ox - v[i], ty = oy - v[i + 1], tz = oz - v[i + 2], u = (tx * px + ty * py + tz * pz) / det;
-  if (u < 0 || u > 1) return -1;
-  const qx = ty * ez - tz * ey, qy = tz * ex - tx * ez, qz = tx * ey - ty * ex, w = (dx * qx + dz * qz) / det;
-  if (w < 0 || u + w > 1) return -1;
-  return (fx * qx + fy * qy + fz * qz) / det;
-}