leaflet-city-mapper 0.0.2 → 0.0.4

package/src/walk/createWalk.js

@@ -0,0 +1,66 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { init3D } from '../scene/init3D.js';
+import { onBlur } from './onBlur.js';
+import { onKey } from './onKey.js';
+import { onPointer } from './onPointer.js';
+import { onTerrain } from './onTerrain.js';
+import { start } from './start.js';
+import { step } from './step.js';
+import { stop } from './stop.js';
+import { toggle } from './toggle.js';
+
+export function createWalk(control, {
+  speed,
+  distance,
+  ...options
+}) {
+  const layer = /* alloc */ new L.Layer();
+  sceneByLayer.get(layer)._type = 'walk';
+  init3D(layer, options);
+  const keys = /* alloc */ new Set();
+  const container = L.DomUtil.create('div', 'leaflet-bar leaflet-control');
+  container.style.cssText = 'display:flex;align-items:center;background:#fff;';
+  const button = L.DomUtil.create('button', '', container);
+  button.type = 'button';
+  button.title = 'Walk';
+  button.setAttribute('aria-label', 'Walk');
+  button.setAttribute('aria-pressed', 'false');
+  button.textContent = '🚶';
+  button.style.cssText = 'width:30px;height:30px;padding:0;border:0;border-radius:4px;background:#fff;font-size:18px;line-height:30px;cursor:pointer;';
+  const hint = L.DomUtil.create('small', '', container);
+  hint.style.cssText = 'display:none;padding:0 8px;color:#333;white-space:nowrap;';
+  hint.textContent = 'W/S: run · A/D: turn · hold Space: ascend · drag: look around · Esc: exit';
+  L.DomEvent.disableClickPropagation(container);
+
+  const context = /* alloc */ {
+    layer,
+    speed,
+    distance,
+    keys,
+    container,
+    button,
+    hint,
+    meshes: null,
+    frame: null,
+    last: undefined,
+    swing: 0,
+    verticalSpeed: 0,
+    saved: null,
+    hitData: null,
+    local: null,
+    state: control.walker = sceneByLayer.get(layer).walker = /* alloc */ { latlng: null, heading: 0, phase: 0, height: 0 }
+  }
+  context.step = step.bind(context);
+  context.onKey = onKey.bind(context);
+  context.onBlur = onBlur.bind(context);
+  context.onPointer = onPointer.bind(context);
+  context.onTerrain = onTerrain.bind(context);
+  context.start = start.bind(context);
+  context.stop = stop.bind(context);
+  context.toggle = toggle.bind(context);
+  control._walk = context;
+  L.DomEvent.on(button, 'click', context.toggle);
+}

package/src/walk/initWalk.js

@@ -0,0 +1,19 @@
+import { L } from '../globals/L.js';
+import { initialize } from './initialize.js';
+import { onAdd } from './onAdd.js';
+import { onRemove } from './onRemove.js';
+
+/**
+ * Third-person walk mode, toggled by a map button (and Esc): a pedestrian at the map centre runs with W/S (or ↑/↓) and
+ * turns with A/D (or ←/→); the camera swings back behind it while it moves. Dragging the map only turns the camera
+ * (bearing, pitch); the wheel changes the camera distance.
+ * The walker follows the terrain, bridges included, and `control.walker` exposes `{ latlng, heading, phase }`.
+ * Options: `speed` (m/s, default 70), `distance` (camera distance in metres, default 20), `position` (button corner, default 'bottomright').
+ * Visible meshes of the other 3D layers (buildings, trees, models, streetlights) are solid; terrain and traffic are not.
+ */
+L.Control.Walk = L.Control.extend({
+  options: { position: 'bottomright', speed: 70, distance: 20 },
+  initialize,
+  onAdd,
+  onRemove,
+});

package/src/walk/initialize.js

@@ -0,0 +1,7 @@
+import { L } from '../globals/L.js';
+import { createWalk } from './createWalk.js';
+
+export function initialize(options) {
+  L.Util.setOptions(this, options);
+  createWalk(this, this.options);
+}

package/src/walk/land.js

@@ -0,0 +1,32 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { intersectMeshes } from '../collision/intersectMeshes.js';
+import { traverse } from '../scene/traverse.js';
+import { updateWorldMatrix } from '../scene/updateWorldMatrix.js';
+import { collectVisibleMesh } from '../picking/collectVisibleMesh.js';
+import { shouldSkipOther } from '../picking/shouldSkipOther.js';
+import { local } from './local.js';
+
+export function land(previousY) {
+  const state = sceneByLayer.get(this.layer), ray = state.raycaster;
+  const feet = local.call(this, this.local), root = state.root;
+  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];
+  if (y > previousY || this.verticalSpeed > 0) return;
+  updateWorldMatrix(state.scene);
+  ray.origin[0] = x; ray.origin[1] = previousY + 0.01; ray.origin[2] = z;
+  ray.direction[0] = 0; ray.direction[1] = -1; ray.direction[2] = 0;
+  ray.meshes.length = 0;
+  let layer, hit;
+  for (layer of sceneByLayer.get(state._shared)._layers) {
+    if (shouldSkipOther(layer, this.layer) || sceneByLayer.get(layer).kind === 'raster' || layer.options.nightLight) continue;
+    traverse(sceneByLayer.get(layer).root, collectVisibleMesh, ray.meshes);
+  }
+  for (hit of intersectMeshes(ray, ray.meshes)) {
+    if (hit.point[1] < y - 0.001) break;
+    this.state.height += (hit.point[1] - y) / root.scale[1];
+    this.verticalSpeed = 0;
+    break;
+  }
+  ray.meshes.length = 0;
+}

package/src/walk/local.js

@@ -0,0 +1,18 @@
+import { radians } from '../globals/radians.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+import { getElevation } from '../terrain/getElevation.js';
+
+export function local(output) {
+  const { layer, state } = this;
+  const map = layer._map, crs = map.options.crs, origin = crs.project(sceneByLayer.get(layer).location);
+  const metres = Math.cos(sceneByLayer.get(layer).location.lat * radians);
+  const p = crs.project(state.latlng), terrain = sceneByLayer.get(cameraByMap.get(map)._terrain3D)?._terrainReady && cameraByMap.get(map)._terrain3D;
+  const ground = (terrain && getElevation(terrain, state.latlng)) || 0;
+  output[0] = (p.x - origin.x) * metres;
+  output[1] = ground + (state.height ?? 0) - sceneByLayer.get(layer).root.position[1];
+  output[2] = -(p.y - origin.y) * metres;
+  return output;
+}

package/src/walk/moveWalker.js

@@ -0,0 +1,23 @@
+import { L } from '../globals/L.js';
+import { radians } from '../globals/radians.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { local } from './local.js';
+import { blocked } from './blocked.js';
+
+export function moveWalker(forward, dt) {
+  const metres = forward * this.speed * dt, { lat, lng } = this.state.latlng;
+  const { position, scale } = sceneByLayer.get(this.layer).root;
+  let east = Math.sin(this.state.heading) * metres, north = Math.cos(this.state.heading) * metres;
+  const feet = local.call(this, this.local);
+  let i;
+  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 them.
+  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 = /* alloc */ new L.LatLng(lat + north / 111320, lng + east / (111320 * Math.cos(lat * radians)));
+  this.state.phase += Math.hypot(east, north) / 1.6 * Math.PI;
+}

package/src/walk/onAdd.js

@@ -0,0 +1,29 @@
+import { walkByMap } from '../globals/walkByMap.js';
+
+export function onAdd(map) {
+  let state = walkByMap.get(map);
+  if (state?.control && state.control !== this) {
+    this._map = null;
+    throw /* alloc */ new Error('Only one Walk control can be active per map');
+  }
+  if (!state) {
+    state = /* alloc */ {
+      control: null,
+      hitData: /* alloc */ {
+        x: 0, y: 0, z: 0, dx: 0, dz: 0, reach: 0, best: 0, found: false,
+        seen: /* alloc */ new Set(),
+        normal: /* alloc */ [0, 0],
+      },
+      local: /* alloc */ [0, 0, 0],
+    };
+    walkByMap.set(map, state);
+  }
+  state.control = this;
+  state.local.fill(0);
+  state.hitData.seen.clear();
+  state.hitData.normal.fill(0);
+  this._walk.hitData = state.hitData;
+  this._walk.local = state.local;
+  this._walk.layer.addTo(map);
+  return this._walk.container;
+}

package/src/walk/onBlur.js

@@ -0,0 +1,3 @@
+export function onBlur() {
+  this.keys.clear();
+}

package/src/walk/onKey.js

@@ -0,0 +1,15 @@
+import { moves } from '../globals/moves.js';
+
+
+import { stop } from './stop.js';
+
+export function onKey(event) {
+  if (event.type === 'keyup' && event.code === 'Space') this.keys.delete('Space');
+  // 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] && event.code !== 'Space') return;
+  event.preventDefault();
+  if (event.type === 'keydown') this.keys.add(event.code); else this.keys.delete(event.code);
+}

package/src/walk/onPointer.js

@@ -0,0 +1,18 @@
+import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+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.dragX = event.clientX;
+    this.dragY = event.clientY;
+    this.dragging = true;
+    map.getContainer().setPointerCapture(event.pointerId);
+  } else if (this.dragging && event.type === 'pointermove') {
+    mapSetPitchAndBearing(map, Math.max(20, Math.min(85, mapGetPitch(map) - (event.clientY - this.dragY) * 0.2)), mapGetBearing(map) - (event.clientX - this.dragX) * 0.25);
+    this.dragX = event.clientX;
+    this.dragY = event.clientY;
+  } else this.dragging = false;
+}

package/src/walk/onRemove.js

@@ -0,0 +1,12 @@
+import { walkByMap } from '../globals/walkByMap.js';
+
+export function onRemove(map) {
+  const state = walkByMap.get(map);
+  if (state?.control !== this) return;
+  this._walk.stop();
+  this._walk.layer.remove();
+  state.control = null;
+  state.hitData.seen.clear();
+  this._walk.hitData = null;
+  this._walk.local = null;
+}

package/src/walk/onTerrain.js

@@ -0,0 +1,5 @@
+import { place } from './place.js';
+
+export function onTerrain() {
+  if (this.meshes) place.call(this);
+}

package/src/walk/place.js

@@ -0,0 +1,20 @@
+import { limbs } from '../globals/limbs.js';
+
+import { update } from '../scene/update.js';
+
+import { local } from './local.js';
+
+export function place() {
+  const [x, y, z] = local.call(this, this.local);
+  // 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);
+  let i, px, py, sign, mesh;
+  for (i = 0; i < limbs.length; i++) {
+    [, px, py, sign] = limbs[i];
+    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(this.layer);
+}

package/src/walk/start.js

@@ -0,0 +1,46 @@
+import { radians } from '../globals/radians.js';
+import { earthCirc } from '../globals/earthCirc.js';
+import { L } from '../globals/L.js';
+import { sceneWalkHandlers } from '../globals/sceneWalkHandlers.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { mapSetPitch } from '../camera/mapSetPitch.js';
+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();
+  this.state.height = this.verticalSpeed = 0;
+  // 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 * earthCirc * Math.cos(this.state.latlng.lat * radians) / 256));
+  let name;
+  this.saved = /* alloc */ {
+    zoom: map.getZoom(), pitch: mapGetPitch(map), scrollWheelZoom: map.options.scrollWheelZoom,
+    handlers: /* alloc */ [],
+  };
+  for (name of sceneWalkHandlers) {
+    if (map[name]?.enabled()) this.saved.handlers.push(name);
+  }
+  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 = -mapGetBearing(map) * radians;
+  map.setView(this.state.latlng, zoom, /* alloc */ { animate: false });
+  mapSetPitch(map, 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

@@ -0,0 +1,45 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { limbs } from '../globals/limbs.js';
+import { parts } from '../globals/parts.js';
+import { moves } from '../globals/moves.js';
+
+
+import * as createMesh from '../rendering/createMesh.js';
+import { build } from '../geometry/build.js';
+
+import { wrap } from '../utils/wrap.js';
+import { local } from './local.js';
+import { place } from './place.js';
+import { land } from './land.js';
+import { moveWalker } from './moveWalker.js';
+import { stepWalkerHeight } from './stepWalkerHeight.js';
+import { updateWalkerView } from './updateWalkerView.js';
+
+export function step(now) {
+  const layer = this.layer;
+  this.frame = requestAnimationFrame(this.step);
+  const dt = Math.min(0.1, (now - (this.last ?? now)) / 1000);
+  this.last = now;
+  if (!sceneByLayer.get(layer).renderer) return;
+  let changed = false;
+  let part, key;
+  if (!this.meshes) {
+    this.meshes = /* alloc */ [];
+    for ([part] of limbs) this.meshes.push(createMesh.createMesh(layer, build(parts[part])));
+    changed = true;
+  }
+  const previousY = sceneByLayer.get(layer).root.position[1] +
+    local.call(this, this.local)[1] * sceneByLayer.get(layer).root.scale[1];
+  if (stepWalkerHeight.call(this, dt)) 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) {
+    moveWalker.call(this, forward, dt);
+    changed = true;
+  }
+  if (changed) land.call(this, previousY);
+  if (updateWalkerView.call(this, forward, turn, dt)) changed = true;
+  if (changed) place.call(this);
+}

package/src/walk/stepWalkerHeight.js

@@ -0,0 +1,11 @@
+export function stepWalkerHeight(dt) {
+  if (this.keys.has('Space')) {
+    this.verticalSpeed = 6;
+    this.state.height += this.verticalSpeed * dt;
+    return true;
+  }
+  if (!this.verticalSpeed && !this.state.height) return false;
+  this.state.height = Math.max(0, this.state.height + this.verticalSpeed * dt - 9.81 * dt * dt / 2);
+  this.verticalSpeed = this.state.height > 0 ? this.verticalSpeed - 9.81 * dt : 0;
+  return true;
+}

package/src/walk/stop.js

@@ -0,0 +1,30 @@
+import { L } from '../globals/L.js';
+import { mapSetPitch } from '../camera/mapSetPitch.js';
+import * as disposeMesh from '../rendering/disposeMesh.js';
+import { onKey } from './onKey.js';
+import { onBlur } from './onBlur.js';
+import { onPointer } from './onPointer.js';
+import { onTerrain } from './onTerrain.js';
+
+export function stop() {
+  const map = this.layer._map;
+  cancelAnimationFrame(this.frame);
+  this.keys.clear(); this.dragging = false;
+  this.state.height = this.verticalSpeed = 0;
+  L.DomEvent.off(document, 'keydown keyup', this.onKey);
+  L.DomEvent.off(window, 'blur', this.onBlur);
+  let mesh, name;
+  if (this.meshes) for (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 (name of this.saved.handlers) map[name].enable();
+  map.setView(this.state.latlng, this.saved.zoom, /* alloc */ { animate: false });
+  mapSetPitch(map, this.saved.pitch);
+  this.saved = null;
+}

package/src/walk/toggle.js

@@ -0,0 +1,6 @@
+import { start } from './start.js';
+import { stop } from './stop.js';
+
+export function toggle() {
+  if (this.saved) stop.call(this); else start.call(this);
+}

package/src/walk/updateWalkerView.js

@@ -0,0 +1,22 @@
+import { degrees } from '../globals/degrees.js';
+import { radians } from '../globals/radians.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { wrap } from '../utils/wrap.js';
+
+export function updateWalkerView(forward, turn, dt) {
+  const map = this.layer._map;
+  if (forward || turn) {
+    // Swing the camera behind the walker.
+    const bearing = mapGetBearing(map) * radians, behind = wrap(-this.state.heading - bearing);
+    if (Math.abs(behind) > 1e-3) mapSetPitchAndBearing(map, mapGetPitch(map), (bearing + behind * Math.min(1, dt * 4)) * degrees);
+    map.setView(this.state.latlng, map.getZoom(), /* alloc */ { 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);
+    return true;
+  }
+  return false;
+}

package/dist/utils/CELL.js

@@ -1,2 +0,0 @@
-const o=8;export{o as CELL};
-//# sourceMappingURL=CELL.js.map

package/dist/utils/CELL.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/CELL.js"],
-  "sourcesContent": ["// Walls (non-horizontal triangles) of a mesh in world space, bucketed by 8 m cells; `origin` is the world translation\n// at build time, since layer roots only move vertically with the terrain afterwards.\n\nexport const CELL = 8;\n"],
-  "mappings": "AAGO,MAAMA,EAAO",
-  "names": ["CELL"]
-}

package/dist/utils/addBridges.js

@@ -1,2 +0,0 @@
-import{createMesh as b}from"./createMesh.js";import{triangulate as v}from"./triangulate.js";function D(s,z){const j=s._map,w=j.options.crs,B=s._terrainZoom,P=w.project(s.location),d=Math.cos(s.location.lat*Math.PI/180),I=s.root.position[1],y=[],$=[],q=[],Z=([c,f,u])=>{const e=w.project(new L.LatLng(f,c));return[(e.x-P.x)*d,u-I,-(e.y-P.y)*d]},M=(c,f)=>{y.push(...c),$.push(...f),q.push(.6,.58,.54)};s._bridges=new Map;for(const{geometry:c}of z.features){const f=c.type==="Polygon"?[c.coordinates]:c.type==="MultiPolygon"?c.coordinates:[];for(const u of f){const e=u.map(o=>o.slice(0,-1)).filter(o=>o.length>=3);if(!e.length)continue;const l=e.flat().map(([o,t,n])=>{const r=j.project([t,o],B);return[r.x,r.y,n]}),p=e.flat().map(Z);let x;try{const o=e.map((r,a)=>e.slice(0,a).reduce((m,i)=>m+i.length,0)),[t,...n]=e.map((r,a)=>r.map((m,i)=>({x:l[o[a]+i][0],y:l[o[a]+i][1]})));x=v(t,n)}catch{continue}const g={triangles:x.map(o=>o.map(t=>l[t])),min:[Math.min(...l.map(o=>o[0])),Math.min(...l.map(o=>o[1]))],max:[Math.max(...l.map(o=>o[0])),Math.max(...l.map(o=>o[1]))]};for(let o=Math.floor(g.min[0]/64);o<=Math.floor(g.max[0]/64);o++)for(let t=Math.floor(g.min[1]/64);t<=Math.floor(g.max[1]/64);t++){const n=`${o}/${t}`;s._bridges.set(n,[...s._bridges.get(n)||[],g])}const h=o=>[o[0],o[1]-1.2,o[2]];for(let[o,t,n]of x){const[r,a,m]=[p[o],p[t],p[n]];(a[2]-r[2])*(m[0]-r[0])-(a[0]-r[0])*(m[2]-r[2])<0&&([t,n]=[n,t]);for(const i of[o,t,n])M(p[i],[0,1,0]);for(const i of[o,n,t])M(h(p[i]),[0,-1,0])}let _=0;for(const o of e){for(let t=0;t<o.length;t++){const n=p[_+t],r=p[_+(t+1)%o.length],a=Math.hypot(r[0]-n[0],r[2]-n[2])||1,m=[(r[2]-n[2])/a,0,-(r[0]-n[0])/a];for(const i of[n,r,h(r),n,h(r),h(n)])M(i,m)}_+=o.length}}}y.length&&(s._bridgeMesh=b(s,{position:y,normal:$,color:q}))}export{D as addBridges};
-//# sourceMappingURL=addBridges.js.map

package/dist/utils/addBridges.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/addBridges.js"],
-  "sourcesContent": ["import { createMesh } from './createMesh.js';\nimport { triangulate } from './triangulate.js';\n\n/**\n * Bare-earth DEMs drop bridges: `getElevation` returns the deck height inside these polygons (GeoJSON\n * Polygon/MultiPolygon with Z, e.g. IGN BD TOPO), and one mesh draws the 1.2 m thick decks.\n * ponytail: anything under a deck (quays, boats asking `getElevation`) also gets the deck height.\n */\n\nexport function addBridges(backend, geojson) {\n  const map = backend._map, crs = map.options.crs, zoom = backend._terrainZoom;\n  const origin = crs.project(backend.location), metres = Math.cos(backend.location.lat * Math.PI / 180);\n  const base = backend.root.position[1], position = [], normal = [], color = [];\n  const local = ([lng, lat, z]) => {\n    const p = crs.project(new L.LatLng(lat, lng));\n    return [(p.x - origin.x) * metres, z - base, -(p.y - origin.y) * metres];\n  };\n  const push = (p, n) => { position.push(...p); normal.push(...n); color.push(0.6, 0.58, 0.54); };\n  backend._bridges = new Map();\n  for (const { geometry } of geojson.features) {\n    const polygons = geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.type === 'MultiPolygon' ? geometry.coordinates : [];\n    for (const polygon of polygons) {\n      const rings = polygon.map(ring => ring.slice(0, -1)).filter(ring => ring.length >= 3);\n      if (!rings.length) continue;\n      const pixels = rings.flat().map(([lng, lat, z]) => { const p = map.project([lat, lng], zoom); return [p.x, p.y, z]; });\n      const points = rings.flat().map(local);\n      let triangles;\n      try {\n        const starts = rings.map((ring, r) => rings.slice(0, r).reduce((sum, previous) => sum + previous.length, 0));\n        const [contour, ...holes] = rings.map((ring, r) => ring.map((c, i) => ({ x: pixels[starts[r] + i][0], y: pixels[starts[r] + i][1] })));\n        triangles = triangulate(contour, holes);\n      } catch { continue; }\n      const bridge = {\n        triangles: triangles.map(t => t.map(i => pixels[i])),\n        min: [Math.min(...pixels.map(p => p[0])), Math.min(...pixels.map(p => p[1]))],\n        max: [Math.max(...pixels.map(p => p[0])), Math.max(...pixels.map(p => p[1]))],\n      };\n      for (let x = Math.floor(bridge.min[0] / 64); x <= Math.floor(bridge.max[0] / 64); x++) {\n        for (let y = Math.floor(bridge.min[1] / 64); y <= Math.floor(bridge.max[1] / 64); y++) {\n          const key = `${x}/${y}`;\n          backend._bridges.set(key, [...backend._bridges.get(key) || [], bridge]);\n        }\n      }\n      const below = p => [p[0], p[1] - 1.2, p[2]];\n      for (let [a, b, c] of triangles) {\n        // Counter-clockwise seen from above, so double-sided shading keeps the top lit.\n        const [pa, pb, pc] = [points[a], points[b], points[c]];\n        if ((pb[2] - pa[2]) * (pc[0] - pa[0]) - (pb[0] - pa[0]) * (pc[2] - pa[2]) < 0) [b, c] = [c, b];\n        for (const i of [a, b, c]) push(points[i], [0, 1, 0]);\n        for (const i of [a, c, b]) push(below(points[i]), [0, -1, 0]);\n      }\n      let start = 0;\n      for (const ring of rings) {\n        for (let i = 0; i < ring.length; i++) {\n          const p = points[start + i], q = points[start + (i + 1) % ring.length];\n          const length = Math.hypot(q[0] - p[0], q[2] - p[2]) || 1, n = [(q[2] - p[2]) / length, 0, -(q[0] - p[0]) / length];\n          for (const corner of [p, q, below(q), p, below(q), below(p)]) push(corner, n);\n        }\n        start += ring.length;\n      }\n    }\n  }\n  if (position.length) {\n    backend._bridgeMesh = createMesh(backend, { position, normal, color });\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["createMesh", "triangulate", "addBridges", "backend", "geojson", "map", "crs", "zoom", "origin", "metres", "base", "position", "normal", "color", "local", "lng", "lat", "z", "p", "push", "n", "geometry", "polygons", "polygon", "rings", "ring", "pixels", "points", "triangles", "starts", "r", "sum", "previous", "contour", "holes", "c", "bridge", "t", "i", "x", "y", "key", "below", "a", "b", "pa", "pb", "pc", "start", "q", "length", "corner"]
-}

package/dist/utils/addRasterTile.js

@@ -1,2 +0,0 @@
-import{createProgram as O}from"./createProgram.js";import{destroyTexture as I}from"./destroyTexture.js";import{terrainAtlas as N}from"./terrainAtlas.js";import{terrainGrid as R}from"./terrainGrid.js";import{setParent as S}from"./setParent.js";import{update as X}from"./update.js";async function j(t,m,e,i){if(!await t._terrainPromise||!t._map||t._map._terrain3D!==t||m._terrain3D!==t||i.request.signal.aborted||!m._rasterTiles.has(`${e.z}/${e.x}/${e.y}`)||t._rasterTiles.has(i))return;const _=Math.max(1,Math.min(64,256/2**(e.z-t._terrainZoom))),v=t._map,u=v.options.crs,y=u.project(t.location),f=Math.cos(t.location.lat*Math.PI/180),T=u.scale(e.z),g=2**(t._terrainZoom-e.z),x=u.transformation.untransform(new L.Point(e.x*256,e.y*256),T),w=u.transformation.untransform(new L.Point((e.x+1)*256,(e.y+1)*256),T),o=t.renderer.device,U=i.texture;if(!t._rasterProgram||t._rasterProgram.device!==o){const a=t._terrainBounds,r=a.max.x-a.min.x+1,z=a.max.y-a.min.y+1,{elevations:E,low:B,high:G}=N(t._terrainTiles,a);t._dem&&I(t,t._dem.texture),t._dem={texture:o.createTexture({size:[r*256,z*256],format:"r32float",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST}),low:Number.isFinite(B)?B:t._terrainOriginElevation,high:Number.isFinite(G)?G:t._terrainOriginElevation},o.queue.writeTexture({texture:t._dem.texture},E,{bytesPerRow:r*1024},[r*256,z*256]),t._terrainGrids=new Map,t._rasterProgram=O(t,{baseTexture:U,unlit:!0,terrain:t._dem,alphaMode:"BLEND",depthWrite:!0})}let s=t._terrainGrids.get(_);if(!s){s=R(_);for(const[a,r]of Object.entries(s))r.size||=1,r.count=r.data.length/r.size,r.indexFormat="uint16",r.buffer=o.createBuffer({size:Math.max(4,r.data.byteLength),usage:a==="index"?GPUBufferUsage.INDEX|GPUBufferUsage.COPY_DST:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST}),o.queue.writeBuffer(r.buffer,0,r.data);t._terrainGrids.set(_,s)}const n=t._terrainOriginElevation,p=Math.min(t._dem.low,n)-n,h=Math.max(t._dem.high,n)-n,l=(w.x-x.x)*f,P=-(w.y-x.y)*f,D={device:o,attributes:s,drawRange:{start:0,count:s.index.count},bounds:{min:[0,p,0],max:[1,h,1],center:[.5,(p+h)/2,.5],radius:Math.hypot(l,h-p,P)/2/Math.max(l,1,P)}},M={position:[(x.x-y.x)*f,0,-(x.y-y.y)*f],rotation:[0,0,0],scale:[l,1,P],worldMatrix:[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],children:[],visible:!0,device:o,geometry:D,program:t._rasterProgram,texture:U,terrain:[e.x*256*g-t._terrainBounds.min.x*256,e.y*256*g-t._terrainBounds.min.y*256,256*g,n],tile:i,opacity:m.options.opacity??1,id:L.Layer._nextId++,renderOrder:m.options.zIndex||0,fadeDuration:250,fadeStart:i.loadedAt,ground:!0};i.mesh.visible=!1,S(M,t.root),X(t),t._rasterTiles.set(i,M)}export{j as addRasterTile};
-//# sourceMappingURL=addRasterTile.js.map

package/dist/utils/addRasterTile.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/addRasterTile.js"],
-  "sourcesContent": ["import { createProgram } from './createProgram.js';\nimport { destroyTexture } from './destroyTexture.js';\nimport { terrainAtlas } from './terrainAtlas.js';\nimport { terrainGrid } from './terrainGrid.js';\nimport { setParent } from './setParent.js';\nimport { update } from './update.js';\n\nexport async function addRasterTile(backend, layer, coords, tile) {\n  const ready = await backend._terrainPromise;\n  if (!ready || !backend._map || backend._map._terrain3D !== backend || layer._terrain3D !== backend ||\n    tile.request.signal.aborted || !layer._rasterTiles.has(`${coords.z}/${coords.x}/${coords.y}`) ||\n    backend._rasterTiles.has(tile)) {\n    return;\n  }\n  // Match DEM pixel spacing, capped at 64 subdivisions per tile.\n  const divisions = Math.max(1, Math.min(64, 256 / 2 ** (coords.z - backend._terrainZoom)));\n  const map = backend._map, crs = map.options.crs;\n  const origin = crs.project(backend.location), metres = Math.cos(backend.location.lat * Math.PI / 180);\n  // Tile pixels map linearly to projected metres: one scaled unit grid per tile, elevation in the vertex shader.\n  const scale = crs.scale(coords.z), terrainScale = 2 ** (backend._terrainZoom - coords.z);\n  const corner = crs.transformation.untransform(new L.Point(coords.x * 256, coords.y * 256), scale);\n  const opposite = crs.transformation.untransform(new L.Point((coords.x + 1) * 256, (coords.y + 1) * 256), scale);\n  const device = backend.renderer.device;\n  const texture = tile.texture;\n  if (!backend._rasterProgram || backend._rasterProgram.device !== device) {\n    // DEM atlas over the archive's tile grid; invalid or missing samples become -1e9 (the shader's no-data).\n    // ponytail: one texture, capped by maxTextureDimension2D (32\u00D732 DEM tiles at 8192 px); split it for larger archives.\n    const bounds = backend._terrainBounds, columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;\n    const { elevations, low, high } = terrainAtlas(backend._terrainTiles, bounds);\n    if (backend._dem) destroyTexture(backend, backend._dem.texture);\n    backend._dem = {\n      texture: device.createTexture({\n        size: [columns * 256, rows * 256],\n        format: 'r32float',\n        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,\n      }),\n      low: Number.isFinite(low) ? low : backend._terrainOriginElevation,\n      high: Number.isFinite(high) ? high : backend._terrainOriginElevation,\n    };\n    device.queue.writeTexture({ texture: backend._dem.texture }, elevations,\n      { bytesPerRow: columns * 1024 }, [columns * 256, rows * 256]);\n    backend._terrainGrids = new Map();\n    backend._rasterProgram = createProgram(backend, {\n      baseTexture: texture,\n      unlit: true,\n      terrain: backend._dem,\n      alphaMode: 'BLEND',\n      depthWrite: true,\n    });\n  }\n  let attributes = backend._terrainGrids.get(divisions);\n  if (!attributes) {\n    attributes = terrainGrid(divisions);\n    for (const [name, attribute] of Object.entries(attributes)) {\n      attribute.size ||= 1;\n      attribute.count = attribute.data.length / attribute.size;\n      attribute.indexFormat = 'uint16';\n      attribute.buffer = device.createBuffer({\n        size: Math.max(4, attribute.data.byteLength),\n        usage: name === 'index'\n          ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST\n          : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,\n      });\n      device.queue.writeBuffer(attribute.buffer, 0, attribute.data);\n    }\n    backend._terrainGrids.set(divisions, attributes);\n  }\n  const base = backend._terrainOriginElevation;\n  const bottom = Math.min(backend._dem.low, base) - base, top = Math.max(backend._dem.high, base) - base;\n  const sizeX = (opposite.x - corner.x) * metres, sizeZ = -(opposite.y - corner.y) * metres;\n  // ponytail: ray picking sees the flat unit grid; read the DEM back if terrain must be pickable.\n  const geometry = {\n    device,\n    attributes,\n    drawRange: { start: 0, count: attributes.index.count },\n    // Local bounds whose radius, scaled by the largest axis, still covers the displaced tile.\n    bounds: {\n      min: [0, bottom, 0], max: [1, top, 1], center: [0.5, (bottom + top) / 2, 0.5],\n      radius: Math.hypot(sizeX, top - bottom, sizeZ) / 2 / Math.max(sizeX, 1, sizeZ),\n    },\n  };\n  const mesh = {\n    position: [(corner.x - origin.x) * metres, 0, -(corner.y - origin.y) * metres],\n    rotation: [0, 0, 0],\n    scale: [sizeX, 1, sizeZ],\n    worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],\n    children: [],\n    visible: true,\n    device,\n    geometry,\n    program: backend._rasterProgram,\n    texture,\n    // DEM pixel of the tile's corner, DEM pixels per tile, and the elevation at the layer origin.\n    terrain: [\n      coords.x * 256 * terrainScale - backend._terrainBounds.min.x * 256,\n      coords.y * 256 * terrainScale - backend._terrainBounds.min.y * 256,\n      256 * terrainScale,\n      base,\n    ],\n    tile,\n    opacity: layer.options.opacity ?? 1,\n    id: L.Layer._nextId++,\n    renderOrder: layer.options.zIndex || 0,\n    fadeDuration: 250,\n    fadeStart: tile.loadedAt,\n    ground: true,\n  };\n  tile.mesh.visible = false;\n  setParent(mesh, backend.root);\n  update(backend);\n  backend._rasterTiles.set(tile, mesh);\n}\n"],
-  "mappings": "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",
-  "names": ["createProgram", "destroyTexture", "terrainAtlas", "terrainGrid", "setParent", "update", "addRasterTile", "backend", "layer", "coords", "tile", "divisions", "map", "crs", "origin", "metres", "scale", "terrainScale", "corner", "opposite", "device", "texture", "bounds", "columns", "rows", "elevations", "low", "high", "attributes", "name", "attribute", "base", "bottom", "top", "sizeX", "sizeZ", "geometry", "mesh"]
-}

package/dist/utils/along.js

@@ -1,2 +0,0 @@
-function n(a,d,i){let o=1;for(;o<d.length-1&&d[o]<i;)o++;const c=a[o-1],r=a[o],t=d[o]-d[o-1]||1,x=(i-d[o-1])/t;return{x:c[0]+(r[0]-c[0])*x,y:(c[2]??0)+((r[2]??0)-(c[2]??0))*x,z:c[1]+(r[1]-c[1])*x,dx:(r[0]-c[0])/t,dz:(r[1]-c[1])/t}}export{n as along};
-//# sourceMappingURL=along.js.map

package/dist/utils/along.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/along.js"],
-  "sourcesContent": ["/** Point and unit direction at distance `s` along `points` ([x, z, y?]) with cumulative `lengths`. */\n\nexport function along(points, lengths, s) {\n  let i = 1;\n  while (i < lengths.length - 1 && lengths[i] < s) i++;\n  const a = points[i - 1], b = points[i], d = lengths[i] - lengths[i - 1] || 1;\n  const t = (s - lengths[i - 1]) / d;\n  return { x: a[0] + (b[0] - a[0]) * t, y: (a[2] ?? 0) + ((b[2] ?? 0) - (a[2] ?? 0)) * t, z: a[1] + (b[1] - a[1]) * t, dx: (b[0] - a[0]) / d, dz: (b[1] - a[1]) / d };\n}\n"],
-  "mappings": "AAEO,SAASA,EAAMC,EAAQC,EAASC,EAAG,CACxC,IAAIC,EAAI,EACR,KAAOA,EAAIF,EAAQ,OAAS,GAAKA,EAAQE,CAAC,EAAID,GAAGC,IACjD,MAAMC,EAAIJ,EAAOG,EAAI,CAAC,EAAGE,EAAIL,EAAOG,CAAC,EAAGG,EAAIL,EAAQE,CAAC,EAAIF,EAAQE,EAAI,CAAC,GAAK,EACrEI,GAAKL,EAAID,EAAQE,EAAI,CAAC,GAAKG,EACjC,MAAO,CAAE,EAAGF,EAAE,CAAC,GAAKC,EAAE,CAAC,EAAID,EAAE,CAAC,GAAKG,EAAG,GAAIH,EAAE,CAAC,GAAK,KAAOC,EAAE,CAAC,GAAK,IAAMD,EAAE,CAAC,GAAK,IAAMG,EAAG,EAAGH,EAAE,CAAC,GAAKC,EAAE,CAAC,EAAID,EAAE,CAAC,GAAKG,EAAG,IAAKF,EAAE,CAAC,EAAID,EAAE,CAAC,GAAKE,EAAG,IAAKD,EAAE,CAAC,EAAID,EAAE,CAAC,GAAKE,CAAE,CACpK",
-  "names": ["along", "points", "lengths", "s", "i", "a", "b", "d", "t"]
-}

package/dist/utils/atmosphere.js

@@ -1,2 +0,0 @@
-function b(s){if(!Number.isFinite(s))throw new Error("Invalid solar altitude");const t=[[-18,[3,7,20],[17,28,54],[.025,.04,.09]],[-6,[37,53,84],[182,106,86],[.12,.1,.14]],[0,[101,131,171],[246,170,115],[.38,.24,.18]],[10,[74,147,208],[197,221,237],[.8,.75,.68]],[25,[53,144,213],[223,238,250],[1,1,1]]],r=t.findIndex(n=>n[0]>=s),a=t[r<0?t.length-1:r],o=t[Math.max(0,r-1)],p=o===a||r<0?1:(s-o[0])/(a[0]-o[0]),i=n=>o[n].map((c,m)=>c+(a[n][m]-c)*p),e=n=>`rgb(${n.map(Math.round).join(", ")})`;return{background:`linear-gradient(${e(i(1))}, ${e(i(2))})`,tint:i(3)}}export{b as atmosphere};
-//# sourceMappingURL=atmosphere.js.map

package/dist/utils/atmosphere.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/atmosphere.js"],
-  "sourcesContent": ["\nexport function atmosphere(altitude) {\n  if (!Number.isFinite(altitude)) {\n    throw new Error('Invalid solar altitude');\n  }\n  const stops = [\n    [-18, [3, 7, 20], [17, 28, 54], [0.025, 0.04, 0.09]],\n    [-6, [37, 53, 84], [182, 106, 86], [0.12, 0.10, 0.14]],\n    [0, [101, 131, 171], [246, 170, 115], [0.38, 0.24, 0.18]],\n    [10, [74, 147, 208], [197, 221, 237], [0.80, 0.75, 0.68]],\n    [25, [53, 144, 213], [223, 238, 250], [1, 1, 1]],\n  ];\n  const upper = stops.findIndex(stop => stop[0] >= altitude);\n  const b = stops[upper < 0 ? stops.length - 1 : upper],\n        a = stops[Math.max(0, upper - 1)];\n  const t = a === b || upper < 0 ? 1 : (altitude - a[0]) / (b[0] - a[0]);\n  const mix = index => a[index].map((value, i) => value + (b[index][i] - value) * t);\n  const rgb = values => `rgb(${values.map(Math.round).join(', ')})`;\n  return { background: `linear-gradient(${rgb(mix(1))}, ${rgb(mix(2))})`, tint: mix(3) };\n}\n"],
-  "mappings": "AACO,SAASA,EAAWC,EAAU,CACnC,GAAI,CAAC,OAAO,SAASA,CAAQ,EAC3B,MAAM,IAAI,MAAM,wBAAwB,EAE1C,MAAMC,EAAQ,CACZ,CAAC,IAAK,CAAC,EAAG,EAAG,EAAE,EAAG,CAAC,GAAI,GAAI,EAAE,EAAG,CAAC,KAAO,IAAM,GAAI,CAAC,EACnD,CAAC,GAAI,CAAC,GAAI,GAAI,EAAE,EAAG,CAAC,IAAK,IAAK,EAAE,EAAG,CAAC,IAAM,GAAM,GAAI,CAAC,EACrD,CAAC,EAAG,CAAC,IAAK,IAAK,GAAG,EAAG,CAAC,IAAK,IAAK,GAAG,EAAG,CAAC,IAAM,IAAM,GAAI,CAAC,EACxD,CAAC,GAAI,CAAC,GAAI,IAAK,GAAG,EAAG,CAAC,IAAK,IAAK,GAAG,EAAG,CAAC,GAAM,IAAM,GAAI,CAAC,EACxD,CAAC,GAAI,CAAC,GAAI,IAAK,GAAG,EAAG,CAAC,IAAK,IAAK,GAAG,EAAG,CAAC,EAAG,EAAG,CAAC,CAAC,CACjD,EACMC,EAAQD,EAAM,UAAUE,GAAQA,EAAK,CAAC,GAAKH,CAAQ,EACnDI,EAAIH,EAAMC,EAAQ,EAAID,EAAM,OAAS,EAAIC,CAAK,EAC9CG,EAAIJ,EAAM,KAAK,IAAI,EAAGC,EAAQ,CAAC,CAAC,EAChCI,EAAID,IAAMD,GAAKF,EAAQ,EAAI,GAAKF,EAAWK,EAAE,CAAC,IAAMD,EAAE,CAAC,EAAIC,EAAE,CAAC,GAC9DE,EAAMC,GAASH,EAAEG,CAAK,EAAE,IAAI,CAACC,EAAOC,IAAMD,GAASL,EAAEI,CAAK,EAAEE,CAAC,EAAID,GAASH,CAAC,EAC3EK,EAAMC,GAAU,OAAOA,EAAO,IAAI,KAAK,KAAK,EAAE,KAAK,IAAI,CAAC,IAC9D,MAAO,CAAE,WAAY,mBAAmBD,EAAIJ,EAAI,CAAC,CAAC,CAAC,KAAKI,EAAIJ,EAAI,CAAC,CAAC,CAAC,IAAK,KAAMA,EAAI,CAAC,CAAE,CACvF",
-  "names": ["atmosphere", "altitude", "stops", "upper", "stop", "b", "a", "t", "mix", "index", "value", "i", "rgb", "values"]
-}

package/dist/utils/attach.js

@@ -1,2 +0,0 @@
-import{emptyNode as _}from"./emptyNode.js";import{setParent as w}from"./setParent.js";import{traverse as G}from"./traverse.js";import{createProgram as E}from"./createProgram.js";import{endZoom as R}from"./endZoom.js";import{onMapChange as S}from"./onMapChange.js";import{onZoomAnim as A}from"./onZoomAnim.js";import{render as z}from"./render.js";import{startZoom as M}from"./startZoom.js";import{update as N}from"./update.js";import{updateArea as B}from"./updateArea.js";import{setTerrainHeight as C}from"./setTerrainHeight.js";import{resizeSunlight as D}from"./resizeSunlight.js";function O(e){const a=e.getContainer();if(a.querySelector(".leaflet-webgpu-warning"))return;const r=document.createElement("div");r.className="leaflet-webgpu-warning",r.setAttribute("role","alert"),r.style.cssText="position:absolute;z-index:1000;top:50%;left:50%;transform:translate(-50%,-50%);max-width:calc(100% - 32px);box-sizing:border-box;padding:12px 16px;border:1px solid #c98b24;border-radius:6px;background:#fff8e6;box-shadow:0 3px 12px #0005;color:#30251d;font:14px/1.5 sans-serif;text-align:center;pointer-events:auto",r.append("WebGPU is not available in this browser or device. ");const l=document.createElement("a");l.href="https://developer.mozilla.org/en-US/docs/Web/API/WebGPU_API#browser_compatibility",l.target="_blank",l.rel="noopener noreferrer",l.textContent="Learn more",r.append(l),a.append(r)}async function Q(e,a){let r=L.Layer._renderers.get(a);if(r?._rendererReady&&await r._rendererReady.promise,!r){r=e,e._rendererReady=Promise.withResolvers(),e._rendererReady.promise.catch(()=>{}),L.Layer._renderers.set(a,r);const t=d=>{throw O(a),e._rendererReady.reject(d),L.Layer._renderers.delete(a),d},u=document.createElement("canvas");navigator.gpu||t(new Error("Layer3D requires WebGPU"));const f=await navigator.gpu.requestAdapter().catch(t);f||t(new Error("Unable to acquire a WebGPU adapter"));const i=await f.requestDevice().catch(t);i.addEventListener("uncapturederror",d=>{const g=L.Layer._renderers.get(a);if(g?.renderer?.device===i)for(const T of g?._layers||[])T.fire("error",{error:d.error})}),i.lost.then(d=>{const g=L.Layer._renderers.get(a);if(!g||g.renderer?.device!==i)return;const T=new Error(`WebGPU device lost: ${d.message||d.reason}`);for(const h of g._layers)h.fire("error",{error:T})});const n=u.getContext("webgpu");n||(i.destroy(),t(new Error("Unable to create a WebGPU canvas context")));const s=navigator.gpu.getPreferredCanvasFormat();n.configure({device:i,format:s,alphaMode:"premultiplied"}),a.getContainer().querySelector(".leaflet-webgpu-warning")?.remove(),e._shared=e,e._layers=new Set,e._sceneOrigin=e.location,e.scene=_(),e.camera={position:[0,0,0],up:[0,1,0],target:[0,0,0],viewMatrix:[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],projectionMatrix:[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],projectionViewMatrix:[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],fov:45,aspect:1,near:.1,far:1e4},e.renderer={device:i,context:n,format:s,canvas:u,dpr:Math.min(window.devicePixelRatio,2)};const o=i.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"depth"}},{binding:2,visibility:GPUShaderStage.FRAGMENT,sampler:{type:"comparison"}},{binding:3,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"read-only-storage"}}]}),p=e.renderer.device.createBuffer({size:80,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST}),c=e.renderer.device.createSampler({compare:"less-equal",minFilter:"linear",magFilter:"linear"}),U=e.renderer.device.createBuffer({size:32,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST});e.renderer.sunlight={layout:o,buffer:p,sampler:c,lights:U,size:0};const x=new Float32Array(20);x.set([1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]),e.renderer.device.queue.writeBuffer(p,0,x),D(e,1);const v=document.createElement("canvas");v.width=1,v.height=1,e.renderer.roofFallbackTexture={device:i,texture:i.createTexture({size:[1,1],format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT}),sampler:i.createSampler({addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"}),image:v,format:"rgba8unorm",srgb:!1,uploaded:null},r._size=null,u.className="leaflet-3d",u.style.cssText="position:absolute;top:0;left:0;pointer-events:none",u.setAttribute("role","img"),u.setAttribute("aria-label",e.options.ariaLabel??"3D scene");let m=a.getPane("webgpuPane");m||(m=a.createPane("webgpuPane",a.getContainer()),m.style.zIndex=1,m.style.pointerEvents="none"),m.append(u),a.on("move zoom rotate pitch resize viewreset layeradd layerremove",S,r),a.on("zoomstart",M,r),a.on("zoomanim",A,r),a.on("zoomend",R,r),e._rendererReady.resolve(),delete r._rendererReady,z(r),L.Layer._renderers.set(a,r)}const l=a.options.crs.project(r._sceneOrigin),P=a.options.crs.project(e.location),y=Math.cos(r._sceneOrigin.lat*Math.PI/180);e._terrainBaseY??=e.root.position[1],e.root.position[0]=(P.x-l.x)*y,e.root.position[1]=e._terrainBaseY,e.root.position[2]=-(P.y-l.y)*y,C(e),e.root.scale.fill(y/Math.cos(e.location.lat*Math.PI/180)),e._shared=r,e.renderer=r.renderer,e.scene=r.scene,e.camera=r.camera,r._layers.add(e),w(e.root,r.scene),G(e.root,t=>{if(t.geometry&&t.geometry.device!==r.renderer.device){const u=t.geometry,f=t.program._layerMaterial,i={};for(const s of["position","normal","color","uv","index"]){const o=u.attributes[s];if(!o)continue;const{data:p,size:c,count:U,normalized:x}=o;i[s]={data:p.slice(0,U*c),size:c,normalized:x}}const n=r.renderer.device;i.index?.data instanceof Uint8Array&&(i.index.data=Uint16Array.from(i.index.data));for(const[s,o]of Object.entries(i))o.size||=1,o.count=o.data.length/o.size,o.indexFormat=o.data instanceof Uint32Array?"uint32":"uint16",o.buffer=n.createBuffer({size:Math.max(4,o.data.byteLength),usage:s==="index"?GPUBufferUsage.INDEX|GPUBufferUsage.COPY_DST:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST}),n.queue.writeBuffer(o.buffer,0,o.data);t.geometry={device:n,attributes:i,drawRange:{start:0,count:i.index?.count||i.position.count}};for(const s of Object.values(u.attributes))s.buffer.destroy();t.bindGroup=null,t.boundTextures=[];for(const s of["baseTexture","metalTexture","emissiveTexture","occlusionTexture"]){const o=f[s];!o||o.device===n||(f[s]={...o,device:n,texture:n.createTexture({size:[o.image.width,o.image.height],format:o.format,usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT}),sampler:n.createSampler(o.samplerOptions),uploaded:null})}t.program.pipelineCache.clear(),t.program=E(e,f),t.device=n}t.texture&&t.texture.device!==r.renderer.device&&(t.texture={...t.texture,device:r.renderer.device,texture:r.renderer.device.createTexture({size:[t.texture.image.width,t.texture.image.height],format:t.texture.format,usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT}),sampler:r.renderer.device.createSampler(t.texture.samplerOptions),uploaded:null})}),N(r),(e.header&&e._type!=="pmtiles"||e._geojson)&&B(e)}export{Q as attach};
-//# sourceMappingURL=attach.js.map