leaflet-city-mapper 0.0.2 → 0.0.3

package/src/camera/mapSetZoomAround.js

@@ -0,0 +1,11 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+
+export function mapSetZoomAround(latlng, zoom, options) {
+  if (!this.getPitch() && !this.getBearing()) return mapCameraState.mapMethods.setZoomAround.call(this, latlng, zoom, options);
+  zoom = this._limitZoom(zoom);
+  const scale = this.getZoomScale(zoom), half = this.getSize().divideBy(2);
+  const screen = latlng instanceof L.Point ? latlng : this.latLngToContainerPoint(latlng);
+  const center = this.containerPointToLayerPoint(half), anchor = this.containerPointToLayerPoint(screen);
+  const next = center.add(anchor.subtract(center).multiplyBy(1 - 1 / scale));
+  return this.setView(this.layerPointToLatLng(next), zoom, { zoom: options });
+}

package/src/camera/mapStopPitchBearingAnimation.js

@@ -0,0 +1,6 @@
+import { cancelCameraAnimation } from './cancelCameraAnimation.js';
+
+export function mapStopPitchBearingAnimation() {
+  cancelCameraAnimation(this);
+  return this;
+}

package/src/camera/mapTryAnimatedPan.js

@@ -0,0 +1,9 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+
+export function mapTryAnimatedPan(center, options) {
+  // Leaflet's geographic recentering already supplies ground pixels, not screen pixels.
+  const offset = this._getCenterOffset(center)._trunc();
+  if (options?.animate !== true && !this.getSize().contains(offset)) return false;
+  mapCameraState.mapMethods.panBy.call(this, offset, options);
+  return true;
+}

package/src/camera/mapUpdateCameraOverlays.js

@@ -0,0 +1,7 @@
+export function mapUpdateCameraOverlays() {
+  let layer;
+  for (layer of Object.values(this._layers)) {
+    if (layer instanceof L.Marker) layer.update();
+    else if (layer instanceof L.Popup || layer instanceof L.Tooltip) layer._updatePosition();
+  }
+}

package/src/camera/pointOf.js

@@ -0,0 +1,3 @@
+export function pointOf(point) {
+  return Array.isArray(point) ? new L.Point(point[0], point[1]) : new L.Point(point.x, point.y);
+}

package/src/camera/project.js

@@ -0,0 +1,20 @@
+import { pointOf } from './pointOf.js';
+import { angles } from './angles.js';
+
+export function project(map, point, inverse = false, limit = false) {
+  const half = map.getSize().divideBy(2), distance = map.getSize().y * 1.5;
+  if (!distance) return pointOf(point);
+  const [cos, sin, tilt, rise] = angles(map);
+  const p = pointOf(point).subtract(half);
+  if (inverse) {
+    const far = map.getSize().y * map.options.pitchMaxDistance;
+    const denominator = tilt * distance + rise * p.y;
+    let v = denominator > 0 ? p.y * distance / denominator : -far;
+    if (limit) v = Math.max(-far, Math.min(far, v));
+    const u = p.x * (distance - rise * v) / distance;
+    return new L.Point(cos * u + sin * v, -sin * u + cos * v).add(half);
+  }
+  const u = cos * p.x - sin * p.y, v = sin * p.x + cos * p.y;
+  const scale = distance / (distance - rise * v);
+  return new L.Point(u * scale, tilt * v * scale).add(half);
+}

package/src/camera/runCameraAnimations.js

@@ -0,0 +1,28 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+import { scheduleCameraAnimation } from './scheduleCameraAnimation.js';
+
+export function runCameraAnimations(now) {
+  mapCameraState.cameraAnimationFrame = null;
+  const pending = [...mapCameraState.cameraAnimations];
+  mapCameraState.cameraAnimations.clear();
+  let failure;
+  let map, animation, progress, eased;
+  for ([map, animation] of pending) {
+    map._cameraFrame = null;
+    if (map._cameraAnimation !== animation) continue;
+    progress = animation.duration
+      ? Math.min(1, (now - animation.start) / (animation.duration * 1000)) : 1;
+    eased = 1 - (1 - progress) ** 3;
+    try {
+      map._setPitchAndBearing(
+        animation.fromPitch + (Math.max(0, Math.min(85, animation.pitch)) - animation.fromPitch) * eased,
+        animation.fromBearing + animation.delta * eased,
+      );
+      if (progress < 1 && map._cameraAnimation === animation) scheduleCameraAnimation(map, animation);
+      else if (map._cameraAnimation === animation) map._cameraAnimation = null;
+    } catch (error) {
+      failure ||= error;
+    }
+  }
+  if (failure) throw failure;
+}

package/src/camera/scheduleCameraAnimation.js

@@ -0,0 +1,8 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+import { runCameraAnimations } from './runCameraAnimations.js';
+
+export function scheduleCameraAnimation(map, animation) {
+  mapCameraState.cameraAnimations.set(map, animation);
+  if (mapCameraState.cameraAnimationFrame === null) mapCameraState.cameraAnimationFrame = requestAnimationFrame(runCameraAnimations);
+  map._cameraFrame = mapCameraState.cameraAnimationFrame;
+}

package/src/camera/updateSky.js

@@ -0,0 +1,16 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+
+export function updateSky() {
+  const height = this.getSize().y, pitch = this.getPitch() * mapCameraState.radians;
+  const far = height * this.options.pitchMaxDistance, distance = height * 1.5;
+  const top = height / 2 - far * Math.cos(pitch) * distance / (distance + Math.sin(pitch) * far);
+  if (top > 0 && !this._pitchSky) {
+    this._pitchSky = L.DomUtil.create('div', 'leaflet-pitch-sky', this.getContainer());
+    this._pitchSky.setAttribute('aria-hidden', 'true');
+    this._pitchSky.style.cssText = 'position:absolute;inset:0 0 auto;height:0;z-index:0;pointer-events:none;background:var(--leaflet-sky-background,linear-gradient(#9ec5e8,#dfe9f0))';
+  }
+  if (this._pitchSky) {
+    this._pitchSky.style.height = `${Math.max(0, Math.ceil(top))}px`;
+    this._pitchSky.style.display = top > 0 ? '' : 'none';
+  }
+}

package/src/camera/verticalGroundY.js

@@ -0,0 +1,4 @@
+export function verticalGroundY(y, tilt, distance, rise, far) {
+  return tilt * distance + rise * y > 0
+    ? Math.max(-far, Math.min(far, y * distance / (tilt * distance + rise * y))) : -far;
+}

package/src/collision/collectMeshes.js

@@ -0,0 +1,5 @@
+export function collectMeshes(node, meshes) {
+  if (node.geometry?.attributes.position) meshes.push(node);
+  let child;
+  for (child of node.children) collectMeshes(child, meshes);
+}

package/src/collision/collider.js

@@ -0,0 +1,63 @@
+import { CELL } from '../constants/CELL.js';
+import { colliders } from '../constants/colliders.js';
+
+
+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 = [];
+
+  let i, first, k, j, x, y, z, ex, ey, ez, fx, fy, fz, nx, nz, ny, length, a, h, t, ix, iz, key;
+  for (i = 0; i < count; i += 3) {
+    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 (k = 0; k < 3; k++) {
+      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];
+    }
+    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];
+
+    nx = ey * fz - ez * fy, nz = ex * fy - ey * fx;
+
+    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.
+      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; }
+    }
+
+    h = Math.hypot(nx, nz), t = nrm.length / 2;
+
+    tri.push(...v);
+    nrm.push(nx / h, nz / h);
+
+    for (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 (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++) {
+        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;
+}

package/src/collision/intersectMeshes.js

@@ -0,0 +1,133 @@
+import { computeBounds } from "../geometry/computeBounds.js";
+import { sub } from '../geometry/sub.js';
+import { cross } from '../geometry/cross.js';
+import { dot } from '../geometry/dot.js';
+import { sortHits } from './sortHits.js';
+
+/** Nearest triangle hit per mesh, sorted by world-space distance. */
+
+export function intersectMeshes(ray, meshes, night = 0) {
+  const hits = [],
+  a = [0, 0, 0],
+  b = [0, 0, 0],
+  c = [0, 0, 0];
+  let mesh, inverse, inverseValues, value, localOrigin, origin, localDirection, direction;
+  let directionLength, near, far, i, a2, b2, position, index, instanceOffset, vertices, closest;
+  let faceIndex, vertex, offset, x, y, z, ai, bi, ci, e, f, p, det, t, u, q, v, uv, ids, x2, y2;
+  let distance, point, worldPoint;
+  for (mesh of meshes) {
+    // Test in mesh-local space; compare distances only after returning to shared world space.
+    inverse = new DOMMatrix(mesh.worldMatrix).inverse();
+    inverseValues = inverse.toFloat64Array();
+    for (value of inverseValues) {
+      if (!Number.isFinite(value)) throw new Error('Singular 3D transform');
+    }
+    localOrigin = new DOMPoint(...ray.origin, 1).matrixTransform(inverse);
+    origin = [
+      localOrigin.x / localOrigin.w,
+      localOrigin.y / localOrigin.w,
+      localOrigin.z / localOrigin.w
+    ];
+    localDirection = new DOMPoint(...ray.direction, 0).matrixTransform(inverse);
+    direction = [
+      localDirection.x,
+      localDirection.y,
+      localDirection.z
+    ];
+    directionLength = Math.hypot(...direction) || 1;
+    direction[0] /= directionLength;
+    direction[1] /= directionLength;
+    direction[2] /= directionLength;
+    // AABB slab test reuses the same local ray as the triangle test.
+    if (!mesh.geometry.bounds) {
+      computeBounds(mesh.geometry);
+    }
+    near = 0, far = Infinity;
+    for (i = 0; i < 3; i++) {
+      if (Math.abs(direction[i]) < 1e-12) {
+        if (origin[i] < mesh.geometry.bounds.min[i] || origin[i] > mesh.geometry.bounds.max[i]) {
+          far = -Infinity;
+          break;
+        }
+      } else {
+        a2 = (mesh.geometry.bounds.min[i] - origin[i]) / direction[i], b2 = (mesh.geometry.bounds.max[i] - origin[i]) / direction[i];
+        near = Math.max(near, Math.min(a2, b2));
+        far = Math.min(far, Math.max(a2, b2));
+      }
+    }
+    if (far < near) {
+      continue;
+    }
+    ({ position, index, instanceOffset } = mesh.geometry.attributes);
+    vertices = index?.count || position.count;
+    closest = Infinity, faceIndex = void 0;
+    for (i = 0; i < vertices * (instanceOffset?.count ?? 1); i += 3) {
+      vertex = instanceOffset ? i % vertices : i;
+      offset = instanceOffset ? Math.floor(i / vertices) * instanceOffset.size : 0;
+      x = instanceOffset?.data[offset] ?? 0;
+      y = instanceOffset?.data[offset + 1] ?? 0;
+      z = instanceOffset?.data[offset + 2] ?? 0;
+      ai = (index ? index.data[vertex] : vertex) * position.size;
+      bi = (index ? index.data[vertex + 1] : vertex + 1) * position.size;
+      ci = (index ? index.data[vertex + 2] : vertex + 2) * position.size;
+      a[0] = position.data[ai];
+      a[1] = position.data[ai + 1];
+      a[2] = position.data[ai + 2];
+      b[0] = position.data[bi];
+      b[1] = position.data[bi + 1];
+      b[2] = position.data[bi + 2];
+      c[0] = position.data[ci];
+      c[1] = position.data[ci + 1];
+      c[2] = position.data[ci + 2];
+      if (instanceOffset) {
+        a[0] = Math.fround(a[0] + x); a[1] = Math.fround(a[1] + y); a[2] = Math.fround(a[2] + z);
+        b[0] = Math.fround(b[0] + x); b[1] = Math.fround(b[1] + y); b[2] = Math.fround(b[2] + z);
+        c[0] = Math.fround(c[0] + x); c[1] = Math.fround(c[1] + y); c[2] = Math.fround(c[2] + z);
+      }
+      // Moller-Trumbore: barycentric triangle coordinates and local ray distance.
+      e = sub(b, a), f = sub(c, a), p = cross(direction, f), det = dot(e, p);
+      if (mesh.program.cullMode === 'none' || mesh.program.cullFace === null
+        ? Math.abs(det) < 1e-9 : det < 1e-9) {
+        continue;
+      }
+      t = sub(origin, a), u = dot(t, p) / det;
+      if (u < 0 || u > 1) {
+        continue;
+      }
+      q = cross(t, e), v = dot(direction, q) / det;
+      if (v < 0 || u + v > 1) {
+        continue;
+      }
+      if (mesh.program.nightLight) {
+        uv = mesh.geometry.attributes.uv.data;
+        ids = index ? [index.data[i], index.data[i + 1], index.data[i + 2]] : [i, i + 1, i + 2];
+        x2 = uv[ids[0] * 2] * (1 - u - v) + uv[ids[1] * 2] * u + uv[ids[2] * 2] * v;
+        y2 = uv[ids[0] * 2 + 1] * (1 - u - v) + uv[ids[1] * 2 + 1] * u + uv[ids[2] * 2 + 1] * v;
+        if (x2 <= 2 && (!night || x2 * x2 + y2 * y2 > 0.9)) continue;
+      }
+      distance = dot(f, q) / det;
+      if (distance > 0 && distance < closest) {
+        closest = distance; faceIndex = i / 3;
+      }
+    }
+    if (faceIndex === undefined) continue;
+    point = new DOMPoint(
+      direction[0] * closest + origin[0],
+      direction[1] * closest + origin[1],
+      direction[2] * closest + origin[2],
+      1
+    ).matrixTransform(new DOMMatrix(mesh.worldMatrix));
+    worldPoint = [point.x / point.w, point.y / point.w, point.z / point.w];
+    hits.push({
+      faceIndex,
+      object: mesh,
+      point: worldPoint,
+      distance: Math.hypot(
+        worldPoint[0] - ray.origin[0],
+        worldPoint[1] - ray.origin[1],
+        worldPoint[2] - ray.origin[2]
+      )
+    });
+  }
+  return sortHits(hits);
+}

package/src/collision/sortHits.js

@@ -0,0 +1,23 @@
+export function sortHits(hits) {
+  const buffer = new Array(hits.length);
+  let source = hits, target = buffer;
+  let width, start, middle, end, left, right, output, previous, i;
+  for (width = 1; width < hits.length; width *= 2) {
+    for (start = 0; start < hits.length; start += width * 2) {
+      middle = Math.min(start + width, hits.length), end = Math.min(start + width * 2, hits.length);
+      left = start, right = middle;
+      for (output = start; output < end; output++) {
+        if (left < middle && (right >= end || !(source[right].distance < source[left].distance))) {
+          target[output] = source[left++];
+        } else {
+          target[output] = source[right++];
+        }
+      }
+    }
+    previous = source;
+    source = target;
+    target = previous;
+  }
+  if (source !== hits) for (i = 0; i < hits.length; i++) hits[i] = source[i];
+  return hits;
+}

package/src/constants/Compass.js

@@ -0,0 +1,7 @@
+import { compassAddHooks } from '../controls/compassAddHooks.js';
+import { compassRemoveHooks } from '../controls/compassRemoveHooks.js';
+
+export const Compass = L.Handler.extend({
+  addHooks: compassAddHooks,
+  removeHooks: compassRemoveHooks,
+});

package/src/constants/ContainerResize.js

@@ -0,0 +1,7 @@
+import { containerResizeAddHooks } from '../controls/containerResizeAddHooks.js';
+import { containerResizeRemoveHooks } from '../controls/containerResizeRemoveHooks.js';
+
+export const ContainerResize = L.Handler.extend({
+  addHooks: containerResizeAddHooks,
+  removeHooks: containerResizeRemoveHooks,
+});

package/src/constants/HEIGHT.js

@@ -0,0 +1 @@
+export const HEIGHT = 8;

package/src/constants/PitchDrag.js

@@ -0,0 +1,7 @@
+import { pitchDragAddHooks } from '../controls/pitchDragAddHooks.js';
+import { pitchDragRemoveHooks } from '../controls/pitchDragRemoveHooks.js';
+
+export const PitchDrag = L.Handler.extend({
+  addHooks: pitchDragAddHooks,
+  removeHooks: pitchDragRemoveHooks,
+});

package/src/constants/ShiftRotate.js

@@ -0,0 +1,7 @@
+import { shiftRotateAddHooks } from '../controls/shiftRotateAddHooks.js';
+import { shiftRotateRemoveHooks } from '../controls/shiftRotateRemoveHooks.js';
+
+export const ShiftRotate = L.Handler.extend({
+  addHooks: shiftRotateAddHooks,
+  removeHooks: shiftRotateRemoveHooks,
+});

package/src/constants/TILE_RADIUS.js

@@ -0,0 +1 @@
+export const TILE_RADIUS = 6;

package/src/constants/TILE_SIZE.js

@@ -0,0 +1 @@
+export const TILE_SIZE = 256;

package/src/constants/TouchMode.js

@@ -0,0 +1,6 @@
+import { notifyCameraTouchChange } from '../controls/notifyCameraTouchChange.js';
+
+export const TouchMode = L.Handler.extend({
+  addHooks: notifyCameraTouchChange,
+  removeHooks: notifyCameraTouchChange,
+});

package/src/constants/attachState.js

@@ -0,0 +1 @@
+export const attachState = {};

package/src/constants/cameraControlsState.js

@@ -0,0 +1 @@
+export const cameraControlsState = {};

package/src/constants/cityMapper.js

@@ -0,0 +1,6 @@
+import { renderers } from './renderers.js';
+
+export const cityMapper = {
+  renderers,
+  nextId: 0,
+};

package/src/constants/dark.js

@@ -0,0 +1 @@
+export const dark = [0.08, 0.07, 0.06];

package/src/constants/elevationWGSL.js

@@ -0,0 +1,27 @@
+/**
+ * WGSL twin of getElevation for the vertex shader: bilinear DEM pixels, or the first valid
+ * neighbour near no-data (stored as -1e9), else `base`. Expects `dem: texture_2d<f32>`.
+ */
+export const elevationWGSL = /* wgsl */ `
+  fn demSample(pixel: vec2<i32>) -> f32 {
+    if (any(pixel < vec2<i32>(0)) || any(pixel >= vec2<i32>(textureDimensions(dem)))) { return -1e9; }
+    return textureLoad(dem, pixel, 0).r;
+  }
+  fn elevation(pixel: vec2<f32>, base: f32) -> f32 {
+    let p = pixel - vec2<f32>(0.5);
+    let f = fract(p);
+    let i = vec2<i32>(floor(p));
+    let v00 = demSample(i);
+    let v10 = demSample(i + vec2<i32>(1, 0));
+    let v01 = demSample(i + vec2<i32>(0, 1));
+    let v11 = demSample(i + vec2<i32>(1, 1));
+    if (v00 > -1000.0 && v10 > -1000.0 && v01 > -1000.0 && v11 > -1000.0) {
+      return mix(mix(v00, v10, f.x), mix(v01, v11, f.x), f.y);
+    }
+    if (v00 > -1000.0) { return v00; }
+    if (v10 > -1000.0) { return v10; }
+    if (v01 > -1000.0) { return v01; }
+    if (v11 > -1000.0) { return v11; }
+    return base;
+  }
+`;

package/src/constants/glass.js

@@ -0,0 +1 @@
+export const glass = [0.12, 0.15, 0.18];

package/src/constants/indexState.js

@@ -0,0 +1 @@
+export const indexState = {};

package/src/constants/mapCameraState.js

@@ -0,0 +1 @@
+export const mapCameraState = {};

package/src/constants/nativeEventMaps.js

@@ -0,0 +1 @@
+export const nativeEventMaps = new WeakMap();

package/src/constants/nativeLayerState.js

@@ -0,0 +1 @@
+export const nativeLayerState = {};

package/src/constants/nativeMethodHandlers.js

@@ -0,0 +1,31 @@
+import { nativeSetLatLng } from '../core/nativeSetLatLng.js';
+import { nativeSetLatLngs } from '../core/nativeSetLatLngs.js';
+import { nativeAddLatLng } from '../core/nativeAddLatLng.js';
+import { nativeSetRadius } from '../core/nativeSetRadius.js';
+import { nativeSetStyle } from '../core/nativeSetStyle.js';
+import { nativeRedraw } from '../core/nativeRedraw.js';
+import { nativeSetIcon } from '../core/nativeSetIcon.js';
+import { nativeSetUrl } from '../core/nativeSetUrl.js';
+import { nativeSetBounds } from '../core/nativeSetBounds.js';
+import { nativeSetOpacity } from '../core/nativeSetOpacity.js';
+import { nativeSetZIndex } from '../core/nativeSetZIndex.js';
+import { nativeSetZIndexOffset } from '../core/nativeSetZIndexOffset.js';
+import { nativeBringToFront } from '../core/nativeBringToFront.js';
+import { nativeBringToBack } from '../core/nativeBringToBack.js';
+
+export const nativeMethodHandlers = {
+  setLatLng: nativeSetLatLng,
+  setLatLngs: nativeSetLatLngs,
+  addLatLng: nativeAddLatLng,
+  setRadius: nativeSetRadius,
+  setStyle: nativeSetStyle,
+  redraw: nativeRedraw,
+  setIcon: nativeSetIcon,
+  setUrl: nativeSetUrl,
+  setBounds: nativeSetBounds,
+  setOpacity: nativeSetOpacity,
+  setZIndex: nativeSetZIndex,
+  setZIndexOffset: nativeSetZIndexOffset,
+  bringToFront: nativeBringToFront,
+  bringToBack: nativeBringToBack,
+};

package/src/constants/onMapChangeState.js

@@ -0,0 +1 @@
+export const onMapChangeState = {};

package/src/constants/onZoomAnimState.js

@@ -0,0 +1 @@
+export const onZoomAnimState = {};

package/src/constants/parts.js

@@ -0,0 +1,19 @@
+import { box } from "../geometry/box.js";
+import { trousers } from './trousers.js';
+import { shirt } from './shirt.js';
+import { skin } from './skin.js';
+import { dark } from './dark.js';
+
+
+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]],
+};

package/src/constants/pendingUpdates.js

@@ -0,0 +1 @@
+export const pendingUpdates = new Set();

package/src/constants/pumpState.js

@@ -0,0 +1 @@
+export const pumpState = {};

package/src/constants/ringDirections.js

@@ -0,0 +1,10 @@
+export const ringDirections = [
+  { x: Math.cos(0 * Math.PI / 4), y: Math.sin(0 * Math.PI / 4), nx: Math.cos((0 + 0.5) * Math.PI / 4), nz: -Math.sin((0 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(1 * Math.PI / 4), y: Math.sin(1 * Math.PI / 4), nx: Math.cos((1 + 0.5) * Math.PI / 4), nz: -Math.sin((1 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(2 * Math.PI / 4), y: Math.sin(2 * Math.PI / 4), nx: Math.cos((2 + 0.5) * Math.PI / 4), nz: -Math.sin((2 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(3 * Math.PI / 4), y: Math.sin(3 * Math.PI / 4), nx: Math.cos((3 + 0.5) * Math.PI / 4), nz: -Math.sin((3 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(4 * Math.PI / 4), y: Math.sin(4 * Math.PI / 4), nx: Math.cos((4 + 0.5) * Math.PI / 4), nz: -Math.sin((4 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(5 * Math.PI / 4), y: Math.sin(5 * Math.PI / 4), nx: Math.cos((5 + 0.5) * Math.PI / 4), nz: -Math.sin((5 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(6 * Math.PI / 4), y: Math.sin(6 * Math.PI / 4), nx: Math.cos((6 + 0.5) * Math.PI / 4), nz: -Math.sin((6 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(7 * Math.PI / 4), y: Math.sin(7 * Math.PI / 4), nx: Math.cos((7 + 0.5) * Math.PI / 4), nz: -Math.sin((7 + 0.5) * Math.PI / 4) },
+];

package/src/constants/roundProfile.js

@@ -0,0 +1 @@
+export const roundProfile = [[0, 0], [0.35, 0.8], [0.6, 1], [0.85, 0.7], [1, 0]];

package/src/constants/shirt.js

@@ -0,0 +1 @@
+export const shirt = [0.75, 0.2, 0.15];

package/src/constants/skin.js

@@ -0,0 +1,2 @@
+// Pedestrian, about 1.77 m tall, prisms as in utils/vehicles.js (forward -z). Limbs hang from their pivot at y = 0.
+export const skin = [0.85, 0.64, 0.5];

package/src/constants/trafficShader.js

@@ -0,0 +1,49 @@
+// One workgroup per vehicle shares its lane lookup and pose across all model vertices.
+export const trafficShader = /* wgsl */ `
+  struct Params { seconds: f32, side: f32, vertices: u32, total: u32 }
+  struct Vehicle { start: u32, count: u32, base: f32, speed: f32 }
+  @group(0) @binding(0) var<uniform> params: Params;
+  @group(0) @binding(1) var<storage, read> model: array<f32>;
+  @group(0) @binding(2) var<storage, read> points: array<vec4f>;
+  @group(0) @binding(3) var<storage, read> vehicles: array<Vehicle>;
+  @group(0) @binding(4) var<storage, read_write> position: array<f32>;
+  @group(0) @binding(5) var<storage, read_write> normal: array<f32>;
+  var<workgroup> center: vec3f;
+  var<workgroup> heading: vec2f;
+  @compute @workgroup_size(64)
+  fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) thread: u32) {
+    let vehicleIndex = group.x;
+    if (thread == 0u) {
+      let vehicle = vehicles[vehicleIndex];
+      let last = vehicle.start + vehicle.count - 1u;
+      let length = points[last].w;
+      var s = vehicle.base + params.seconds * vehicle.speed;
+      s -= length * floor(s / length);
+      var i = vehicle.start + 1u;
+      var end = last;
+      while (i < end) {
+        let middle = i + (end - i) / 2u;
+        if (points[middle].w < s) { i = middle + 1u; }
+        else { end = middle; }
+      }
+      let a = points[i - 1u];
+      let b = points[i];
+      let d = select(b.w - a.w, 1.0, b.w == a.w);
+      let t = (s - a.w) / d;
+      heading = (b.xy - a.xy) / d;
+      center = vec3f(a.x + (b.x - a.x) * t - heading.y * params.side,
+        a.z + (b.z - a.z) * t, a.y + (b.y - a.y) * t + heading.x * params.side);
+    }
+    workgroupBarrier();
+    for (var vertex = thread; vertex < params.vertices; vertex += 64u) {
+      let k = vertex * 3u;
+      let n = params.vertices * 3u + k;
+      let o = (vehicleIndex * params.vertices + vertex) * 3u;
+      position[o] = center.x - model[k] * heading.y - model[k + 2u] * heading.x;
+      position[o + 1u] = center.y + model[k + 1u];
+      position[o + 2u] = center.z + model[k] * heading.x - model[k + 2u] * heading.y;
+      normal[o] = -model[n] * heading.y - model[n + 2u] * heading.x;
+      normal[o + 1u] = model[n + 1u];
+      normal[o + 2u] = model[n] * heading.x - model[n + 2u] * heading.y;
+    }
+  }`;

package/src/constants/trousers.js

@@ -0,0 +1 @@
+export const trousers = [0.16, 0.2, 0.32];

package/src/constants/tyre.js

@@ -0,0 +1 @@
+export const tyre = [0.05, 0.05, 0.05];

package/src/constants/underEntryState.js

@@ -0,0 +1 @@
+export const underEntryState = {};