leaflet-city-mapper 0.0.4 → 0.0.6

package/src/sources/releaseArea.js

@@ -1,23 +1,25 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { highlightedFeatureByLayer } from '../weakmaps/highlightedFeatureByLayer.js';
+import { hoveredFeatureByLayer } from '../weakmaps/hoveredFeatureByLayer.js';
+
 
 
 import { setHighlight } from '../picking/setHighlight.js';
 import { showFeature } from '../picking/showFeature.js';
 import { setParent } from '../scene/setParent.js';
-import { update } from '../scene/update.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
 
 /** Cancel pending work and dispose this block's GPU data, including any hover highlight. */
-export function releaseArea(backend, area) {
+export function releaseArea(layer, area) {
   area.request.abort();
   let attribute;
   if (area.mesh) {
-    if (sceneByLayer.get(backend).highlightedFeature?.mesh === area.mesh) {
-      setHighlight(backend, null);
-      sceneByLayer.get(backend).hoveredFeature = null;
-      showFeature(backend, null);
+    if (highlightedFeatureByLayer.get(layer)?.mesh === area.mesh) {
+      setHighlight(layer, null);
+      hoveredFeatureByLayer.set(layer, null);
+      showFeature(layer, null);
     }
     setParent(area.mesh, null);
-    update(backend);
+    update(layer);
     const geometry = area.mesh.geometry;
     for (attribute of Object.values(geometry.attributes)) attribute.buffer.destroy();
     area.mesh.program.pipelineCache.clear();

package/src/sources/setGeoJSONData.js

@@ -1,4 +1,5 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+
 
 
 import { releaseArea } from './releaseArea.js';
@@ -8,8 +9,8 @@ export function setGeoJSONData(layer, data) {
   layer.options.data = data;
   delete layer.options.url;
   let area;
-  for (area of sceneByLayer.get(layer)._areas.values()) releaseArea(layer, area);
-  sceneByLayer.get(layer)._areas.clear();
+  for (area of areasByLayer.get(layer).values()) releaseArea(layer, area);
+  areasByLayer.get(layer).clear();
   updateArea(layer);
   return layer;
 }

package/src/sources/sourceAreaContext.js

@@ -1,19 +1,20 @@
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+
 import { radians } from '../globals/radians.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
-
-export function sourceAreaContext(backend, area, map) {
-  const crs = map.options.crs, origin = crs.project(sceneByLayer.get(backend).location);
-  return /* alloc */ {
-    backend, area, map, crs, origin,
-    metres: Math.cos(sceneByLayer.get(backend).location.lat * radians),
-    positions: /* alloc */ [],
-    normals: /* alloc */ [],
-    colors: /* alloc */ [],
-    uvs: /* alloc */ [],
-    featureFaces: /* alloc */ [],
-    lights: /* alloc */ [],
-    supports: /* alloc */ new Set(),
-    skipped: 0,
-  };
-}
+
+export function sourceAreaContext(layer, area, map) {
+  const crs = map.options.crs, origin = crs.project(locationByLayer.get(layer));
+  return /* alloc */ {
+    backend: layer, area, map, crs, origin,
+    metres: Math.cos(locationByLayer.get(layer).lat * radians),
+    positions: /* alloc */ [],
+    normals: /* alloc */ [],
+    colors: /* alloc */ [],
+    uvs: /* alloc */ [],
+    featureFaces: /* alloc */ [],
+    lights: /* alloc */ [],
+    supports: /* alloc */ new Set(),
+    skipped: 0,
+  };
+}

package/src/sources/updateArea.js

@@ -1,29 +1,33 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
 
 
-import { pump } from "./pump.js";
+
+import { pump } from "./pumpSourceAreas.js";
 import { releaseArea } from './releaseArea.js';
 import { compareAreaDistance } from './compareAreaDistance.js';
 
 /** Cover the visible ground bounds and one bordering block, clipped to the archive. */
 
-export function updateArea(backend) {
-  if (!backend._map || !sceneByLayer.get(backend)._shared) return;
-  if (sceneByLayer.get(backend)._geojson) {
-    if (!sceneByLayer.get(backend)._areas.has('geojson')) {
-      sceneByLayer.get(backend)._areas.set('geojson', /* alloc */ { request: /* alloc */ new AbortController() });
+export function updateArea(layer) {
+  if (!layer._map || !sharedByLayer.get(layer)) return;
+  if (geojsonByLayer.get(layer)) {
+    if (!areasByLayer.get(layer).has('geojson')) {
+      areasByLayer.get(layer).set('geojson', /* alloc */ { request: /* alloc */ new AbortController() });
     }
-    pump(backend);
+    pump(layer);
     return;
   }
-  if (!sceneByLayer.get(backend).header) return;
-  const z = sceneByLayer.get(backend).header.minZoom;
-  const center = backend._map.project(backend._map.getCenter(), z).divideBy(256).floor();
-  const bounds = backend._map.getBounds();
-  const nw = backend._map.project(bounds.getNorthWest(), z).divideBy(256).floor();
-  const se = backend._map.project(bounds.getSouthEast(), z).divideBy(256).floor();
-  const archiveNW = backend._map.project(/* alloc */ [sceneByLayer.get(backend).header.maxLat, sceneByLayer.get(backend).header.minLon], z).divideBy(256).floor();
-  const archiveSE = backend._map.project(/* alloc */ [sceneByLayer.get(backend).header.minLat, sceneByLayer.get(backend).header.maxLon], z).divideBy(256).floor();
+  if (!headerByLayer.get(layer)) return;
+  const z = headerByLayer.get(layer).minZoom;
+  const center = layer._map.project(layer._map.getCenter(), z).divideBy(256).floor();
+  const bounds = layer._map.getBounds();
+  const nw = layer._map.project(bounds.getNorthWest(), z).divideBy(256).floor();
+  const se = layer._map.project(bounds.getSouthEast(), z).divideBy(256).floor();
+  const archiveNW = layer._map.project(/* alloc */ [headerByLayer.get(layer).maxLat, headerByLayer.get(layer).minLon], z).divideBy(256).floor();
+  const archiveSE = layer._map.project(/* alloc */ [headerByLayer.get(layer).minLat, headerByLayer.get(layer).maxLon], z).divideBy(256).floor();
   const wanted = /* alloc */ new Map();
   let x, y, key, area, coords;
   for (x = Math.max(0, nw.x - 1, archiveNW.x); x <= Math.min(2 ** z - 1, se.x + 1, archiveSE.x); x++) {
@@ -31,10 +35,10 @@ export function updateArea(backend) {
       wanted.set(`${x}/${y}`, /* alloc */ { z, x, y });
     }
   }
-  for ([key, area] of sceneByLayer.get(backend)._areas) {
+  for ([key, area] of areasByLayer.get(layer)) {
     if (!wanted.has(key)) {
-      releaseArea(backend, area);
-      sceneByLayer.get(backend)._areas.delete(key);
+      releaseArea(layer, area);
+      areasByLayer.get(layer).delete(key);
     }
   }
   // Load the nearest new blocks first without rebuilding retained geometry.
@@ -46,7 +50,7 @@ export function updateArea(backend) {
   areas.sort(compareAreaDistance);
   for (coords of areas) {
     key = `${coords.x}/${coords.y}`;
-    if (!sceneByLayer.get(backend)._areas.has(key)) sceneByLayer.get(backend)._areas.set(key, /* alloc */ { coords, request: /* alloc */ new AbortController() });
+    if (!areasByLayer.get(layer).has(key)) areasByLayer.get(layer).set(key, /* alloc */ { coords, request: /* alloc */ new AbortController() });
   }
-  pump(backend);
+  pump(layer);
 }

package/src/sources/{updateStatus.js → updateSourceStatus.js}

@@ -1,15 +1,16 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+
 
 
 /** Emit a snapshot for consumers; ready does not wait for all neighborhood tasks. */
-export function updateStatus(backend, enabled = true) {
+export function updateStatus(layer, enabled = true) {
   const progress = /* alloc */ { enabled, loaded: 0, skipped: 0, pending: 0, errors: /* alloc */ [] };
   let area;
-  for (area of sceneByLayer.get(backend)._areas.values()) {
+  for (area of areasByLayer.get(layer).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);
+  layer.fire('progress', progress);
 }

package/src/sunlight/{addTo.js → addTimeControlToMap.js}

@@ -1,5 +1,5 @@
 import { L } from '../globals/L.js';
-import { underEntry } from '../scene/underEntry.js';
+import { underEntry } from '../layer-controls/underEntry.js';
 import { styleTimeControl } from './styleTimeControl.js';
 
 export function addTo(map) {

package/src/sunlight/addTimeLayer.js

@@ -1,6 +1,7 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { controlByLayer } from '../weakmaps/controlByLayer.js';
+
 
 
 export function addTimeLayer(map) {
-  return sceneByLayer.get(this).control.addTo(map);
+  return controlByLayer.get(this).addTo(map);
 }

package/src/sunlight/atmosphere.js

@@ -1,8 +1,8 @@
 import { atmosphereStops } from '../globals/atmosphereStops.js';
 import { atmosphereColor } from '../globals/atmosphereColor.js';
 
-import { mix } from './mix.js';
-import { rgb } from './rgb.js';
+import { mix } from '../colors/mixColor.js';
+import { rgb } from '../colors/formatRGB.js';
 
 
 export function atmosphere(altitude) {

package/src/sunlight/initSunlight.js

@@ -1,10 +1,10 @@
 import { L } from '../globals/L.js';
 import { onAddSun } from './onAddSun.js';
-import { underEntry } from '../scene/underEntry.js';
-import { initialize } from './initialize.js';
-import { onAdd } from './onAdd.js';
-import { addTo } from './addTo.js';
-import { remove } from './remove.js';
+import { underEntry } from '../layer-controls/underEntry.js';
+import { initialize } from './initializeTimeControl.js';
+import { onAdd } from './onAddTimeControl.js';
+import { addTo } from './addTimeControlToMap.js';
+import { remove } from './removeTimeControl.js';
 import { onRemoveSun } from './onRemoveSun.js';
 
 L.Control.Time = L.Control.extend({

package/src/sunlight/{initialize.js → initializeTimeControl.js}

@@ -1,5 +1,7 @@
+import { controlByLayer } from '../weakmaps/controlByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 import { addTimeLayer } from './addTimeLayer.js';
@@ -9,6 +11,6 @@ export function initialize(options) {
   L.Util.setOptions(this, options);
   this.live = true;
   this.layer = /* alloc */ new L.Layer();
-  sceneByLayer.get(this.layer).control = this;
-  sceneByLayer.get(this.layer).kind = 'time';
+  controlByLayer.set(this.layer, this);
+  kindByLayer.set(this.layer, 'time');
 }

package/src/sunlight/onAddSun.js

@@ -1,6 +1,7 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
-import { sunlightByControl } from '../globals/sunlightByControl.js';
-import { sunByMap } from '../globals/sunByMap.js';
+import { timeControlByMap } from '../weakmaps/timeControlByMap.js';
+
+import { sunlightByControl } from '../weakmaps/sunlightByControl.js';
+import { sunByMap } from '../weakmaps/sunByMap.js';
 import { createSun } from './createSun.js';
 import { tickSun } from './tickSun.js';
 
@@ -17,7 +18,7 @@ export function onAddSun(control, map) {
   }
   state.control = control;
   state.originalSky = map.getContainer().style.getPropertyValue('--leaflet-sky-background');
-  cameraByMap.get(map)._timeControl = control;
+  timeControlByMap.set(map, control);
   sunlightByControl.set(control, state);
   state.update();
   state.timer = setInterval(tickSun, 60000, state);

package/src/sunlight/onRemoveSun.js

@@ -1,4 +1,4 @@
-import { sunlightByControl } from '../globals/sunlightByControl.js';
+import { sunlightByControl } from '../weakmaps/sunlightByControl.js';
 
 import { removeSun } from './removeSun.js';
 

package/src/sunlight/removeSun.js

@@ -1,19 +1,21 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
-import { sunByMap } from '../globals/sunByMap.js';
+import { sunlightByMap } from '../weakmaps/sunlightByMap.js';
+import { timeControlByMap } from '../weakmaps/timeControlByMap.js';
+
+import { sunByMap } from '../weakmaps/sunByMap.js';
 
 
-import { render } from './render.js';
+import { render } from './requestSunlightRender.js';
 import { updateSky } from './updateSky.js';
 
 export function removeSun(state) {
   const { map, timer, sunDisc, moonDisc } = state;
   const shared = sunByMap.get(map);
   clearInterval(timer);
-  delete cameraByMap.get(map)._timeControl;
+  timeControlByMap.delete(map);
   map.fire('simulationtimechange', /* alloc */ { time: null, live: false });
   map.off('moveend', state.update);
   map.off('move rotate pitch resize', state.updateSky);
-  delete cameraByMap.get(map)._sunlight;
+  sunlightByMap.delete(map);
   updateSky(state);
   sunDisc.remove(); moonDisc.remove();
   render(map);

package/src/sunlight/removeTimeLayer.js

@@ -1,7 +1,8 @@
+import { controlByLayer } from '../weakmaps/controlByLayer.js';
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 export function removeTimeLayer() {
-  return L.Control.prototype.remove.call(sceneByLayer.get(this).control);
+  return L.Control.prototype.remove.call(controlByLayer.get(this));
 }

package/src/sunlight/requestSunlightRender.js

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

package/src/sunlight/updateCelestialDisc.js

@@ -1,4 +1,4 @@
-import { projectCelestialBody } from './projectCelestialBody.js';
+import { projectCelestialBody } from '../projections/projectCelestialBody.js';
 
 export function updateCelestialDisc(disc, body, sky, size, pitch, bearing, projection) {
   disc.hidden = true;

package/src/sunlight/updateSky.js

@@ -1,5 +1,7 @@
+import { pitchSkyByMap } from '../weakmaps/pitchSkyByMap.js';
+import { sunlightByMap } from '../weakmaps/sunlightByMap.js';
+
 import { radians } from '../globals/radians.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
 
 import { mapGetPitch } from '../camera/mapGetPitch.js';
 import { mapGetBearing } from '../camera/mapGetBearing.js';
@@ -7,7 +9,7 @@ import { mapGetBearing } from '../camera/mapGetBearing.js';
 import { updateCelestialDisc } from './updateCelestialDisc.js';
 
 export function updateSky({ map, originalSky, sunDisc, moonDisc, projection }) {
-  const sun = cameraByMap.get(map)._sunlight, sky = cameraByMap.get(map)._pitchSky;
+  const sun = sunlightByMap.get(map), sky = pitchSkyByMap.get(map);
   if (sun) map.getContainer().style.setProperty('--leaflet-sky-background', sun.background);
   else if (originalSky) map.getContainer().style.setProperty('--leaflet-sky-background', originalSky);
   else map.getContainer().style.removeProperty('--leaflet-sky-background');

package/src/sunlight/updateSun.js

@@ -1,10 +1,11 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { sunlightByMap } from '../weakmaps/sunlightByMap.js';
+
 
 
 import { atmosphere } from './atmosphere.js';
-import { moonPosition } from './moonPosition.js';
-import { solarPosition } from './solarPosition.js';
-import { render } from './render.js';
+import { moonPosition } from '../astronomy/moonPosition.js';
+import { solarPosition } from '../astronomy/solarPosition.js';
+import { render } from './requestSunlightRender.js';
 import { updateSky } from './updateSky.js';
 
 export function updateSun(state) {
@@ -16,7 +17,8 @@ export function updateSun(state) {
     slider.value = String(control.time.getUTCHours() * 60 + control.time.getUTCMinutes());
     output.textContent = `${time.slice(11, 16)} UTC${control.live ? ' · now' : ''}`;
     const center = map.getCenter();
-    const sun = cameraByMap.get(map)._sunlight = solarPosition(control.time, center.lat, center.lng);
+    const sun = solarPosition(control.time, center.lat, center.lng);
+    sunlightByMap.set(map, sun);
     Object.assign(sun, atmosphere(sun.altitude));
     sun.moon = moonPosition(control.time, center.lat, center.lng);
     status.textContent = sun.altitude <= 0
@@ -31,7 +33,7 @@ export function updateSun(state) {
     updateSky(state);
     render(map);
   } catch (error) {
-    delete cameraByMap.get(map)._sunlight;
+    sunlightByMap.delete(map);
     updateSky(state);
     render(map);
     status.textContent = `Error: ${error.message}`;

package/src/sunlight/useSelectedTime.js

@@ -1,7 +1,8 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { sunlightByMap } from '../weakmaps/sunlightByMap.js';
+
 
 
-import { render } from './render.js';
+import { render } from './requestSunlightRender.js';
 import { updateSky } from './updateSky.js';
 import { updateSun } from './updateSun.js';
 
@@ -11,7 +12,7 @@ export function useSelectedTime(state) {
   if (!date.value || !date.validity.valid) {
     control.time = /* alloc */ new Date(NaN);
     map.fire('simulationtimechange', /* alloc */ { time: null, live: false });
-    delete cameraByMap.get(map)._sunlight;
+    sunlightByMap.delete(map);
     updateSky(state);
     render(map);
     status.textContent = 'Error: choose a valid solar date';

package/src/terrain/applyTerrain.js

@@ -1,21 +1,24 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { terrainOriginElevationByLayer } from '../weakmaps/terrainOriginElevationByLayer.js';
+import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
+
 import { addBridges } from '../geometry/addBridges.js';
 import { conformModelToTerrain } from '../geometry/conformModelToTerrain.js';
 import { getElevation } from './getElevation.js';
 import { setTerrainHeight } from './setTerrainHeight.js';
-import { update } from '../scene/update.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
 
-export function applyTerrain(backend, map, bridges) {
-  const scene = sceneByLayer.get(backend);
-  scene._terrainReady = true;
-  scene._terrainOriginElevation = getElevation(backend, scene.location) ?? 0;
-  let layer;
-  for (layer of Object.values(map._layers)) {
-    setTerrainHeight(layer);
-    conformModelToTerrain(layer, backend);
+export function applyTerrain(layer, map, bridges) {
+
+  terrainReadyByLayer.set(layer, true);
+  terrainOriginElevationByLayer.set(layer, getElevation(layer, locationByLayer.get(layer)) ?? 0);
+  let mapLayer;
+  for (mapLayer of Object.values(map._layers)) {
+    setTerrainHeight(mapLayer);
+    conformModelToTerrain(mapLayer, layer);
   }
-  if (bridges) addBridges(backend, bridges);
+  if (bridges) addBridges(layer, bridges);
   map.fire('terrainchange');
-  update(backend);
-  backend.fire('terrainready');
+  update(layer);
+  layer.fire('terrainready');
 }

package/src/terrain/clearLayerTerrain.js

@@ -1,8 +1,9 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
 
 
 import { setRasterTerrain } from '../raster/setRasterTerrain.js';
 
 export function clearLayerTerrain(layer) {
-  if (sceneByLayer.get(layer).kind === 'raster') setRasterTerrain(layer, null);
+  if (kindByLayer.get(layer) === 'raster') setRasterTerrain(layer, null);
 }

package/src/terrain/getElevation.js

@@ -1,5 +1,9 @@
+import { bridgesByLayer } from '../weakmaps/bridgesByLayer.js';
+import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
+import { terrainTilesByLayer } from '../weakmaps/terrainTilesByLayer.js';
+import { terrainZoomByLayer } from '../weakmaps/terrainZoomByLayer.js';
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 import { bridgeElevation } from '../geometry/bridgeElevation.js';
@@ -7,8 +11,8 @@ import { terrainElevation } from './terrainElevation.js';
 
 /** @param {L.LatLng|L.Point} location LatLng, or a pixel point at the terrain zoom. */
 
-export function getElevation(backend, location) {
-  if (!backend._map || !sceneByLayer.get(backend)._terrainReady) return null;
-  const point = location instanceof L.Point ? location : backend._map.project(location, sceneByLayer.get(backend)._terrainZoom);
-  return bridgeElevation(point, sceneByLayer.get(backend)._bridges) ?? terrainElevation(point, sceneByLayer.get(backend)._terrainTiles);
+export function getElevation(layer, location) {
+  if (!layer._map || !terrainReadyByLayer.get(layer)) return null;
+  const point = location instanceof L.Point ? location : layer._map.project(location, terrainZoomByLayer.get(layer));
+  return bridgeElevation(point, bridgesByLayer.get(layer)) ?? terrainElevation(point, terrainTilesByLayer.get(layer));
 }

package/src/terrain/initTerrain.js

@@ -1,4 +1,9 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
+import { terrainSourceByLayer } from '../weakmaps/terrainSourceByLayer.js';
+import { terrainTilesByLayer } from '../weakmaps/terrainTilesByLayer.js';
+
 
 
 import { onTerrainRemove } from './onTerrainRemove.js';
@@ -15,9 +20,9 @@ export function initTerrain(layer, options) {
   const layerOptions = /* alloc */ { ...options };
   delete layerOptions.url;
   init3D(layer, layerOptions);
-  sceneByLayer.get(layer).terrainSource = terrainSource;
-  sceneByLayer.get(layer)._terrainTiles = /* alloc */ new Map();
-  sceneByLayer.get(layer)._rasterTiles = /* alloc */ new Map();
-  sceneByLayer.get(layer)._terrainReady = false;
-  sceneByLayer.get(layer).kind = 'terrain';
+  terrainSourceByLayer.set(layer, terrainSource);
+  terrainTilesByLayer.set(layer, /* alloc */ new Map());
+  rasterTilesByLayer.set(layer, /* alloc */ new Map());
+  terrainReadyByLayer.set(layer, false);
+  kindByLayer.set(layer, 'terrain');
 }

package/src/terrain/loadTerrain.js

@@ -1,4 +1,11 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+import { terrainArchiveByLayer } from '../weakmaps/terrainArchiveByLayer.js';
+import { terrainControllerByLayer } from '../weakmaps/terrainControllerByLayer.js';
+import { terrainLoadingByLayer } from '../weakmaps/terrainLoadingByLayer.js';
+import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
+import { terrainSourceByLayer } from '../weakmaps/terrainSourceByLayer.js';
+
 import { createLayer } from '../scene/createLayer.js';
 
 import { loadTerrainTiles } from './loadTerrainTiles.js';
@@ -6,38 +13,40 @@ import { readBridges } from './readBridges.js';
 import { terrainTileQueue } from './terrainTileQueue.js';
 import { applyTerrain } from './applyTerrain.js';
 
-export async function loadTerrain(backend) {
-  if (sceneByLayer.get(backend)._terrainLoading || !backend._map) return;
-  sceneByLayer.get(backend)._terrainLoading = true;
-  sceneByLayer.get(backend)._terrainReady = false;
-  const controller = sceneByLayer.get(backend)._terrainController = /* alloc */ new AbortController();
+export async function loadTerrain(layer) {
+  if (terrainLoadingByLayer.get(layer) || !layer._map) return;
+  terrainLoadingByLayer.set(layer, true);
+  terrainReadyByLayer.set(layer, false);
+  const controller = /* alloc */ new AbortController();
+  terrainControllerByLayer.set(layer, controller);
   let i;
   try {
-    if (!sceneByLayer.get(backend).terrainSource) throw /* alloc */ new Error('Terrain layer requires a PMTiles or COG elevation archive');
-    const archive = sceneByLayer.get(backend)._terrainArchive = createLayer(/* alloc */ { source: /* alloc */ {
-      type: backend.options.asset !== undefined || /\.tiff?(?:[?#]|$)/i.test(sceneByLayer.get(backend).terrainSource) ? 'cog' : 'pmtiles',
-      url: sceneByLayer.get(backend).terrainSource, archive: backend.options.archive, asset: backend.options.asset,
+    if (!terrainSourceByLayer.get(layer)) throw /* alloc */ new Error('Terrain layer requires a PMTiles or COG elevation archive');
+    const archive = createLayer(/* alloc */ { source: /* alloc */ {
+      type: layer.options.asset !== undefined || /\.tiff?(?:[?#]|$)/i.test(terrainSourceByLayer.get(layer)) ? 'cog' : 'pmtiles',
+      url: terrainSourceByLayer.get(layer), archive: layer.options.archive, asset: layer.options.asset,
     } });
-    await sceneByLayer.get(archive).ready;
-    const header = sceneByLayer.get(archive).header;
+    terrainArchiveByLayer.set(layer, archive);
+    await readyByLayer.get(archive);
+    const header = headerByLayer.get(archive);
     if (header.tileType !== 0 || header.minZoom !== header.maxZoom) {
       throw /* alloc */ new Error('Expected a single-zoom Float32 terrain archive');
     }
-    const map = backend._map;
-    const tiles = terrainTileQueue(backend, header);
-    const state = /* alloc */ { backend, archive, controller, tiles, next: 0 };
+    const map = layer._map;
+    const tiles = terrainTileQueue(layer, header);
+    const state = /* alloc */ { backend: layer, archive, controller, tiles, next: 0 };
     const workers = /* alloc */ [];
     for (i = 0; i < Math.min(4, tiles.length); i++) workers.push(loadTerrainTiles(state));
     await Promise.all(workers);
-    const bridges = backend.options.bridges && await fetch(backend.options.bridges, /* alloc */ { signal: controller.signal })
+    const bridges = layer.options.bridges && await fetch(layer.options.bridges, /* alloc */ { signal: controller.signal })
       .then(readBridges);
-    if (controller.signal.aborted || backend._map !== map) return;
-    applyTerrain(backend, map, bridges);
+    if (controller.signal.aborted || layer._map !== map) return;
+    applyTerrain(layer, map, bridges);
     return true;
   } catch (error) {
-    if (!controller.signal.aborted) backend.fire('error', /* alloc */ { error });
+    if (!controller.signal.aborted) layer.fire('error', /* alloc */ { error });
     return false;
   } finally {
-    sceneByLayer.get(backend)._terrainLoading = false;
+    terrainLoadingByLayer.set(layer, false);
   }
 }

package/src/terrain/loadTerrainTiles.js

@@ -1,8 +1,9 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { terrainTilesByLayer } from '../weakmaps/terrainTilesByLayer.js';
+
 
 
 export async function loadTerrainTiles(state) {
-  const { backend, archive, controller, tiles } = state;
+  const { backend: layer, archive, controller, tiles } = state;
   let coords, result;
   while (state.next < tiles.length) {
     controller.signal.throwIfAborted();
@@ -11,7 +12,7 @@ export async function loadTerrainTiles(state) {
     if (!result || result.data.byteLength !== 256 * 256 * 4) {
       throw /* alloc */ new Error(`Missing or invalid Float32 terrain tile ${coords.z}/${coords.x}/${coords.y}`);
     }
-    sceneByLayer.get(backend)._terrainTiles.set(`${coords.x}/${coords.y}`, /* alloc */ new Float32Array(result.data));
+    terrainTilesByLayer.get(layer).set(`${coords.x}/${coords.y}`, /* alloc */ new Float32Array(result.data));
   }
 }
 import { getZxy } from '../archives/getZxy.js';

package/src/terrain/mapElevationOf.js

@@ -0,0 +1,7 @@
+import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+import { getElevation } from './getElevation.js';
+
+export function mapElevationOf(map, location) {
+  const terrain = terrain3DByMap.get(map);
+  return terrain && getElevation(terrain, location);
+}