leaflet-city-mapper 0.0.3 → 0.0.5

package/src/shadows/shadowBounds.js

@@ -1,32 +0,0 @@
-import { computeBounds } from '../geometry/computeBounds.js';
-
-export function shadowBounds(meshes) {
-  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
-  let mesh, bounds, matrix, cached, i, x, y, z, w, axis, value;
-  for (mesh of meshes) {
-    if (!mesh.geometry.bounds || mesh.geometry.attributes.position.needsUpdate) computeBounds(mesh.geometry);
-    bounds = mesh.geometry.bounds, matrix = mesh.worldMatrix;
-    cached = mesh._shadowBounds;
-    if (!cached || cached.version !== mesh._worldMatrixVersion || cached.bounds !== bounds) {
-      cached = mesh._shadowBounds = { version: mesh._worldMatrixVersion, bounds,
-        min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity] };
-      for (i = 0; i < 8; i++) {
-        x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
-        z = i & 4 ? bounds.max[2] : bounds.min[2];
-        w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
-        for (axis = 0; axis < 3; axis++) {
-          value = (matrix[axis] * x + matrix[axis + 4] * y + matrix[axis + 8] * z + matrix[axis + 12]) / w;
-          cached.min[axis] = Math.min(cached.min[axis], value);
-          cached.max[axis] = Math.max(cached.max[axis], value);
-        }
-      }
-    }
-    for (axis = 0; axis < 3; axis++) {
-      min[axis] = Math.min(min[axis], cached.min[axis]);
-      max[axis] = Math.max(max[axis], cached.max[axis]);
-    }
-  }
-  // Include ground receivers below/around the loaded buildings and trees.
-  min[1] = Math.min(0, min[1]);
-  return { min, max };
-}

package/src/sources/addGeneratedTriangle.js

@@ -1,6 +0,0 @@
-import { addTriangle } from './addTriangle.js';
-import { pumpState } from '../constants/pumpState.js';
-
-export function addGeneratedTriangle(...args) {
-  addTriangle(pumpState.triangleContexts[pumpState.triangleContexts.length - 1], ...args);
-}

package/src/sources/projectRing.js

@@ -1,20 +0,0 @@
-import { getElevation } from '../terrain/getElevation.js';
-
-export function projectRing(context, ring) {
-  const { backend, crs, origin, metres, map } = context;
-  if (ring.length < 4) throw new Error('Invalid GeoJSON polygon ring');
-  const path = [];
-  let lng, lat, point, elevation;
-  for ([lng, lat] of ring.slice(0, -1)) {
-    if (!Number.isFinite(lng) || !Number.isFinite(lat)) throw new Error('Invalid GeoJSON coordinates');
-    point = crs.project(new L.LatLng(lat, lng));
-    elevation = map._terrain3D ? getElevation(map._terrain3D, [lat, lng]) : undefined;
-    path.push({
-      x: (point.x - origin.x) * metres,
-      y: (point.y - origin.y) * metres,
-      ground: Number.isFinite(elevation) && Number.isFinite(backend.root.position[1])
-        ? elevation - backend.root.position[1] : 0,
-    });
-  }
-  return path;
-}

package/src/sources/projectedTree.js

@@ -1,13 +0,0 @@
-import { getElevation } from '../terrain/getElevation.js';
-
-export function projectedTree(context, lon, lat) {
-  const { backend, crs, origin, metres, map } = context;
-  const point = crs.project(new L.LatLng(lat, lon));
-  const elevation = map._terrain3D ? getElevation(map._terrain3D, [lat, lon]) : undefined;
-  return {
-    x: (point.x - origin.x) * metres,
-    y: (point.y - origin.y) * metres,
-    ground: Number.isFinite(elevation) && Number.isFinite(backend.root.position[1])
-      ? elevation - backend.root.position[1] : 0,
-  };
-}

package/src/sources/pump.js

@@ -1,54 +0,0 @@
-import { cityMapper } from '../constants/cityMapper.js';
-import { emptyNode } from "../scene/emptyNode.js";
-import { isClockWise } from "../triangulation/isClockWise.js";
-import { lampPostGeometry } from "../geometry/lampPostGeometry.js";
-import { lightGeometry } from "../geometry/lightGeometry.js";
-import { parseColor } from "../utils/parseColor.js";
-import { treeGeometry } from "../geometry/treeGeometry.js";
-import { triangulate } from "../triangulation/triangulate.js";
-import { createProgram } from '../rendering/createProgram.js';
-import { updateStatus } from './updateStatus.js';
-import { loadSource } from '../archives/loadSource.js';
-import { setParent } from '../scene/setParent.js';
-import { update } from '../scene/update.js';
-import { getElevation } from "../terrain/getElevation.js";
-import { pumpState } from '../constants/pumpState.js';
-import { compareDistance } from '../utils/compareDistance.js';
-import { buildArea } from './buildArea.js';
-
-pumpState.triangleContexts = [];
-
-/** Share four load/build slots across source layers, nearest ground blocks first. */
-export function pump(backend, map = backend._map) {
-  const shared = map && cityMapper.renderers.get(map);
-  if (!shared) return;
-  const layers = [];
-  let layer, area, center, areaBackend;
-  for (layer of shared._layers) {
-    if (Number.isFinite(layer._inflight) && layer._areas && (layer.url || layer._geojson)) layers.push(layer);
-  }
-  const pending = [];
-  for (layer of layers) {
-    for (area of layer._areas.values()) {
-      if (area.started || area.request.signal.aborted) continue;
-      center = area.coords && map.project(map.getCenter(), area.coords.z).divideBy(256);
-      pending.push({
-        layer, area,
-        distance: center
-          ? Math.hypot(area.coords.x + 0.5 - center.x, area.coords.y + 0.5 - center.y) / 2 ** area.coords.z : 0,
-      });
-    }
-  }
-  pending.sort(compareDistance);
-  let inflight = 0;
-  for (layer of layers) inflight += layer._inflight;
-  for ({ layer: areaBackend, area } of pending) {
-    if (inflight >= 4) break;
-    if (areaBackend._inflight >= 2) continue;
-    area.started = true;
-    areaBackend._inflight++;
-    inflight++;
-    buildArea(areaBackend, area, map);
-  }
-  for (layer of layers) updateStatus(layer);
-}

package/src/sources/updateStatus.js

@@ -1,12 +0,0 @@
-/** Emit a snapshot for consumers; ready does not wait for all neighborhood tasks. */
-export function updateStatus(backend, enabled = true) {
-  const progress = { enabled, loaded: 0, skipped: 0, pending: 0, errors: [] };
-  let area;
-  for (area of backend._areas.values()) {
-    if (area.error) progress.errors.push(area.error);
-    else if (!area.done) progress.pending++;
-    progress.loaded += area.buildings ?? 0;
-    progress.skipped += area.skipped ?? 0;
-  }
-  backend.fire('progress', progress);
-}

package/src/sunlight/horizontalPosition.js

@@ -1,16 +0,0 @@
-
-export function horizontalPosition(d, lat, lng, ascension, declination) {
-  const rad = Math.PI / 180;
-  const hourAngle = (280.16 + 360.9856235 * d + lng) * rad - ascension;
-  const latitude = lat * rad;
-  const altitude = Math.asin(Math.sin(latitude) * Math.sin(declination) +
-    Math.cos(latitude) * Math.cos(declination) * Math.cos(hourAngle));
-  const southAzimuth = Math.atan2(Math.sin(hourAngle),
-    Math.cos(hourAngle) * Math.sin(latitude) - Math.tan(declination) * Math.cos(latitude));
-  const azimuth = (southAzimuth / rad + 180 + 360) % 360;
-  return {
-    altitude: altitude / rad, azimuth,
-    direction: [Math.sin(azimuth * rad) * Math.cos(altitude), Math.sin(altitude),
-    -Math.cos(azimuth * rad) * Math.cos(altitude)]
-  };
-}

package/src/sunlight/initialize.js

@@ -1,11 +0,0 @@
-import { addTimeLayer } from './addTimeLayer.js';
-import { removeTimeLayer } from './removeTimeLayer.js';
-
-export function initialize(options) {
-  L.Util.setOptions(this, options);
-  this.live = true;
-  this.layer = new L.Layer();
-  this.layer.control = this;
-  this.layer.onAdd = addTimeLayer;
-  this.layer.onRemove = removeTimeLayer;
-}

package/src/sunlight/mix.js

@@ -1,6 +0,0 @@
-export function mix(a, b, t) {
-  const values = [];
-  let i;
-  for (i = 0; i < a.length; i++) values.push(a[i] + (b[i] - a[i]) * t);
-  return values;
-}

package/src/sunlight/moonPosition.js

@@ -1,17 +0,0 @@
-import { solarPosition } from "./solarPosition.js";
-import { horizontalPosition } from "./horizontalPosition.js";
-
-// Low-precision geocentric lunar orbit; no parallax or atmospheric refraction.
-
-export function moonPosition(date, lat, lng) {
-  solarPosition(date, lat, lng);
-  const rad = Math.PI / 180, d = new Date(date).getTime() / 86400000 - 10957.5;
-  const anomaly = (134.963 + 13.064993 * d) * rad;
-  const longitude = (218.316 + 13.176396 * d + 6.289 * Math.sin(anomaly)) * rad;
-  const latitude = 5.128 * Math.sin((93.272 + 13.229350 * d) * rad) * rad;
-  const obliquity = 23.4397 * rad;
-  const x = Math.cos(latitude) * Math.cos(longitude);
-  const y = Math.cos(latitude) * Math.sin(longitude) * Math.cos(obliquity) - Math.sin(latitude) * Math.sin(obliquity);
-  const z = Math.cos(latitude) * Math.sin(longitude) * Math.sin(obliquity) + Math.sin(latitude) * Math.cos(obliquity);
-  return horizontalPosition(d, lat, lng, Math.atan2(y, x), Math.asin(z));
-}

package/src/sunlight/projectCelestialBody.js

@@ -1,13 +0,0 @@
-/** Perspective projection of a celestial direction; null when behind the camera. */
-
-export function projectCelestialBody(dir, size, pitch, bearing) {
-  const [x, y, z] = dir;
-  const forward = -x * Math.sin(bearing) * Math.sin(pitch) - y * Math.cos(pitch) - z * Math.cos(bearing) * Math.sin(pitch);
-  if (forward > 0) {
-    return {
-      left: size.x / 2 + size.y * 1.5 * (x * Math.cos(bearing) - z * Math.sin(bearing)) / forward,
-      top:  size.y / 2 - size.y * 1.5 * (-x * Math.sin(bearing) * Math.cos(pitch) + y * Math.sin(pitch) - z * Math.cos(bearing) * Math.cos(pitch)) / forward
-    };
-  }
-  return null;
-}

package/src/sunlight/render.js

@@ -1,7 +0,0 @@
-import { cityMapper } from '../constants/cityMapper.js';
-import { update as updateScene } from '../scene/update.js';
-
-export function render(map) {
-  const renderer = cityMapper.renderers.get(map);
-  if (renderer) updateScene(renderer);
-}

package/src/sunlight/rgb.js

@@ -1,6 +0,0 @@
-export function rgb(values) {
-  const rounded = [];
-  let value;
-  for (value of values) rounded.push(Math.round(value));
-  return `rgb(${rounded.join(', ')})`;
-}

package/src/sunlight/solarPosition.js

@@ -1,17 +0,0 @@
-import { horizontalPosition } from "./horizontalPosition.js";
-
-// Solar centre, without atmospheric refraction.
-
-export function solarPosition(date, lat, lng) {
-  const time = new Date(date).getTime();
-  if (!Number.isFinite(time) || !Number.isFinite(lat) || Math.abs(lat) > 90 ||
-    !Number.isFinite(lng) || Math.abs(lng) > 180) throw new Error('Invalid solar date or location');
-  const rad = Math.PI / 180, d = time / 86400000 - 10957.5;
-  const mean = (357.5291 + 0.98560028 * d) * rad;
-  const longitude = mean + (1.9148 * Math.sin(mean) + 0.02 * Math.sin(2 * mean) +
-    0.0003 * Math.sin(3 * mean) + 102.9372 + 180) * rad;
-  const obliquity = 23.4397 * rad;
-  const declination = Math.asin(Math.sin(longitude) * Math.sin(obliquity));
-  const ascension = Math.atan2(Math.sin(longitude) * Math.cos(obliquity), Math.cos(longitude));
-  return horizontalPosition(d, lat, lng, ascension, declination);
-}

package/src/terrain/terrainGrid.js

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

package/src/traffic/routeGeometry.js

@@ -1,31 +0,0 @@
-/** Dashed lane outline, in layer-local metres. */
-
-export function routeGeometry(lanes) {
-  const position = [], normal = [], color = [];
-  let points, lengths, properties, raw, rgb, tint, i, a, b, dx, dz, length, x, z, distance, start, end;
-  let p, q, point;
-  for ({ points, lengths, properties } of lanes) {
-    raw = properties?.route_color;
-    rgb = /^[\da-f]{6}$/i.test(raw) ? Number.parseInt(raw, 16) : null;
-    tint = rgb === null ? [0.08, 0.7, 0.85]
-      : [(rgb >> 16 & 255) / 255, (rgb >> 8 & 255) / 255, (rgb & 255) / 255];
-    for (i = 1; i < points.length; i++) {
-      a = points[i - 1], b = points[i];
-      dx = b[0] - a[0], dz = b[1] - a[1], length = lengths[i] - lengths[i - 1];
-      if (!length) continue;
-      x = -dz / length * 2.5, z = dx / length * 2.5;
-      for (distance = Math.floor(lengths[i - 1] / 30) * 30; distance < lengths[i]; distance += 30) {
-        start = Math.max(0, (distance - lengths[i - 1]) / length);
-        end = Math.min(1, (distance + 18 - lengths[i - 1]) / length);
-        if (end <= start) continue;
-        p = [a[0] + dx * start, a[1] + dz * start, a[2] + (b[2] - a[2]) * start + 0.4];
-        q = [a[0] + dx * end, a[1] + dz * end, a[2] + (b[2] - a[2]) * end + 0.4];
-        for (point of [[p[0] - x, p[2], p[1] - z], [p[0] + x, p[2], p[1] + z], [q[0] + x, q[2], q[1] + z],
-        [p[0] - x, p[2], p[1] - z], [q[0] + x, q[2], q[1] + z], [q[0] - x, q[2], q[1] - z]]) {
-          position.push(...point); normal.push(0, 1, 0); color.push(...tint);
-        }
-      }
-    }
-  }
-  return { position, normal, color };
-}

package/src/traffic/toLanes.js

@@ -1,16 +0,0 @@
-// GeoJSON (Multi)LineStrings become lanes ({latlngs, properties, elevation?}); prepare() adds `points` ([x, z, ground]),
-// `lengths` and `length` in layer-local metres.
-
-export function toLanes({ features = [] }) {
-  const lanes = [];
-  let geometry, properties, lines, line, latlngs, lng, lat;
-  for ({ geometry, properties } of features) {
-    lines = geometry?.type === 'LineString' ? [geometry.coordinates] : geometry?.type === 'MultiLineString' ? geometry.coordinates : [];
-    for (line of lines) {
-      latlngs = [];
-      for ([lng, lat] of line) latlngs.push([lat, lng]);
-      lanes.push({ latlngs, properties: properties ?? {}, elevation: properties?.elevation });
-    }
-  }
-  return lanes;
-}

package/src/traffic/tooltip.js

@@ -1,11 +0,0 @@
-export function tooltip({ properties: p }) {
-  const content = document.createElement('div');
-  content.style.whiteSpace = 'pre-line';
-  const lines = [];
-  let line;
-  for (line of [p.name, p.departure && `Departure ${p.departure} ${p.timetable.timeZone}`, p.description]) {
-    if (line) lines.push(line);
-  }
-  content.textContent = lines.join('\n');
-  return content;
-}

package/src/vehicles/carriage.js

@@ -1,19 +0,0 @@
-import { box } from '../geometry/box.js';
-import { glass } from '../constants/glass.js';
-import { tyre } from '../constants/tyre.js';
-import { white } from '../constants/white.js';
-import { headlight } from '../constants/headlight.js';
-import { taillight } from '../constants/taillight.js';
-
-export function carriage(center, length, color) {
-  const front = center - length / 2, rear = center + length / 2;
-  return [
-    [box(-1.25, 1.25, front, rear), 0.45, 1.25, color],
-    [box(-1.2, 1.2, front + 0.15, rear - 0.15), 1.25, 2.65, glass],
-    [box(-1.25, 1.25, front, rear), 2.65, 3.1, white],
-    [box(-1.15, -0.85, front + 1, front + 2), 0, 0.7, tyre],
-    [box(0.85, 1.15, rear - 2, rear - 1), 0, 0.7, tyre],
-    [box(-0.9, 0.9, front - 0.03, front), 0.8, 1.05, headlight],
-    [box(-0.9, 0.9, rear, rear + 0.03), 0.8, 1.05, taillight],
-  ];
-}

package/src/vehicles/mirror.js

@@ -1,8 +0,0 @@
-import { box } from "../geometry/box.js";
-
-export function mirror(x0, x1, z0, z1, ...rest) {
-  return [
-    [box(x0, x1, z0, z1), ...rest],
-    [box(-x1, -x0, z0, z1), ...rest]
-  ];
-}

package/src/walk/local.js

@@ -1,10 +0,0 @@
-import { getElevation } from '../terrain/getElevation.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];
-}

package/src/walk/onAdd.js

@@ -1,4 +0,0 @@
-export function onAdd(map) {
-  this._walk.layer.addTo(map);
-  return this._walk.container;
-}

package/src/walk/onPointer.js

@@ -1,13 +0,0 @@
-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;
-}

package/src/walk/onRemove.js

@@ -1,4 +0,0 @@
-export function onRemove() {
-  this._walk.stop();
-  this._walk.layer.remove();
-}

package/src/walk/start.js

@@ -1,37 +0,0 @@
-import { step } from './step.js';
-import { onKey } from './onKey.js';
-import { onBlur } from './onBlur.js';
-import { onPointer } from './onPointer.js';
-import { onTerrain } from './onTerrain.js';
-
-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 = [];
-  let name;
-  for (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 (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);
-}

package/src/walk/step.js

@@ -1,53 +0,0 @@
-import * as createMesh from '../rendering/createMesh.js';
-import { build } from '../geometry/build.js';
-import { limbs } from '../constants/limbs.js';
-import { moves } from '../constants/moves.js';
-import { parts } from '../constants/parts.js';
-import { wrap } from '../utils/wrap.js';
-import { local } from './local.js';
-import { place } from './place.js';
-import { blocked } from './blocked.js';
-
-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;
-  let part, key, i;
-  if (!this.meshes) {
-    this.meshes = [];
-    for ([part] of limbs) this.meshes.push(createMesh.createMesh(layer, build(parts[part])));
-    changed = true;
-  }
-  let forward = 0, turn = 0;
-  for (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 (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);
-}