leaflet-city-mapper 0.0.2 → 0.0.4

package/src/utils/triangulate.js

@@ -1,100 +0,0 @@
-import { isClockWise } from "./isClockWise.js";
-
-/**
- * Triangulates a polygon given as `{x, y}` points.
- * Rings omit the repeated closing point; winding is normalized internally.
- * Vertex indices remain relative to the original inputs after duplicate/collinear
- * cleanup. Hole bridges duplicate endpoints, not source vertices.
- * @param {Object[]} contour Outer boundary.
- * @param {Object[][]} [holes] Interior boundaries.
- *
- * @returns {number[][]} Triangles as indices in `[...contour, ...holes.flat()]`.
- */
-
-export function triangulate(contour, holes = []) {
-  const points = [contour, ...holes].flat();
-  if (points.some(p => !Number.isFinite(p.x) || !Number.isFinite(p.y))) throw new Error('Invalid polygon coordinates');
-  // Translate near the origin to avoid cancellation with geographic coordinates.
-  const vertices = points.map((p, index) => ({ x: p.x - contour[0].x, y: p.y - contour[0].y, index }));
-  const cross = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
-  const equal = (a, b) => a.x === b.x && a.y === b.y;
-  // Remove zero-area corners before connecting holes; keep original vertex indices.
-  const clean = ring => {
-    let changed = true;
-    while (changed && ring.length > 3) {
-      changed = false;
-      for (let i = 0; i < ring.length; i++) {
-        const a = ring[(i + ring.length - 1) % ring.length], b = ring[i], c = ring[(i + 1) % ring.length];
-        if (equal(a, b) || Math.abs(cross(a, b, c)) < 1e-10) {
-          ring.splice(i, 1); changed = true; break;
-        }
-      }
-    }
-    if (ring.length < 3) throw new Error('Degenerate polygon ring');
-    return ring;
-  };
-  let offset = 0;
-  const rings = [contour, ...holes].map((path, index) => {
-    const ring = clean(vertices.slice(offset, offset += path.length));
-    if (isClockWise(ring) !== Boolean(index)) ring.reverse();
-    return ring;
-  });
-  const inside = (point, ring) => {
-    let result = false;
-    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
-      const a = ring[i], b = ring[j];
-      if ((a.y > point.y) !== (b.y > point.y) &&
-        point.x < (b.x - a.x) * (point.y - a.y) / (b.y - a.y) + a.x) result = !result;
-    }
-    return result;
-  };
-  const intersects = (a, b, c, d) => {
-    if (equal(a, c) || equal(a, d) || equal(b, c) || equal(b, d)) return false;
-    const abC = cross(a, b, c), abD = cross(a, b, d), cdA = cross(c, d, a), cdB = cross(c, d, b);
-    const on = (p, q, r) => Math.min(p.x, q.x) <= r.x && r.x <= Math.max(p.x, q.x) &&
-      Math.min(p.y, q.y) <= r.y && r.y <= Math.max(p.y, q.y);
-    return abC * abD < 0 && cdA * cdB < 0 ||
-      abC === 0 && on(a, b, c) || abD === 0 && on(a, b, d) ||
-      cdA === 0 && on(c, d, a) || cdB === 0 && on(c, d, b);
-  };
-  let polygon = rings[0].slice();
-  // A bridge must stay inside the outer boundary, outside every hole, and cross no edge.
-  // ponytail: quadratic ear clipping for building footprints; use spatial indexing for large rings.
-  for (const hole of rings.slice(1).sort((a, b) => Math.min(...a.map(p => p.x)) - Math.min(...b.map(p => p.x)))) {
-    let bridge, distance = Infinity;
-    for (let h = 0; h < hole.length; h++) for (let p = 0; p < polygon.length; p++) {
-      const a = hole[h], b = polygon[p], d = (a.x - b.x) ** 2 + (a.y - b.y) ** 2;
-      if (d >= distance) continue;
-      const mid = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
-      if (!inside(mid, rings[0]) || rings.slice(1).some(r => inside(mid, r))) continue;
-      if ([polygon, ...rings.slice(1)].some(r => r.some((c, i) => intersects(a, b, c, r[(i + 1) % r.length])))) continue;
-      bridge = [h, p]; distance = d;
-    }
-    if (!bridge) throw new Error('Unable to connect polygon hole');
-    const [h, p] = bridge;
-    polygon = [...polygon.slice(0, p + 1), ...hole.slice(h), ...hole.slice(0, h + 1),
-    polygon[p], ...polygon.slice(p + 1)];
-  }
-  // Clip a convex corner only when no other vertex is inside/on its triangle.
-  const result = [];
-  while (polygon.length > 3) {
-    let clipped = false;
-    for (let i = 0; i < polygon.length; i++) {
-      const a = polygon[(i + polygon.length - 1) % polygon.length], b = polygon[i], c = polygon[(i + 1) % polygon.length];
-      if (cross(a, b, c) <= 1e-10) continue;
-      if (polygon.some(p => !equal(p, a) && !equal(p, b) && !equal(p, c) &&
-        cross(a, b, p) >= 0 && cross(b, c, p) >= 0 && cross(c, a, p) >= 0)) continue;
-      result.push([a.index, b.index, c.index]); polygon.splice(i, 1); clipped = true; break;
-    }
-    if (!clipped) throw new Error('Unable to triangulate polygon: invalid or self-intersecting rings');
-  }
-  if (cross(...polygon) > 1e-10) result.push(polygon.map(p => p.index));
-  const area = ring => Math.abs(ring.reduce((sum, p, i) => {
-    const q = ring[(i + 1) % ring.length]; return sum + p.x * q.y - q.x * p.y;
-  }, 0)) / 2;
-  // Reject incomplete coverage instead of silently emitting a partial roof.
-  const expected = area(rings[0]) - rings.slice(1).reduce((sum, ring) => sum + area(ring), 0);
-  const actual = result.reduce((sum, triangle) => sum + cross(...triangle.map(i => vertices[i])) / 2, 0);
-  if (expected <= 0 || Math.abs(actual - expected) > Math.max(1e-7, expected * 1e-8)) throw new Error('Polygon triangulation area mismatch');
-  return result;
-}

package/src/utils/tripsAt.js

@@ -1,16 +0,0 @@
-import { vehicleOffsets } from "./vehicleOffsets.js";
-import { scheduledTrips } from "./scheduledTrips.js";
-
-// A lane with a `timetable` runs scheduled trips end to end; one with a `flow` (vehicles/h) loops evenly spaced vehicles.
-
-export 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 }));
-});

package/src/utils/underEntry.js

@@ -1,17 +0,0 @@
-/**
- * Keeps `element` right under `layer`'s entry in the map's layers control while the layer is on the map.
- * Returns false when no layers control lists the layer.
- */
-export function underEntry(layer, element) {
-  const map = layer._map;
-  const place = () => {
-    const input = [...map.getContainer().querySelectorAll('.leaflet-control-layers-selector')].find(input => input.layerId === L.Util.stamp(layer));
-    input?.closest('label').after(element);
-    return Boolean(input);
-  };
-  // Leaflet rebuilds the list after 'layeradd'/'layerremove' (on the layer's own 'add'/'remove'): re-place afterwards.
-  const replace = () => queueMicrotask(() => map.hasLayer(layer) && place());
-  map.on('layeradd layerremove', replace);
-  layer.once('remove', () => { map.off('layeradd layerremove', replace); element.remove(); });
-  return place();
-}

package/src/utils/update.js

@@ -1,18 +0,0 @@
-import { render } from "./render.js";
-
-/** Scene graph, shared camera and frame rendering. */
-/** Content changes: render once on the next animation frame. */
-
-export function update(backend) {
-  const shared = backend._shared;
-  if (!shared) return backend;
-  if (shared !== backend) {
-    update(shared);
-    return backend;
-  }
-  backend._frame ||= requestAnimationFrame(() => {
-    backend._frame = null;
-    if (backend._shared === backend && backend.renderer) render(backend);
-  });
-  return backend;
-}

package/src/utils/updateArea.js

@@ -1,40 +0,0 @@
-import { pump } from "./pump.js";
-import { releaseArea } from "./releaseArea.js";
-
-/** Cover the visible ground bounds and one bordering block, clipped to the archive. */
-
-export function updateArea(backend) {
-  if (!backend._map || !backend._shared) return;
-  if (backend._geojson) {
-    if (!backend._areas.has('geojson')) {
-      backend._areas.set('geojson', { request: new AbortController() });
-    }
-    pump(backend);
-    return;
-  }
-  if (!backend.header) return;
-  const z = backend.header.minZoom;
-  const center = backend._map.project(backend._map.getCenter(), z).divideBy(256).floor();
-  const bounds = backend._map.getBounds();
-  const nw = backend._map.project(bounds.getNorthWest(), z).divideBy(256).floor();
-  const se = backend._map.project(bounds.getSouthEast(), z).divideBy(256).floor();
-  const archiveNW = backend._map.project([backend.header.maxLat, backend.header.minLon], z).divideBy(256).floor();
-  const archiveSE = backend._map.project([backend.header.minLat, backend.header.maxLon], z).divideBy(256).floor();
-  const wanted = new Map();
-  for (let x = Math.max(0, nw.x - 1, archiveNW.x); x <= Math.min(2 ** z - 1, se.x + 1, archiveSE.x); x++) {
-    for (let y = Math.max(0, nw.y - 1, archiveNW.y); y <= Math.min(2 ** z - 1, se.y + 1, archiveSE.y); y++) {
-      wanted.set(`${x}/${y}`, { z, x, y });
-    }
-  }
-  for (const [key, area] of backend._areas) {
-    if (!wanted.has(key)) {
-      releaseArea(backend, area);
-      backend._areas.delete(key);
-    }
-  }
-  // Load the nearest new blocks first without rebuilding retained geometry.
-  for (const [key, coords] of [...wanted].sort(([, a], [, b]) => Math.hypot(a.x - center.x, a.y - center.y) - Math.hypot(b.x - center.x, b.y - center.y))) {
-    if (!backend._areas.has(key)) backend._areas.set(key, { coords, request: new AbortController() });
-  }
-  pump(backend);
-}

package/src/utils/updateCamera.js

@@ -1,32 +0,0 @@
-/** Orthonormal view basis plus perspective matrices, refreshed before projecting/drawing. */
-
-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]];
-
-export function updateCamera(camera) {
-  const z = camera.position.map((v, i) => v - camera.target[i]);
-  const zLength = Math.hypot(...z) || 1;
-  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/updatePointLights.js

@@ -1,38 +0,0 @@
-import { lightGrid } from './lightGrid.js';
-import { traverse } from './traverse.js';
-import { worldLights } from './worldLights.js';
-import { destroyTexture } from './destroyTexture.js';
-import { bindSunlight } from './bindSunlight.js';
-
-/** A cached spatial grid limits fragment lighting to nearby lamps, without dropping dense cells. */
-
-export function updatePointLights(backend) {
-  const { device, sunlight: sun } = backend.renderer;
-  const meshes = [];
-  for (const layer of backend._layers) {
-    if (!layer.options.nightLight || !layer.root.visible) continue;
-    traverse(layer.root, mesh => {
-      if (!mesh.visible) return true;
-      if (mesh.extras?.lights) meshes.push(mesh);
-    });
-  }
-  if (sun.lightMeshes?.length === meshes.length && meshes.every((mesh, i) => sun.lightMeshes[i].mesh === mesh &&
-    sun.lightMeshes[i].lights === mesh.extras.lights && mesh.worldMatrix.every((v, j) => v === sun.lightMeshes[i].matrix[j]))) return;
-  // Per mesh, world-space [x, y, z, radius, r, g, b, intensity] per light: re-packed only when its lights or matrix change.
-  const packed = meshes.map(mesh => {
-    const cache = mesh._worldLights, m = mesh.worldMatrix, lights = mesh.extras.lights;
-    if (cache?.lights === lights && m.every((v, j) => v === cache.matrix[j])) return cache.data;
-    const values = worldLights(lights, m);
-    mesh._worldLights = { lights, matrix: [...m], data: values };
-    return values;
-  });
-  const { data, count } = lightGrid(packed, device.limits.maxStorageBufferBindingSize);
-  if (sun.lights.size < data.byteLength) {
-    destroyTexture(backend, sun.lights);
-    sun.lights = device.createBuffer({ size: data.byteLength, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
-    bindSunlight(backend);
-  }
-  device.queue.writeBuffer(sun.lights, 0, data);
-  sun.lightCount = count;
-  sun.lightMeshes = meshes.map(mesh => ({ mesh, lights: mesh.extras.lights, matrix: [...mesh.worldMatrix] }));
-}

package/src/utils/updateWorldMatrix.js

@@ -1,47 +0,0 @@
-/** 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);
-}

package/src/utils/vehicleOffsets.js

@@ -1,8 +0,0 @@
-import { speed } from "./speed.js";
-
-/** Evenly spaced starting offsets (metres) for `flow` vehicles/h moving at `velocity` m/s on a `length` metres lane. */
-
-export function vehicleOffsets(length, flow, velocity = speed) {
-  const count = Math.round(length * flow / 3600 / velocity);
-  return Array.from({ length: count }, (_, i) => (i + 0.5) * length / count);
-}

package/src/utils/vehicles.js

@@ -1,65 +0,0 @@
-import { hull } from "./hull.js";
-import { box } from './box.js';
-import { glass, tyre } from './glass.js';
-import { mirror } from './mirror.js';
-import { white } from "./white.js";
-import { paints } from './paints.js';
-import { headlight } from './headlight.js';
-import { taillight } from './taillight.js';
-
-/**
- * `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: 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],
-      ];
-    },
-    lights: [{
-      position: [0, 1.2, -6],
-      radius: 10,
-      color: [1, 0.94, 0.82],
-      flux: 800
-    }]
-  },
-  // Panoramic river cruiser, about 60 × 11 m: glass saloon, open upper deck with benches, wheelhouse forward.
-  boat: {
-    side: 0,
-    model: () => [
-      [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]],
-    ],
-    lights: [{
-      position: [0, 8, 4],
-      radius: 30,
-      color: [1, 0.8, 0.55],
-      flux: 20000
-    }]
-  },
-};

package/src/utils/vertexNormals.js

@@ -1,30 +0,0 @@
-/** Area-weighted vertex normals, for indexed or non-indexed triangles. */
-
-export function vertexNormals(p, indices) {
-  // Accumulate area-weighted face normals for shared vertices, then normalize.
-  const normals = new Float32Array(p.length);
-  for (let i = 0; i < (indices?.length || p.length / 3); i += 3) {
-    const a = indices ? indices[i] : i,
-          b = indices ? indices[i + 1] : i + 1,
-          c = indices ? indices[i + 2] : i + 2;
-    const u = [0, 1, 2].map(j => p[b * 3 + j] - p[a * 3 + j]),
-          v = [0, 1, 2].map(j => p[c * 3 + j] - p[a * 3 + j]);
-    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]
-    ];
-    for (const index of [a, b, c]) {
-      for (let j = 0; j < 3; j++) {
-        normals[index * 3 + j] += n[j];
-      }
-    }
-  }
-  for (let i = 0; i < normals.length; i += 3) {
-    const length = Math.hypot(...normals.subarray(i, i + 3)) || 1;
-    for (let j = 0; j < 3; j++) {
-      normals[i + j] /= length;
-    }
-  }
-  return normals;
-}

package/src/utils/walk.js

@@ -1,187 +0,0 @@
-import * as createMesh from './createMesh.js';
-import * as disposeMesh from './disposeMesh.js';
-import * as update from './update.js';
-import { build } from './build.js';
-import { getElevation } from './getElevation.js';
-import { hit } from './hit.js';
-import { limbs } from './limbs.js';
-import { moves } from './moves.js';
-import { parts } from './parts.js';
-import { wrap } from './wrap.js';
-
-export function local() {
-  const { layer, state } = this;
-  const map = layer._map, crs = map.options.crs, origin = crs.project(layer.location);
-  const metres = Math.cos(layer.location.lat * Math.PI / 180);
-  const p = crs.project(state.latlng), terrain = map._terrain3D?._terrainReady && map._terrain3D;
-  const ground = (terrain && getElevation(terrain, state.latlng)) || 0;
-  return [(p.x - origin.x) * metres, ground - layer.root.position[1], -(p.y - origin.y) * metres];
-}
-
-export function place() {
-  const [x, y, z] = local.call(this);
-  // Model forward is -z; a yaw of -heading turns it to the compass heading (x east, -z north).
-  const yaw = -this.state.heading, cos = Math.cos(yaw), sin = Math.sin(yaw);
-  for (let i = 0; i < limbs.length; i++) {
-    const [, px, py, sign] = limbs[i];
-    const mesh = this.meshes[i];
-    mesh.position[0] = x + px * cos; mesh.position[1] = y + py; mesh.position[2] = z - px * sin;
-    mesh.rotation[0] = sign * this.swing * Math.sin(this.state.phase);
-    mesh.rotation[1] = yaw;
-  }
-  update.update(this.layer);
-}
-
-export function blocked(east, north, feet) {
-  const length = Math.hypot(east, north);
-  return length > 1e-6 && hit(this.layer, feet[0], feet[1], feet[2], east / length, -north / length, length + 0.3);
-}
-
-export function step(now) {
-  const layer = this.layer, map = layer._map;
-  this.frame = requestAnimationFrame(this.step);
-  const dt = Math.min(0.1, (now - (this.last ?? now)) / 1000);
-  this.last = now;
-  if (!layer.renderer) return;
-  let changed = false;
-  if (!this.meshes) {
-    this.meshes = [];
-    for (const [part] of limbs) this.meshes.push(createMesh.createMesh(layer, build(parts[part])));
-    changed = true;
-  }
-  let forward = 0, turn = 0;
-  for (const key of this.keys) { forward += moves[key]?.[0] || 0; turn += moves[key]?.[1] || 0; }
-  forward = Math.sign(forward); turn = Math.sign(turn);
-  if (turn) { this.state.heading = wrap(this.state.heading + turn * 2.5 * dt); changed = true; }
-  if (forward) {
-    const metres = forward * this.speed * dt, { lat, lng } = this.state.latlng, { position, scale } = layer.root;
-    let east = Math.sin(this.state.heading) * metres, north = Math.cos(this.state.heading) * metres;
-    const feet = local.call(this);
-    for (let i = 0; i < feet.length; i++) feet[i] = position[i] + scale[i] * feet[i];
-    // World x is east, z south; keep 0.3 m from walls and slide along the one in the way.
-    const wall = blocked.call(this, east, north, feet);
-    if (wall) {
-      const into = east * wall[0] - north * wall[1];
-      east -= into * wall[0]; north += into * wall[1];
-      if (blocked.call(this, east, north, feet)) east = north = 0;
-    }
-    this.state.latlng = new L.LatLng(lat + north / 111320, lng + east / (111320 * Math.cos(lat * Math.PI / 180)));
-    this.state.phase += Math.hypot(east, north) / 1.6 * Math.PI;
-    changed = true;
-  }
-  if (forward || turn) {
-    // The camera (looking along -bearing) swings back behind the walker.
-    const bearing = map.getBearing() * Math.PI / 180, behind = wrap(-this.state.heading - bearing);
-    if (Math.abs(behind) > 1e-3) map._setPitchAndBearing(map.getPitch(), (bearing + behind * Math.min(1, dt * 4)) * 180 / Math.PI);
-    map.setView(this.state.latlng, map.getZoom(), { animate: false });
-  }
-  const target = forward ? 0.9 : 0;
-  if (Math.abs(this.swing - target) > 1e-3) { this.swing += (target - this.swing) * Math.min(1, dt * 10); changed = true; }
-  if (changed) place.call(this);
-}
-
-export function onKey(event) {
-  // Text fields and sliders keep their keys; buttons and checkboxes don't.
-  if (event.target.closest?.('input:not([type=checkbox], [type=radio]), select, textarea, [contenteditable]') ||
-    event.ctrlKey || event.altKey || event.metaKey) return;
-  if (event.type === 'keydown' && event.code === 'Escape') { this.stop(); return; }
-  if (!moves[event.code]) return;
-  event.preventDefault();
-  if (event.type === 'keydown') this.keys.add(event.code); else this.keys.delete(event.code);
-}
-
-export function onBlur() {
-  this.keys.clear();
-}
-
-export function onPointer(event) {
-  // Dragging only turns the camera around the walker: horizontal = bearing, vertical = pitch.
-  const map = this.layer._map;
-  if (event.type === 'pointerdown') {
-    if (event.button !== 0 || event.target.closest('.leaflet-control')) return;
-    this.drag = { x: event.clientX, y: event.clientY };
-    map.getContainer().setPointerCapture(event.pointerId);
-  } else if (this.drag && event.type === 'pointermove') {
-    map._setPitchAndBearing(Math.max(20, Math.min(85, map.getPitch() - (event.clientY - this.drag.y) * 0.2)),
-      map.getBearing() - (event.clientX - this.drag.x) * 0.25);
-    this.drag = { x: event.clientX, y: event.clientY };
-  } else this.drag = null;
-}
-
-export function onTerrain() {
-  if (this.meshes) place.call(this);
-}
-
-export function start() {
-  const map = this.layer._map;
-  if (this.saved || !map) return;
-  this.state.latlng = map.getCenter();
-  // Zoom whose camera distance (1.5 viewport heights, as in scene/render.js) is about `distance` metres behind the walker.
-  const pixelsPerMetre = map.getSize().y * 1.5 / this.distance;
-  const zoom = Math.min(map.getMaxZoom(), Math.log2(pixelsPerMetre * 40075016.68557849 * Math.cos(this.state.latlng.lat * Math.PI / 180) / 256));
-  const handlers = [];
-  for (const name of ['dragging', 'keyboard', 'doubleClickZoom', 'boxZoom']) {
-    if (map[name]?.enabled()) handlers.push(name);
-  }
-  this.saved = {
-    zoom: map.getZoom(), pitch: map.getPitch(), scrollWheelZoom: map.options.scrollWheelZoom, handlers
-  };
-  for (const name of this.saved.handlers) map[name].disable();
-  // Wheel zoom moves the camera closer or farther, keeping the walker centred.
-  map.options.scrollWheelZoom = this.saved.scrollWheelZoom && 'center';
-  this.state.heading = -map.getBearing() * Math.PI / 180;
-  map.setView(this.state.latlng, zoom, { animate: false });
-  map.setPitch(75);
-  L.DomEvent.on(document, 'keydown keyup', this.onKey);
-  L.DomEvent.on(window, 'blur', this.onBlur);
-  L.DomEvent.on(map.getContainer(), 'pointerdown pointermove pointerup pointercancel', this.onPointer);
-  map.on('terrainchange', this.onTerrain);
-  this.button.setAttribute('aria-pressed', 'true');
-  this.button.style.background = '#e4e4e4';
-  this.hint.style.display = '';
-  this.last = undefined;
-  this.frame = requestAnimationFrame(this.step);
-}
-
-export function stop() {
-  const map = this.layer._map;
-  cancelAnimationFrame(this.frame);
-  this.keys.clear(); this.drag = null;
-  L.DomEvent.off(document, 'keydown keyup', this.onKey);
-  L.DomEvent.off(window, 'blur', this.onBlur);
-  for (const mesh of this.meshes || []) disposeMesh.disposeMesh(this.layer, mesh);
-  this.meshes = null;
-  this.button.setAttribute('aria-pressed', 'false');
-  this.button.style.background = '#fff';
-  this.hint.style.display = 'none';
-  if (!map || !this.saved) return;
-  L.DomEvent.off(map.getContainer(), 'pointerdown pointermove pointerup pointercancel', this.onPointer);
-  map.off('terrainchange', this.onTerrain);
-  map.options.scrollWheelZoom = this.saved.scrollWheelZoom;
-  for (const name of this.saved.handlers) map[name].enable();
-  map.setView(this.state.latlng, this.saved.zoom, { animate: false });
-  map.setPitch(this.saved.pitch);
-  this.saved = null;
-}
-
-export function toggle() {
-  if (this.saved) stop.call(this); else start.call(this);
-}
-
-export function controlOnAdd() {
-  return this.container;
-}
-
-export function onReady() {
-  this.ready = true;
-  if (this.layer._map) this.control.addTo(this.layer._map);
-}
-
-export function onLayerAdd() {
-  if (this.ready) this.control.addTo(this.layer._map);
-}
-
-export function onLayerRemove() {
-  stop.call(this);
-  this.control.remove();
-}

package/src/utils/worldLights.js

@@ -1,25 +0,0 @@
-
-/** World-space [x, y, z, radius, r, g, b, intensity] for one mesh's point lights. */
-export function worldLights(lights, m) {
-  const values = new Float32Array(lights.length * 8);
-  lights.forEach(({
-    position: [x, y, z],
-    radius,
-    color,
-    flux
-  }, i) => {
-    const w = m[3] * x + m[7] * y + m[11] * z + m[15];
-    values.set(
-      [
-        (m[0] * x + m[4] * y + m[8] * z + m[12]) / w,
-        (m[1] * x + m[5] * y + m[9] * z + m[13]) / w,
-       (m[2] * x + m[6] * y + m[10] * z + m[14]) / w,
-       radius,
-       ...color,
-       flux / (4 * Math.PI) * 0.03
-      ],
-       i * 8
-    );
-  });
-  return values;
-}