leaflet-city-mapper 0.0.2 → 0.0.4

package/src/sunlight/useSelectedTime.js

@@ -0,0 +1,23 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+import { render } from './render.js';
+import { updateSky } from './updateSky.js';
+import { updateSun } from './updateSun.js';
+
+export function useSelectedTime(state) {
+  const { control, map, date, slider, status } = state;
+  control.live = false;
+  if (!date.value || !date.validity.valid) {
+    control.time = /* alloc */ new Date(NaN);
+    map.fire('simulationtimechange', /* alloc */ { time: null, live: false });
+    delete cameraByMap.get(map)._sunlight;
+    updateSky(state);
+    render(map);
+    status.textContent = 'Error: choose a valid solar date';
+    return;
+  }
+  control.time = /* alloc */ new Date(`${date.value}T00:00:00Z`);
+  control.time.setUTCMinutes(Number(slider.value));
+  updateSun(state);
+}

package/src/terrain/applyTerrain.js

@@ -0,0 +1,21 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { addBridges } from '../geometry/addBridges.js';
+import { conformModelToTerrain } from '../geometry/conformModelToTerrain.js';
+import { getElevation } from './getElevation.js';
+import { setTerrainHeight } from './setTerrainHeight.js';
+import { update } from '../scene/update.js';
+
+export function applyTerrain(backend, map, bridges) {
+  const scene = sceneByLayer.get(backend);
+  scene._terrainReady = true;
+  scene._terrainOriginElevation = getElevation(backend, scene.location) ?? 0;
+  let layer;
+  for (layer of Object.values(map._layers)) {
+    setTerrainHeight(layer);
+    conformModelToTerrain(layer, backend);
+  }
+  if (bridges) addBridges(backend, bridges);
+  map.fire('terrainchange');
+  update(backend);
+  backend.fire('terrainready');
+}

package/src/terrain/clearLayerTerrain.js

@@ -0,0 +1,8 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { setRasterTerrain } from '../raster/setRasterTerrain.js';
+
+export function clearLayerTerrain(layer) {
+  if (sceneByLayer.get(layer).kind === 'raster') setRasterTerrain(layer, null);
+}

package/src/terrain/copyTerrainTile.js

@@ -0,0 +1,12 @@
+export function copyTerrainTile(atlas, values, start, columns) {
+  let row, column, value;
+  for (row = 0; row < 256; row++) {
+    for (column = 0; column < 256; column++) {
+      value = values[row * 256 + column];
+      if (!Number.isFinite(value) || value <= -1000) continue;
+      atlas.elevations[start + row * columns * 256 + column] = value;
+      atlas.low = Math.min(atlas.low, value);
+      atlas.high = Math.max(atlas.high, value);
+    }
+  }
+}

package/src/terrain/getElevation.js

@@ -0,0 +1,14 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { bridgeElevation } from '../geometry/bridgeElevation.js';
+import { terrainElevation } from './terrainElevation.js';
+
+/** @param {L.LatLng|L.Point} location LatLng, or a pixel point at the terrain zoom. */
+
+export function getElevation(backend, location) {
+  if (!backend._map || !sceneByLayer.get(backend)._terrainReady) return null;
+  const point = location instanceof L.Point ? location : backend._map.project(location, sceneByLayer.get(backend)._terrainZoom);
+  return bridgeElevation(point, sceneByLayer.get(backend)._bridges) ?? terrainElevation(point, sceneByLayer.get(backend)._terrainTiles);
+}

package/src/terrain/initTerrain.js

@@ -0,0 +1,23 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { onTerrainRemove } from './onTerrainRemove.js';
+import { onTerrainAdd } from './onTerrainAdd.js';
+import { init3D } from '../scene/init3D.js';
+
+/**
+ * Renders Float32 DEM tiles and archived raster basemaps in the shared WebGPU scene.
+ * Source options: `url` (single-zoom Float32 PMTiles or supported COG DEM);
+ * `bridges` (optional GeoJSON deck polygons with Z, see _addBridges).
+ */
+export function initTerrain(layer, options) {
+  const terrainSource = options.url;
+  const layerOptions = /* alloc */ { ...options };
+  delete layerOptions.url;
+  init3D(layer, layerOptions);
+  sceneByLayer.get(layer).terrainSource = terrainSource;
+  sceneByLayer.get(layer)._terrainTiles = /* alloc */ new Map();
+  sceneByLayer.get(layer)._rasterTiles = /* alloc */ new Map();
+  sceneByLayer.get(layer)._terrainReady = false;
+  sceneByLayer.get(layer).kind = 'terrain';
+}

package/src/terrain/loadReadyTerrain.js

@@ -0,0 +1,5 @@
+import { loadTerrain } from './loadTerrain.js';
+
+export function loadReadyTerrain() {
+  loadTerrain(this.backend).then(this.resolve, this.reject);
+}

package/src/terrain/loadTerrain.js

@@ -0,0 +1,43 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { createLayer } from '../scene/createLayer.js';
+
+import { loadTerrainTiles } from './loadTerrainTiles.js';
+import { readBridges } from './readBridges.js';
+import { terrainTileQueue } from './terrainTileQueue.js';
+import { applyTerrain } from './applyTerrain.js';
+
+export async function loadTerrain(backend) {
+  if (sceneByLayer.get(backend)._terrainLoading || !backend._map) return;
+  sceneByLayer.get(backend)._terrainLoading = true;
+  sceneByLayer.get(backend)._terrainReady = false;
+  const controller = sceneByLayer.get(backend)._terrainController = /* alloc */ new AbortController();
+  let i;
+  try {
+    if (!sceneByLayer.get(backend).terrainSource) throw /* alloc */ new Error('Terrain layer requires a PMTiles or COG elevation archive');
+    const archive = sceneByLayer.get(backend)._terrainArchive = createLayer(/* alloc */ { source: /* alloc */ {
+      type: backend.options.asset !== undefined || /\.tiff?(?:[?#]|$)/i.test(sceneByLayer.get(backend).terrainSource) ? 'cog' : 'pmtiles',
+      url: sceneByLayer.get(backend).terrainSource, archive: backend.options.archive, asset: backend.options.asset,
+    } });
+    await sceneByLayer.get(archive).ready;
+    const header = sceneByLayer.get(archive).header;
+    if (header.tileType !== 0 || header.minZoom !== header.maxZoom) {
+      throw /* alloc */ new Error('Expected a single-zoom Float32 terrain archive');
+    }
+    const map = backend._map;
+    const tiles = terrainTileQueue(backend, header);
+    const state = /* alloc */ { backend, archive, controller, tiles, next: 0 };
+    const workers = /* alloc */ [];
+    for (i = 0; i < Math.min(4, tiles.length); i++) workers.push(loadTerrainTiles(state));
+    await Promise.all(workers);
+    const bridges = backend.options.bridges && await fetch(backend.options.bridges, /* alloc */ { signal: controller.signal })
+      .then(readBridges);
+    if (controller.signal.aborted || backend._map !== map) return;
+    applyTerrain(backend, map, bridges);
+    return true;
+  } catch (error) {
+    if (!controller.signal.aborted) backend.fire('error', /* alloc */ { error });
+    return false;
+  } finally {
+    sceneByLayer.get(backend)._terrainLoading = false;
+  }
+}

package/src/terrain/loadTerrainTiles.js

@@ -0,0 +1,17 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+export async function loadTerrainTiles(state) {
+  const { backend, archive, controller, tiles } = state;
+  let coords, result;
+  while (state.next < tiles.length) {
+    controller.signal.throwIfAborted();
+    coords = tiles[state.next++];
+    result = await getZxy(archive, coords.z, coords.x, coords.y, controller.signal);
+    if (!result || result.data.byteLength !== 256 * 256 * 4) {
+      throw /* alloc */ new Error(`Missing or invalid Float32 terrain tile ${coords.z}/${coords.x}/${coords.y}`);
+    }
+    sceneByLayer.get(backend)._terrainTiles.set(`${coords.x}/${coords.y}`, /* alloc */ new Float32Array(result.data));
+  }
+}
+import { getZxy } from '../archives/getZxy.js';

package/src/terrain/onTerrainAdd.js

@@ -0,0 +1,25 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { loadTerrain } from "./loadTerrain.js";
+import { setRasterTerrain } from '../raster/setRasterTerrain.js';
+import { onAdd3DLayer } from '../scene/onAdd3DLayer.js';
+import { loadReadyTerrain } from './loadReadyTerrain.js';
+import { setLayerTerrain } from './setLayerTerrain.js';
+
+export function onTerrainAdd(backend, map) {
+  if (cameraByMap.get(map)._terrain3D && cameraByMap.get(map)._terrain3D !== backend) {
+    throw /* alloc */ new Error('Only one terrain layer can be active per map');
+  }
+  cameraByMap.get(map)._terrain3D = backend;
+  onAdd3DLayer(backend, map);
+  if (sceneByLayer.get(backend).root) sceneByLayer.get(backend)._terrainPromise = loadTerrain(backend);
+  else {
+    const pending = Promise.withResolvers();
+    sceneByLayer.get(backend)._terrainPromise = pending.promise;
+    backend.once('ready', loadReadyTerrain, /* alloc */ { backend, ...pending });
+  }
+  map.eachLayer(setLayerTerrain, backend);
+  map.fire('terrainchange');
+}

package/src/terrain/onTerrainChange.js

@@ -0,0 +1,17 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { releaseArea } from '../sources/releaseArea.js';
+import { updateArea } from "../sources/updateArea.js";
+
+/** GeoJSON source areas: loading, building and releasing. */
+
+export function onTerrainChange(layer) {
+  if (!layer._map) return;
+  let area;
+  for (area of sceneByLayer.get(layer)._areas.values()) {
+    releaseArea(layer, area);
+  }
+  sceneByLayer.get(layer)._areas.clear();
+  updateArea(layer);
+}

package/src/terrain/onTerrainRemove.js

@@ -0,0 +1,45 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { renderEmpty } from '../globals/renderEmpty.js';
+
+import { destroyTexture } from '../rendering/destroyTexture.js';
+import { conformModelToTerrain } from '../geometry/conformModelToTerrain.js';
+import { disposeMesh } from '../rendering/disposeMesh.js';
+import { setRasterTerrain } from '../raster/setRasterTerrain.js';
+import { removeRasterTile } from '../raster/removeRasterTile.js';
+import { setTerrainHeight } from './setTerrainHeight.js';
+import { onRemove3DLayer } from '../scene/onRemove3DLayer.js';
+import { clearLayerTerrain } from './clearLayerTerrain.js';
+
+export function onTerrainRemove(layer, map) {
+  sceneByLayer.get(layer)._terrainController?.abort();
+  sceneByLayer.get(layer)._terrainLoading = false;
+  sceneByLayer.get(layer)._terrainReady = false;
+  map.eachLayer(clearLayerTerrain);
+  let tile, l, grid, attribute;
+  for (tile of sceneByLayer.get(layer)._rasterTiles.keys()) removeRasterTile(layer, tile);
+  if (cameraByMap.get(map)._terrain3D === layer) delete cameraByMap.get(map)._terrain3D;
+  for (l of Object.values(map._layers)) {
+    conformModelToTerrain(l, null);
+    setTerrainHeight(l);
+  }
+
+  map.fire('terrainchange');
+  sceneByLayer.get(layer)._terrainTiles.clear();
+  sceneByLayer.get(layer)._terrainOriginElevation = 0;
+  sceneByLayer.get(layer)._terrainPromise = null;
+  if (sceneByLayer.get(layer)._rasterProgram) {
+    sceneByLayer.get(layer)._rasterProgram.pipelineCache.clear();
+  }
+  sceneByLayer.get(layer)._rasterProgram = null;
+  if (sceneByLayer.get(layer)._dem) destroyTexture(layer, sceneByLayer.get(layer)._dem.texture);
+  sceneByLayer.get(layer)._dem = null;
+  for (grid of sceneByLayer.get(layer)._terrainGrids?.values() || renderEmpty) {
+    for (attribute of Object.values(grid)) destroyTexture(layer, attribute.buffer);
+  }
+  sceneByLayer.get(layer)._terrainGrids = null;
+  sceneByLayer.get(layer)._bridges = null;
+  disposeMesh(layer, sceneByLayer.get(layer)._bridgeMesh);
+  sceneByLayer.get(layer)._bridgeMesh = null;
+  onRemove3DLayer(layer, map);
+}

package/src/terrain/rasterProgram.js

@@ -0,0 +1,51 @@
+import { demTexture } from '../globals/demTexture.js';
+import { demTarget } from '../globals/demTarget.js';
+import { demLayout } from '../globals/demLayout.js';
+import { demSize } from '../globals/demSize.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { createProgram } from '../rendering/createProgram.js';
+import { destroyTexture } from '../rendering/destroyTexture.js';
+import { terrainAtlas } from './terrainAtlas.js';
+
+export function rasterProgram(backend, texture) {
+  const state = sceneByLayer.get(backend), device = state.renderer.device;
+  if (state._rasterProgram?.device === device) return state._rasterProgram;
+  // DEM atlas over the archive's tile grid; invalid or missing samples become -1e9 (the shader's no-data).
+  // ponytail: one texture, capped by maxTextureDimension2D (32x32 DEM tiles at 8192 px); split it for larger archives.
+  const bounds = state._terrainBounds, columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
+  const { elevations, low, high } = terrainAtlas(state._terrainTiles, bounds);
+  if (state._dem) destroyTexture(backend, state._dem.texture);
+  state._dem = /* alloc */ {
+    texture: device.createTexture((
+      demTexture.size[0] = columns * 256,
+      demTexture.size[1] = rows * 256,
+      demTexture.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+      demTexture
+    )),
+    low: Number.isFinite(low) ? low : state._terrainOriginElevation,
+    high: Number.isFinite(high) ? high : state._terrainOriginElevation,
+  };
+  device.queue.writeTexture((
+    demTarget.texture = state._dem.texture,
+    demTarget
+  ), elevations,
+    (
+      demLayout.bytesPerRow = columns * 1024,
+      demLayout
+    ), (
+      demSize[0] = columns * 256,
+      demSize[1] = rows * 256,
+      demSize
+    ));
+  demTarget.texture = null;
+  state._terrainGrids = /* alloc */ new Map();
+  state._rasterProgram = createProgram(backend, /* alloc */ {
+    baseTexture: texture,
+    unlit: true,
+    terrain: state._dem,
+    alphaMode: 'BLEND',
+    depthWrite: true,
+    doubleSided: backend.options.doubleSided,
+  });
+  return state._rasterProgram;
+}

package/src/terrain/readBridges.js

@@ -0,0 +1,4 @@
+export function readBridges(response) {
+  if (!response.ok) throw /* alloc */ new Error(`Bridges: HTTP ${response.status}`);
+  return response.json();
+}

package/src/terrain/sample.js

@@ -0,0 +1,7 @@
+export function sample(tiles, 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;
+}

package/src/terrain/setLayerTerrain.js

@@ -0,0 +1,8 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { setRasterTerrain } from '../raster/setRasterTerrain.js';
+
+export function setLayerTerrain(layer) {
+  if (sceneByLayer.get(layer).kind === 'raster') setRasterTerrain(layer, this);
+}

package/src/terrain/setTerrainHeight.js

@@ -0,0 +1,14 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+import { getElevation } from './getElevation.js';
+
+export function setTerrainHeight(layer) {
+  if (!sceneByLayer.get(layer).root || !sceneByLayer.get(layer).location) return;
+  sceneByLayer.get(layer)._terrainBaseY ??= sceneByLayer.get(layer).root.position[1];
+  const terrain = cameraByMap.get(layer._map)?._terrain3D;
+  const elevation = terrain && getElevation(terrain, sceneByLayer.get(layer).location);
+  const offset = Number.isFinite(elevation) ? layer.options.terrainOffset ?? 0 : 0;
+  sceneByLayer.get(layer).root.position[1] = sceneByLayer.get(layer)._terrainBaseY + (elevation ?? 0) + offset;
+}

package/src/terrain/terrainAtlas.js

@@ -0,0 +1,17 @@
+import { copyTerrainTile } from './copyTerrainTile.js';
+
+/** 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 = /* alloc */ new Float32Array(columns * rows * 65536).fill(-1e9);
+  const atlas = /* alloc */ { elevations, low: Infinity, high: -Infinity };
+  let key, values, coordinates, x, y, start;
+  for ([key, values] of tiles) {
+    coordinates = key.split('/');
+    x = Number(coordinates[0]), y = Number(coordinates[1]);
+    start = (y - bounds.min.y) * 256 * columns * 256 + (x - bounds.min.x) * 256;
+    copyTerrainTile(atlas, values, start, columns);
+  }
+  return atlas;
+}

package/src/terrain/terrainBuffers.js

@@ -0,0 +1,27 @@
+import { demBuffer } from '../globals/demBuffer.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { terrainGrid } from './terrainGrid.js';
+
+export function terrainBuffers(backend, divisions) {
+  const state = sceneByLayer.get(backend), device = state.renderer.device;
+  let attributes = state._terrainGrids.get(divisions);
+  if (!attributes) {
+    attributes = terrainGrid(divisions);
+    let name, attribute;
+    for ([name, attribute] of Object.entries(attributes)) {
+      attribute.size ||= 1;
+      attribute.count = attribute.data.length / attribute.size;
+      attribute.indexFormat = 'uint16';
+      attribute.buffer = device.createBuffer((
+        demBuffer.size = Math.max(4, attribute.data.byteLength),
+        demBuffer.usage = name === 'index'
+          ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+          : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        demBuffer
+      ));
+      device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+    }
+    state._terrainGrids.set(divisions, attributes);
+  }
+  return attributes;
+}

package/src/terrain/terrainElevation.js

@@ -0,0 +1,15 @@
+import { sample } from './sample.js';
+
+/** 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 a = sample(tiles, x0, y0), b = sample(tiles, x0 + 1, y0);
+  const c = sample(tiles, x0, y0 + 1), d = sample(tiles, x0 + 1, y0 + 1);
+  if (!Number.isFinite(a) || !Number.isFinite(b) || !Number.isFinite(c) || !Number.isFinite(d)) {
+    return Number.isFinite(a) ? a : Number.isFinite(b) ? b : Number.isFinite(c) ? c : Number.isFinite(d) ? d : null;
+  }
+  return (a * (1 - fx) + b * fx) * (1 - fy) + (c * (1 - fx) + d * fx) * fy;
+}

package/src/terrain/terrainGrid.js

@@ -0,0 +1,32 @@
+/** Unit tile grid; the vertex shader supplies the elevation. */
+
+export function terrainGrid(divisions) {
+  const vertices = (divisions + 1) ** 2;
+  const positions = /* alloc */ new Float32Array(vertices * 3);
+  const normals = /* alloc */ new Float32Array(vertices * 3);
+  const uvs = /* alloc */ new Float32Array(vertices * 2);
+  const indices = /* alloc */ new Uint16Array(divisions * divisions * 6);
+  let row, column, a, b, c, d, vertex = 0, index = 0;
+  for (row = 0; row <= divisions; row++) {
+    for (column = 0; column <= divisions; column++) {
+      positions[vertex * 3] = column / divisions;
+      positions[vertex * 3 + 2] = row / divisions;
+      normals[vertex * 3 + 1] = 1;
+      uvs[vertex * 2] = column / divisions;
+      uvs[vertex * 2 + 1] = row / divisions;
+      vertex++;
+      if (row < divisions && column < divisions) {
+        a = row * (divisions + 1) + column;
+        b = a + 1, c = a + divisions + 1, d = c + 1;
+        indices[index++] = a; indices[index++] = c; indices[index++] = b;
+        indices[index++] = b; indices[index++] = c; indices[index++] = d;
+      }
+    }
+  }
+  return /* alloc */ {
+    position: /* alloc */ { size: 3, data: positions },
+    normal: /* alloc */ { size: 3, data: normals },
+    uv: /* alloc */ { size: 2, data: uvs },
+    index: /* alloc */ { data: indices },
+  };
+}

package/src/terrain/terrainTileQueue.js

@@ -0,0 +1,25 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { archiveNorthWest } from '../globals/archiveNorthWest.js';
+import { archiveSouthEast } from '../globals/archiveSouthEast.js';
+import { compareDistance } from '../utils/compareDistance.js';
+
+export function terrainTileQueue(backend, header) {
+  const scene = sceneByLayer.get(backend), map = backend._map;
+  scene._terrainZoom = header.maxZoom;
+  archiveNorthWest[0] = header.maxLat; archiveNorthWest[1] = header.minLon;
+  const northwest = map.project(archiveNorthWest, scene._terrainZoom).divideBy(256).floor();
+  archiveSouthEast[0] = header.minLat; archiveSouthEast[1] = header.maxLon;
+  const southeast = map.project(archiveSouthEast, scene._terrainZoom).divideBy(256).floor();
+  scene._terrainBounds = /* alloc */ new L.Bounds(northwest, southeast);
+  const tiles = /* alloc */ [];
+  const center = map.project(map.getCenter(), scene._terrainZoom).divideBy(256);
+  let x, y;
+  for (x = northwest.x; x <= southeast.x; x++) {
+    for (y = northwest.y; y <= southeast.y; y++) {
+      tiles.push(/* alloc */ { z: scene._terrainZoom, x, y, distance: Math.hypot(x + 0.5 - center.x, y + 0.5 - center.y) });
+    }
+  }
+  tiles.sort(compareDistance);
+  return tiles;
+}

package/src/traffic/addTraffic.js

@@ -0,0 +1,10 @@
+import { trafficByLayer } from '../globals/trafficByLayer.js';
+
+
+import { placeTraffic } from './placeTraffic.js';
+import { startTraffic } from './startTraffic.js';
+
+export function addTraffic(state) {
+  trafficByLayer.set(state.layer, state);
+  if (state.ready) startTraffic(state);
+}

package/src/traffic/along.js

@@ -0,0 +1,20 @@
+/** Point and unit direction at distance `s` along `points` ([x, z, y?]) with cumulative `lengths`. */
+
+export function along(points, lengths, s, target) {
+  let i = 1, end = lengths.length - 1;
+  let middle;
+  while (i < end) {
+    middle = i + Math.floor((end - i) / 2);
+    if (lengths[middle] < s) i = middle + 1;
+    else end = middle;
+  }
+  const a = points[i - 1], b = points[i], d = lengths[i] - lengths[i - 1] || 1;
+  const t = (s - lengths[i - 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;
+}

package/src/traffic/appendRouteDash.js

@@ -0,0 +1,15 @@
+export function appendRouteDash(position, normal, color, a, b, dx, dz, x, z, start, end, r, g, blue) {
+  const px = a[0] + dx * start, pz = a[1] + dz * start;
+  const py = a[2] + (b[2] - a[2]) * start + 0.4;
+  const qx = a[0] + dx * end, qz = a[1] + dz * end;
+  const qy = a[2] + (b[2] - a[2]) * end + 0.4;
+  let vertex;
+  for (vertex = 0; vertex < 6; vertex++) {
+    if (vertex === 0 || vertex === 3) position.push(px - x, py, pz - z);
+    else if (vertex === 1) position.push(px + x, py, pz + z);
+    else if (vertex === 5) position.push(qx - x, qy, qz - z);
+    else position.push(qx + x, qy, qz + z);
+    normal.push(0, 1, 0);
+    color.push(r, g, blue);
+  }
+}

package/src/traffic/appendRouteSegment.js

@@ -0,0 +1,15 @@
+import { appendRouteDash } from './appendRouteDash.js';
+
+export function appendRouteSegment(position, normal, color, points, lengths, i, r, g, blue) {
+  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) return;
+  const x = -dz / length * 2.5, z = dx / length * 2.5;
+  let distance, start, end;
+  for (distance = Math.floor(lengths[i - 1] / 30) * 30; distance < lengths[i]; distance += 30) {
+    start = Math.max(0, (distance - lengths[i - 1]) / length);
+    end = Math.min(1, (distance + 18 - lengths[i - 1]) / length);
+    if (end <= start) continue;
+    appendRouteDash(position, normal, color, a, b, dx, dz, x, z, start, end, r, g, blue);
+  }
+}

package/src/traffic/clockMinutes.js

@@ -0,0 +1,6 @@
+
+
+export function clockMinutes(clockTime) {
+  const parts = clockTime.split(':');
+  return Number(parts[0]) * 60 + Number(parts[1]);
+}

package/src/traffic/compareDepartures.js

@@ -0,0 +1,5 @@
+
+
+export function compareDepartures(a, b) {
+  return a - b;
+}

package/src/traffic/createTrafficMesh.js

@@ -0,0 +1,7 @@
+import * as createMeshApi from '../rendering/createMesh.js';
+
+export function createTrafficMesh(state, data, featureFaces, material, usage = 0) {
+  const result = createMeshApi.createMesh(state.layer, data, material, usage);
+  result.extras.featureFaces = featureFaces;
+  return result;
+}

package/src/traffic/destroyTrafficGpu.js

@@ -0,0 +1,7 @@
+export function destroyTrafficGpu(state) {
+  state.gpu?.params?.destroy();
+  state.gpu?.template?.destroy();
+  state.gpu?.points?.destroy();
+  state.gpu?.vehicles?.destroy();
+  state.gpu = null;
+}

package/src/traffic/disposeTrafficObject.js

@@ -0,0 +1,16 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import * as disposeMesh from '../rendering/disposeMesh.js';
+import * as setHighlight from '../picking/setHighlight.js';
+import * as showFeature from '../picking/showFeature.js';
+
+export function disposeTrafficObject(state, object) {
+  if (!object) return;
+  if (sceneByLayer.get(state.layer).highlightedFeature?.mesh === object) {
+    setHighlight.setHighlight(state.layer, null);
+    sceneByLayer.get(state.layer).hoveredFeature = null;
+    showFeature.showFeature(state.layer, null);
+  };
+  disposeMesh.disposeMesh(state.layer, object);
+}

package/src/traffic/drawTrafficRoute.js

@@ -0,0 +1,9 @@
+import { trafficRouteMaterial } from '../globals/trafficRouteMaterial.js';
+import { routeGeometry } from './routeGeometry.js';
+import { createTrafficMesh } from './createTrafficMesh.js';
+
+
+export function drawTrafficRoute(state) {
+  state.route = createTrafficMesh(state, routeGeometry(state.lanes),
+    /* alloc */ [], trafficRouteMaterial);
+}

package/src/traffic/failTraffic.js

@@ -0,0 +1,6 @@
+export function failTraffic(state, error) {
+  state.error = error;
+  state.status.textContent = `${state.vehicle}: Error: ${error.message}`;
+  state.status.setAttribute('role', 'alert');
+  console.error('Traffic layer', error);
+}

package/src/traffic/failedTrafficLoad.js

@@ -0,0 +1,5 @@
+import { failTraffic } from './failTraffic.js';
+
+export function failedTrafficLoad(state, signal, error) {
+  if (!signal.aborted && error.name !== 'AbortError') failTraffic(state, error);
+}

package/src/traffic/fetchTrafficLanes.js

@@ -0,0 +1,10 @@
+export async function fetchTrafficLanes(state, time, signal) {
+  const href = /* alloc */ new URL(state.url, document.baseURI).href;
+  if (/\.m?js(?:[?#]|$)/i.test(state.url)) return (await import(href)).default(time, state.layer, signal);
+  if (!state.file) {
+    const response = await fetch(href, /* alloc */ { signal });
+    if (!response.ok) throw /* alloc */ new Error(`HTTP ${response.status}`);
+    state.file = await response.json();
+  }
+  return state.file;
+}