leaflet-city-mapper 0.0.3 → 0.0.5

package/src/cog/validCogEncoding.js

@@ -0,0 +1,5 @@
+export function validCogEncoding(tags, samples, bits, format, elevation, bytes, unsigned) {
+  if (elevation) return tags.get(262)?.[0] === 1;
+  return (samples === 3 || samples === 4) && bits?.length === samples && bytes && unsigned &&
+    tags.get(262)?.[0] === 2;
+}

package/src/cog/validCogGeoArrays.js

@@ -0,0 +1,8 @@
+import { finiteCogValues } from './finiteCogValues.js';
+
+export function validCogGeoArrays(keys, scale, tie) {
+  return !!keys && keys[0] === 1 && keys.length === 4 + keys[3] * 4 &&
+    !!scale && scale.length === 3 && finiteCogValues(scale) &&
+    scale[0] > 0 && Math.abs(scale[0] - scale[1]) <= 1e-8 &&
+    !!tie && tie.length === 6 && finiteCogValues(tie) && tie[0] === 0 && tie[1] === 0;
+}

package/src/cog/validCogGrid.js

@@ -0,0 +1,9 @@
+export function validCogGrid(source, base, profile, zoom, x, y, resolution) {
+  return zoom >= 0 && zoom <= 24 &&
+    Math.abs(20037508.342789244 * 2 / (256 * 2 ** zoom) - resolution) <= resolution * 1e-7 &&
+    (!profile.elevation || Number.isInteger(x) && Number.isInteger(y)) &&
+    Math.abs(base.width / profile.width - base.height / profile.height) <= 1e-7 &&
+    profile.elevation === base.elevation &&
+    x >= 0 && y >= 0 && x + profile.width / 256 <= 2 ** zoom && y + profile.height / 256 <= 2 ** zoom &&
+    !source.levels.has(zoom) && !(base.elevation && source.levels.size);
+}

package/src/cog/validCogTileCoordinates.js

@@ -0,0 +1,4 @@
+export function validCogTileCoordinates(z, x, y) {
+  return Number.isSafeInteger(z) && Number.isSafeInteger(x) && Number.isSafeInteger(y) &&
+    z >= 0 && z <= 24 && x >= 0 && y >= 0 && x < 2 ** z && y < 2 ** z;
+}

package/src/cog/validateCogContainer.js

@@ -0,0 +1,9 @@
+export function validateCogContainer(container, header) {
+  if (header.tileType !== 0 || header.tileCompression !== 1 ||
+    !Number.isSafeInteger(header.jsonMetadataOffset) || !Number.isSafeInteger(header.jsonMetadataLength) ||
+    header.jsonMetadataLength <= 0 || header.jsonMetadataLength > 1048576 ||
+    !Number.isSafeInteger(header.tileDataOffset) || !Number.isSafeInteger(header.tileDataLength) ||
+    header.tileDataOffset < 127 || header.tileDataOffset + header.tileDataLength > container.size) {
+    throw /* alloc */ new Error('Invalid PMTiles COG asset container');
+  }
+}

package/src/cog/validateCogContentRange.js

@@ -0,0 +1,8 @@
+export function validateCogContentRange(source, range, rangeStart, length) {
+  if (!range || Number(range[1]) !== rangeStart || Number(range[2]) !== rangeStart + length - 1 ||
+    !Number.isSafeInteger(Number(range[3])) || Number(range[3]) < rangeStart + length ||
+    (source.containerSize ?? source.size) !== undefined &&
+      (source.containerSize ?? source.size) !== Number(range[3])) {
+    throw /* alloc */ new Error('Invalid COG range response');
+  }
+}

package/src/cog/validateCogOffsets.js

@@ -0,0 +1,10 @@
+export function validateCogOffsets(source, level) {
+  if (level.offsets?.length !== level.columns * level.rows || level.lengths?.length !== level.offsets.length) {
+    throw /* alloc */ new Error('Invalid COG tile offsets or lengths');
+  }
+  let i;
+  for (i = 0; i < level.offsets.length; i++) {
+    if (!level.offsets[i] || !level.lengths[i] || level.lengths[i] > 1048576 ||
+      level.offsets[i] + level.lengths[i] > source.size) throw /* alloc */ new Error('Invalid COG tile offsets or lengths');
+  }
+}

package/src/cog/validateCogRange.js

@@ -0,0 +1,7 @@
+export function validateCogRange(source, offset, length) {
+  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 ||
+    length <= 0 || length > 32000000 || !Number.isSafeInteger(offset + length) ||
+    source.size !== undefined && offset + length > source.size) {
+    throw /* alloc */ new Error('Invalid COG byte range');
+  }
+}

package/src/cog/validateCogResponse.js

@@ -0,0 +1,15 @@
+import { validateCogContentRange } from './validateCogContentRange.js';
+import { invalidCogFullResponse } from './invalidCogFullResponse.js';
+
+export function validateCogResponse(source, response, rangeStart, length) {
+  const etag = response.headers.get('ETag');
+  if (source.etag && source.etag !== etag) throw /* alloc */ new Error('COG changed; recreate the layer');
+  if (etag) source.etag = etag;
+  const range = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(response.headers.get('Content-Range') || '');
+  if (response.status === 206) {
+    validateCogContentRange(source, range, rangeStart, length);
+    if (source.baseOffset === undefined) source.size = Number(range[3]);
+  } else if (invalidCogFullResponse(response)) {
+    throw /* alloc */ new Error('COG server must support byte ranges for files over 32 MB');
+  }
+}

package/src/collision/collider.js

@@ -1,27 +1,38 @@
-import { CELL } from '../constants/CELL.js';
-import { colliders } from '../constants/colliders.js';
+import { colliders } from '../weakmaps/colliders.js';
+import { indexTriangle } from './indexTriangle.js';
+import { readTriangle } from './readTriangle.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 m = mesh.worldMatrix, { position: { data: p }, index, normal, uv, instanceOffset } = mesh.geometry.attributes;
 
-  const count = index ? index.count : p.length / 3, tri = [], nrm = [], cells = new Map(), v = [];
+  const vertices = index ? index.count : p.length / 3;
+  const count = vertices * (instanceOffset?.count ?? 1);
+  const tri = /* alloc */ [];
+  const nrm = /* alloc */ [];
+  const cells = /* alloc */ new Map();
+  const a = /* alloc */ [0, 0, 0], b = /* alloc */ [0, 0, 0], d = /* alloc */ [0, 0, 0];
+  const v = /* alloc */ [];
 
-  let i, first, k, j, x, y, z, ex, ey, ez, fx, fy, fz, nx, nz, ny, length, a, h, t, ix, iz, key;
+  let i, first, j, ex, ey, ez, fx, fy, fz, nx, nz, ny, length, h, t, maxX = -Infinity;
   for (i = 0; i < count; i += 3) {
-    first = index ? index.data[i] : i;
+    first = index ? index.data[i % vertices] : i % vertices;
     // 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];
-    }
+    readTriangle(mesh, i, a, b, d);
+    v[0] = m[0] * a[0] + m[4] * a[1] + m[8] * a[2] + m[12];
+    v[1] = m[1] * a[0] + m[5] * a[1] + m[9] * a[2] + m[13];
+    v[2] = m[2] * a[0] + m[6] * a[1] + m[10] * a[2] + m[14];
+    v[3] = m[0] * b[0] + m[4] * b[1] + m[8] * b[2] + m[12];
+    v[4] = m[1] * b[0] + m[5] * b[1] + m[9] * b[2] + m[13];
+    v[5] = m[2] * b[0] + m[6] * b[1] + m[10] * b[2] + m[14];
+    v[6] = m[0] * d[0] + m[4] * d[1] + m[8] * d[2] + m[12];
+    v[7] = m[1] * d[0] + m[5] * d[1] + m[9] * d[2] + m[13];
+    v[8] = m[2] * d[0] + m[6] * d[1] + m[10] * d[2] + 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;
@@ -34,29 +45,25 @@ export function collider(mesh) {
 
     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; }
+      j = first * 3;
+      if ((m[0] * normal.data[j] + m[4] * normal.data[j + 1] + m[8] * normal.data[j + 2]) * nx +
+        (m[2] * normal.data[j] + m[6] * normal.data[j + 1] + m[10] * normal.data[j + 2]) * nz < 0) { nx = -nx; nz = -nz; }
     }
 
     h = Math.hypot(nx, nz), t = nrm.length / 2;
 
     tri.push(...v);
+    maxX = Math.max(maxX, v[0], v[3], v[6]);
     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);
-      }
+    indexTriangle(cells, v, t);
   }
-  c = {
+  c = /* alloc */ {
     tri: Float32Array.from(tri),
     nrm: Float32Array.from(nrm),
     cells,
-    origin: [m[12], m[13], m[14]]
+    maxX,
+    origin: /* alloc */ [m[12], m[13], m[14]]
   };
   colliders.set(mesh.geometry, c);
   return c;

package/src/collision/hiddenLightHit.js

@@ -0,0 +1,8 @@
+export function hiddenLightHit(mesh, i, u, v, night) {
+  if (!mesh.program.nightLight) return false;
+  const { index, uv: { data: uv } } = mesh.geometry.attributes;
+  const idA = index ? index.data[i] : i, idB = index ? index.data[i + 1] : i + 1, idC = index ? index.data[i + 2] : i + 2;
+  const x = uv[idA * 2] * (1 - u - v) + uv[idB * 2] * u + uv[idC * 2] * v;
+  const y = uv[idA * 2 + 1] * (1 - u - v) + uv[idB * 2 + 1] * u + uv[idC * 2 + 1] * v;
+  return x <= 2 && (!night || x * x + y * y > 0.9);
+}

package/src/collision/indexTriangle.js

@@ -0,0 +1,11 @@
+import { CELL } from '../globals/CELL.js';
+
+export function indexTriangle(cells, v, t) {
+  let ix, iz, key;
+  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, /* alloc */ []);
+      cells.get(key).push(t);
+    }
+}

package/src/collision/insideMesh.js

@@ -0,0 +1,53 @@
+import { CELL } from '../globals/CELL.js';
+
+import { collider } from './collider.js';
+import { horizontalRay } from './horizontalRay.js';
+import { computeBounds } from '../geometry/computeBounds.js';
+
+export function insideMesh(mesh, x, y, z, seen, intersections) {
+  const geometry = mesh.geometry;
+  if (!mesh.visible || !geometry?.attributes?.position?.data || mesh.program?.depthTest === false) return false;
+  if (!geometry.bounds) computeBounds(geometry);
+  const bounds = geometry.bounds;
+  const world = mesh.worldMatrix;
+  const center = bounds.center;
+  const cx = world[0] * center[0] + world[4] * center[1] + world[8] * center[2] + world[12];
+  const cy = world[1] * center[0] + world[5] * center[1] + world[9] * center[2] + world[13];
+  const cz = world[2] * center[0] + world[6] * center[1] + world[10] * center[2] + world[14];
+  const radius = bounds.radius * Math.max(
+    Math.hypot(world[0], world[1], world[2]),
+    Math.hypot(world[4], world[5], world[6]),
+    Math.hypot(world[8], world[9], world[10])
+  );
+  if (Math.hypot(cx - x, cy - y, cz - z) > radius) return false;
+  const shape = collider(mesh);
+  const end = Math.floor(shape.maxX / CELL);
+  if (x >= shape.maxX) return false;
+  const iz = Math.floor(z / CELL);
+  const hits = intersections;
+  hits.length = 0;
+  seen.clear();
+  let ix, cell, triangle, distance;
+  for (ix = Math.floor(x / CELL); ix <= end; ix++) {
+    cell = shape.cells.get(`${ix},${iz}`);
+    if (!cell) continue;
+    for (triangle of cell) {
+      if (seen.has(triangle)) continue;
+      seen.add(triangle);
+      distance = horizontalRay(shape.tri, triangle, x, y, z, 1, 0);
+      if (distance > 1e-4) hits.push(distance);
+    }
+  }
+  for (ix = 1; ix < hits.length; ix++) {
+    distance = hits[ix];
+    let j = ix - 1;
+    while (j >= 0 && hits[j] > distance) hits[j + 1] = hits[j--];
+    hits[j + 1] = distance;
+  }
+  let crossings = 0, previous = -Infinity;
+  for (distance of hits) {
+    if (distance - previous > 1e-4) crossings++;
+    previous = distance;
+  }
+  return crossings % 2 === 1;
+}

package/src/collision/insideWalker.js

@@ -0,0 +1,46 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
+import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
+import { insideMesh } from './insideMesh.js';
+import { trafficCollision } from './trafficCollision.js';
+import { local } from '../projections/walkerLocalPosition.js';
+
+export function insideWalker(context) {
+  const { layer, local: localBuffer, hitData } = context;
+  const shared = sharedByLayer.get(layer);
+  if (!shared || !layersByLayer.get(shared)) return false;
+  updateWorldMatrix(sceneByLayer.get(layer));
+  const root = rootByLayer.get(layer);
+  const feet = local.call(context, localBuffer);
+  const x = root.position[0] + feet[0] * root.scale[0];
+  const y = root.position[1] + feet[1] * root.scale[1];
+  const z = root.position[2] + feet[2] * root.scale[2];
+  const layers = layersByLayer.get(shared);
+  let other, node, child;
+  for (other of layers) {
+    if (other === layer || kindByLayer.get(other) === 'terrain') continue;
+    if (kindByLayer.get(other) === 'traffic') {
+      hitData.best = 0;
+      hitData.found = false;
+      if (trafficCollision(other, x, y, z, 0, 0, 0, hitData)) return true;
+      continue;
+    }
+    const nodes = hitData.nodes;
+    nodes.length = 0;
+    if (rootByLayer.get(other)) nodes.push(rootByLayer.get(other));
+    while (nodes.length) {
+      node = nodes.pop();
+      if (!node.visible) continue;
+      if (node.geometry && (
+        insideMesh(node, x, y + 0.45 * root.scale[1], z, hitData.seen, hitData.intersections) ||
+        insideMesh(node, x, y + 1.35 * root.scale[1], z, hitData.seen, hitData.intersections)
+      )) return true;
+      for (child of node.children) nodes.push(child);
+    }
+  }
+  return false;
+}

package/src/collision/intersectMeshes.js

@@ -1,133 +1,32 @@
-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);
-}
+import { sortHits } from './sortHits.js';
+import { localRay } from './localRay.js';
+import { rayBounds } from './rayBounds.js';
+import { readTriangle } from './readTriangle.js';
+import { triangleDistance } from './triangleDistance.js';
+import { worldHit } from './worldHit.js';
+
+/** Nearest triangle hit per mesh, sorted by world-space distance. */
+export function intersectMeshes(ray, meshes, night = 0) {
+  const hits = /* alloc */ [];
+  const a = /* alloc */ [0, 0, 0], b = /* alloc */ [0, 0, 0], c = /* alloc */ [0, 0, 0];
+  const origin = /* alloc */ [0, 0, 0], direction = /* alloc */ [0, 0, 0];
+  let mesh, position, index, instanceOffset, vertices, closest, faceIndex, i, distance;
+  for (mesh of meshes) {
+    // Test locally, then compare distances in shared world space.
+    localRay(ray, mesh, origin, direction);
+    if (!rayBounds(mesh, origin, direction)) 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) {
+      readTriangle(mesh, i, a, b, c);
+      distance = triangleDistance(mesh, i, a, b, c, origin, direction, night);
+      if (distance > 0 && distance < closest) {
+        closest = distance; faceIndex = i / 3;
+      }
+    }
+    if (faceIndex === undefined) continue;
+    hits.push(worldHit(ray, mesh, origin, direction, closest, faceIndex));
+  }
+  return sortHits(hits);
+}

package/src/collision/localRay.js

@@ -0,0 +1,21 @@
+export function localRay(ray, mesh, origin, direction) {
+  const inverse = /* alloc */ new DOMMatrix(mesh.worldMatrix).invertSelf();
+  const inverseValues = inverse.toFloat64Array();
+  let value, x, y, z, w;
+  for (value of inverseValues) {
+    if (!Number.isFinite(value)) throw /* alloc */ new Error('Singular 3D transform');
+  }
+  x = ray.origin[0], y = ray.origin[1], z = ray.origin[2];
+  w = inverseValues[3] * x + inverseValues[7] * y + inverseValues[11] * z + inverseValues[15];
+  origin[0] = (inverseValues[0] * x + inverseValues[4] * y + inverseValues[8] * z + inverseValues[12]) / w;
+  origin[1] = (inverseValues[1] * x + inverseValues[5] * y + inverseValues[9] * z + inverseValues[13]) / w;
+  origin[2] = (inverseValues[2] * x + inverseValues[6] * y + inverseValues[10] * z + inverseValues[14]) / w;
+  x = ray.direction[0], y = ray.direction[1], z = ray.direction[2];
+  direction[0] = inverseValues[0] * x + inverseValues[4] * y + inverseValues[8] * z;
+  direction[1] = inverseValues[1] * x + inverseValues[5] * y + inverseValues[9] * z;
+  direction[2] = inverseValues[2] * x + inverseValues[6] * y + inverseValues[10] * z;
+  const directionLength = Math.hypot(...direction) || 1;
+  direction[0] /= directionLength;
+  direction[1] /= directionLength;
+  direction[2] /= directionLength;
+}

package/src/collision/mergeHits.js

@@ -0,0 +1,11 @@
+export function mergeHits(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[right].distance < source[left].distance))) {
+      target[output] = source[left++];
+    } else {
+      target[output] = source[right++];
+    }
+  }
+}

package/src/collision/rayBounds.js

@@ -0,0 +1,19 @@
+import { computeBounds } from '../geometry/computeBounds.js';
+
+export function rayBounds(mesh, origin, direction) {
+  if (!mesh.geometry.bounds) computeBounds(mesh.geometry);
+  let near = 0, far = Infinity, i, a, b;
+  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 {
+      a = (mesh.geometry.bounds.min[i] - origin[i]) / direction[i], b = (mesh.geometry.bounds.max[i] - origin[i]) / direction[i];
+      near = Math.max(near, Math.min(a, b));
+      far = Math.min(far, Math.max(a, b));
+    }
+  }
+  return !(far < near);
+}

package/src/collision/readTriangle.js

@@ -0,0 +1,20 @@
+export function readTriangle(mesh, i, a, b, c) {
+  const { position, index, instanceOffset } = mesh.geometry.attributes;
+  const vertices = index?.count || position.count;
+  const vertex = instanceOffset ? i % vertices : i;
+  const offset = instanceOffset ? Math.floor(i / vertices) * instanceOffset.size : 0;
+  const x = instanceOffset?.data[offset] ?? 0;
+  const y = instanceOffset?.data[offset + 1] ?? 0;
+  const z = instanceOffset?.data[offset + 2] ?? 0;
+  const ai = (index ? index.data[vertex] : vertex) * position.size;
+  const bi = (index ? index.data[vertex + 1] : vertex + 1) * position.size;
+  const 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);
+  }
+}

package/src/collision/sortHits.js

@@ -1,18 +1,11 @@
 export function sortHits(hits) {
-  const buffer = new Array(hits.length);
+  if (hits.length < 2) return hits;
+  const buffer = /* alloc */ new Array(hits.length);
   let source = hits, target = buffer;
-  let width, start, middle, end, left, right, output, previous, i;
+  let width, start, 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++];
-        }
-      }
+      mergeHits(source, target, start, width);
     }
     previous = source;
     source = target;
@@ -21,3 +14,4 @@ export function sortHits(hits) {
   if (source !== hits) for (i = 0; i < hits.length; i++) hits[i] = source[i];
   return hits;
 }
+import { mergeHits } from './mergeHits.js';

package/src/collision/trafficCollision.js

@@ -0,0 +1,60 @@
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { trafficByLayer } from '../weakmaps/trafficByLayer.js';
+
+import { locateTraffic } from '../traffic/locateTraffic.js';
+
+export function trafficCollision(layer, x, y, z, dx, dz, reach, data) {
+  const state = trafficByLayer.get(layer);
+  if (!state?.mesh || !state.trips.length) return false;
+  let bounds = state.collisionBounds;
+  if (!bounds) {
+    bounds = state.collisionBounds = { radius: 0, minY: Infinity, maxY: -Infinity };
+    let i, px, py, pz;
+    for (i = 0; i < state.template.position.length; i += 3) {
+      px = state.template.position[i];
+      py = state.template.position[i + 1];
+      pz = state.template.position[i + 2];
+      bounds.radius = Math.max(bounds.radius, Math.hypot(px, pz));
+      bounds.minY = Math.min(bounds.minY, py);
+      bounds.maxY = Math.max(bounds.maxY, py);
+    }
+  }
+  const root = rootByLayer.get(layer), position = state.position ||= {};
+  const scale = Math.max(root.scale[0], root.scale[1], root.scale[2]);
+  const radius = bounds.radius * scale + 0.35;
+  let trip, projection, closest, rx, rz, perpendicular, entry, distance, bottom, top, px, pz;
+  for (trip of state.trips) {
+    ({ x: px, y: bottom, z: pz } = locateTraffic(state, trip, position));
+    bottom = root.position[1] + (bottom + bounds.minY) * root.scale[1];
+    top = root.position[1] + (position.y + bounds.maxY) * root.scale[1];
+    if (bottom > y + 1.7 * scale || top < y + 0.2 * scale) continue;
+    px = root.position[0] + px * root.scale[0];
+    pz = root.position[2] + pz * root.scale[2];
+    projection = (px - x) * dx + (pz - z) * dz;
+    closest = Math.max(0, Math.min(reach, projection));
+    rx = x + closest * dx - px;
+    rz = z + closest * dz - pz;
+    perpendicular = rx * rx + rz * rz;
+    if (perpendicular >= radius * radius) continue;
+    if (reach === 0) {
+      data.found = true;
+      distance = Math.hypot(x - px, z - pz);
+      data.normal[0] = distance ? (x - px) / distance : 0;
+      data.normal[1] = distance ? (z - pz) / distance : 0;
+      continue;
+    }
+    entry = Math.max(0, projection - Math.sqrt(radius * radius - perpendicular));
+    if (entry > reach || entry >= data.best) continue;
+    data.best = entry;
+    data.found = true;
+    distance = Math.hypot(x + entry * dx - px, z + entry * dz - pz);
+    if (distance < 1e-6) {
+      data.normal[0] = -dx;
+      data.normal[1] = -dz;
+    } else {
+      data.normal[0] = (x + entry * dx - px) / distance;
+      data.normal[1] = (z + entry * dz - pz) / distance;
+    }
+  }
+  return data.found;
+}

package/src/collision/transformTriangle.js

@@ -0,0 +1,9 @@
+export function transformTriangle(v, p, index, i, m) {
+  let k, j, x, y, z;
+  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];
+  }
+}