leaflet-city-mapper 0.0.1 → 0.0.3

package/src/camera/mapLimitOffset.js

@@ -0,0 +1,10 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+import { project } from './project.js';
+
+export function mapLimitOffset(offset, bounds) {
+  if (!bounds || !this.getPitch() && !this.getBearing()) return mapCameraState.mapMethods._limitOffset.call(this, offset, bounds);
+  const half = this.getSize().divideBy(2), ground = half.subtract(project(this, half.subtract(offset), true));
+  const center = this.project(this.getCenter());
+  const limited = this.project(this._limitCenter(this.unproject(center.add(ground)), this.getZoom(), bounds));
+  return half.subtract(project(this, half.subtract(limited.subtract(center))));
+}

package/src/camera/mapPanBy.js

@@ -0,0 +1,9 @@
+import { project } from './project.js';
+import { pointOf } from './pointOf.js';
+import { mapCameraState } from '../constants/mapCameraState.js';
+
+export function mapPanBy(offset, options) {
+  const half = this.getSize().divideBy(2);
+  const ground = half.subtract(project(this, half.subtract(pointOf(offset)), true));
+  return mapCameraState.mapMethods.panBy.call(this, ground, options);
+}

package/src/camera/mapPanInside.js

@@ -0,0 +1,14 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+import { pointOf } from './pointOf.js';
+
+export function mapPanInside(latlng, options = {}) {
+  if (!this.getPitch() && !this.getBearing()) return mapCameraState.mapMethods.panInside.call(this, latlng, options);
+  const min = pointOf(options.paddingTopLeft || options.padding || [0, 0]);
+  const max = this.getSize().subtract(pointOf(options.paddingBottomRight || options.padding || [0, 0]));
+  const screen = this.latLngToContainerPoint(latlng);
+  const safe = new L.Point(Math.max(min.x, Math.min(max.x, screen.x)),
+    Math.max(min.y, Math.min(max.y, screen.y)));
+  if (safe.equals(screen)) return this;
+  const delta = this.latLngToLayerPoint(latlng).subtract(this.containerPointToLayerPoint(safe));
+  return this.panTo(this.unproject(this.project(this.getCenter()).add(delta)), options);
+}

package/src/camera/mapResetNorth.js

@@ -0,0 +1 @@
+export function mapResetNorth(options = { animate: true }) { return this.setBearing(0, options); }

package/src/camera/mapResetNorthPitch.js

@@ -0,0 +1 @@
+export function mapResetNorthPitch(options = { animate: true }) { return this._animateCamera(0, 0, options); }

package/src/camera/mapSetBearing.js

@@ -0,0 +1 @@
+export function mapSetBearing(bearing, options) { return this._animateCamera(this.getPitch(), bearing, options); }

package/src/camera/mapSetPitch.js

@@ -0,0 +1 @@
+export function mapSetPitch(pitch, options) { return this._animateCamera(pitch, this.getBearing(), options); }

package/src/camera/mapSetPitchAndBearing.js

@@ -0,0 +1,14 @@
+import { updateSky } from './updateSky.js';
+
+export function mapSetPitchAndBearing(pitch, bearing) {
+  if (!Number.isFinite(pitch) || !Number.isFinite(bearing)) throw new TypeError('Camera angles must be finite numbers');
+  const previousPitch = this.getPitch(), previousBearing = this.getBearing();
+  this._cameraPitch = Math.max(0, Math.min(85, pitch));
+  this._cameraBearing = ((bearing % 360) + 360) % 360;
+  if (this._loaded) {
+    updateSky.call(this);
+    if (previousBearing !== this.getBearing()) this.fire('rotate', { bearing: this.getBearing() });
+    if (previousPitch !== this.getPitch()) this.fire('pitch', { pitch: this.getPitch() });
+  }
+  return this;
+}

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/horizontalRay.js

@@ -0,0 +1,12 @@
+// Möller-Trumbore for the horizontal ray (ox, oy, oz) + d·(dx, 0, dz) against triangle t; returns d or -1.
+export function horizontalRay(v, t, ox, oy, oz, dx, dz) {
+  const i = t * 9, ex = v[i + 3] - v[i], ey = v[i + 4] - v[i + 1], ez = v[i + 5] - v[i + 2];
+  const fx = v[i + 6] - v[i], fy = v[i + 7] - v[i + 1], fz = v[i + 8] - v[i + 2];
+  const px = -dz * fy, py = dz * fx - dx * fz, pz = dx * fy, det = ex * px + ey * py + ez * pz;
+  if (Math.abs(det) < 1e-9) return -1;
+  const tx = ox - v[i], ty = oy - v[i + 1], tz = oz - v[i + 2], u = (tx * px + ty * py + tz * pz) / det;
+  if (u < 0 || u > 1) return -1;
+  const qx = ty * ez - tz * ey, qy = tz * ex - tx * ez, qz = tx * ey - ty * ex, w = (dx * qx + dz * qz) / det;
+  if (w < 0 || u + w > 1) return -1;
+  return (fx * qx + fy * qy + fz * qz) / det;
+}

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/CELL.js

@@ -0,0 +1,4 @@
+// Walls (non-horizontal triangles) of a mesh in world space, bucketed by 8 m cells; `origin` is the world translation
+// at build time, since layer roots only move vertically with the terrain afterwards.
+
+export const CELL = 8;

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/accessorSizes.js

@@ -0,0 +1 @@
+export const sizes = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4 };

package/src/constants/accessorTypes.js

@@ -0,0 +1,8 @@
+export const types = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array,
+};

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/colliders.js

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

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/headlight.js

@@ -0,0 +1 @@
+export const headlight = [1.9, 1.85, 1.7];

package/src/constants/hull.js

@@ -0,0 +1 @@
+export const hull = [[-5.5, 30], [5.5, 30], [5.5, -20], [4, -26], [1.5, -30], [-1.5, -30], [-4, -26], [-5.5, -20]];

package/src/constants/indexState.js

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

package/src/constants/limbs.js

@@ -0,0 +1,9 @@
+// [part, pivot x, pivot y, swing sign]
+
+export const limbs = [
+  ['body', 0, 0, 0],
+  ['leg', -0.09, 0.9, 1],
+  ['leg', 0.09, 0.9, -1],
+  ['arm', -0.25, 1.42, -1],
+  ['arm', 0.25, 1.42, 1]
+];

package/src/constants/mapCameraState.js

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

package/src/constants/moves.js

@@ -0,0 +1,11 @@
+// W/S (↑/↓) run forward/back along the heading, A/D (←/→) turn: [forward, turn].
+export const moves = {
+  KeyW: [1, 0],
+  ArrowUp: [1, 0],
+  KeyS: [-1, 0],
+  ArrowDown: [-1, 0],
+  KeyD: [0, 1],
+  ArrowRight: [0, 1],
+  KeyA: [0, -1],
+  ArrowLeft: [0, -1]
+};

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 = {};