leaflet-city-mapper 0.0.3 → 0.0.4

package/src/sunlight/rgb.js

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

package/src/sunlight/solarPosition.js

@@ -1,17 +1,18 @@
 import { horizontalPosition } from "./horizontalPosition.js";
+import { solarTime } from './solarTime.js';
+import { radians } from '../globals/radians.js';
+import { sinObliquity } from '../globals/sinObliquity.js';
+import { cosObliquity } from '../globals/cosObliquity.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 time = solarTime(date, lat, lng);
+  const d = time / 86400000 - 10957.5;
+  const mean = (357.5291 + 0.98560028 * d) * radians;
   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));
+    0.0003 * Math.sin(3 * mean) + 102.9372 + 180) * radians;
+  const declination = Math.asin(Math.sin(longitude) * sinObliquity);
+  const ascension = Math.atan2(Math.sin(longitude) * cosObliquity, Math.cos(longitude));
   return horizontalPosition(d, lat, lng, ascension, declination);
 }

package/src/sunlight/solarTime.js

@@ -0,0 +1,11 @@
+/** Normalize dates and validate the observer without calculating a celestial position. */
+export function solarTime(date, lat, lng) {
+  const time = date instanceof Date ? Date.prototype.getTime.call(date)
+    : typeof date === 'string' ? Date.parse(date)
+    : (/* alloc */ new Date(date)).getTime();
+  if (!Number.isFinite(time) || !Number.isFinite(lat) || Math.abs(lat) > 90 ||
+    !Number.isFinite(lng) || Math.abs(lng) > 180) {
+    throw /* alloc */ new Error('Invalid solar date or location');
+  }
+  return time;
+}

package/src/sunlight/styleTimeControl.js

@@ -1,7 +1,7 @@
 export function styleTimeControl(container, nested) {
   container.classList.toggle('leaflet-control', !nested);
   container.classList.toggle('leaflet-bar', !nested);
-  Object.assign(container.style, nested
-    ? { background: '', padding: '2px 0 6px 20px', margin: '0' }
-    : { background: '#fff', padding: '8px', margin: '' });
+  container.style.background = nested ? '' : '#fff';
+  container.style.padding = nested ? '2px 0 6px 20px' : '8px';
+  container.style.margin = nested ? '0' : '';
 }

package/src/sunlight/updateCelestialDisc.js

@@ -0,0 +1,12 @@
+import { projectCelestialBody } from './projectCelestialBody.js';
+
+export function updateCelestialDisc(disc, body, sky, size, pitch, bearing, projection) {
+  disc.hidden = true;
+  if (!sky || !body || body.altitude <= 0) return;
+  if (disc.parentNode !== sky) sky.append(disc);
+  const point = projectCelestialBody(body.direction, size, pitch, bearing, projection);
+  if (!point) return;
+  const { left, top } = point;
+  disc.hidden = left < 0 || left > size.x || top < 0 || top > sky.clientHeight || sky.style.display === 'none';
+  disc.style.left = `${left}px`; disc.style.top = `${top}px`;
+}

package/src/sunlight/updateSky.js

@@ -1,20 +1,17 @@
-import { projectCelestialBody } from './projectCelestialBody.js';
+import { radians } from '../globals/radians.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
 
-export function updateSky({ map, originalSky, sunDisc, moonDisc }) {
-  const sun = map._sunlight, sky = map._pitchSky;
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+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;
   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');
-  const size = map.getSize(), pitch = map.getPitch() * Math.PI / 180, bearing = map.getBearing() * Math.PI / 180;
-  let disc, body, point, left, top;
-  for ([disc, body] of [[sunDisc, sun], [moonDisc, sun?.moon]]) {
-    disc.hidden = true;
-    if (!sky || !body || body.altitude <= 0 || !sun) continue;
-    if (disc.parentNode !== sky) sky.append(disc);
-    point = projectCelestialBody(body.direction, size, pitch, bearing);
-    if (!point) continue;
-    ({ left, top } = point);
-    disc.hidden = left < 0 || left > size.x || top < 0 || top > sky.clientHeight || sky.style.display === 'none';
-    disc.style.left = `${left}px`; disc.style.top = `${top}px`;
-  }
+  const size = map.getSize(), pitch = mapGetPitch(map) * radians, bearing = mapGetBearing(map) * radians;
+  updateCelestialDisc(sunDisc, sun, sky, size, pitch, bearing, projection);
+  updateCelestialDisc(moonDisc, sun?.moon, sky, size, pitch, bearing, projection);
 }

package/src/sunlight/updateSun.js

@@ -1,3 +1,6 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
 import { atmosphere } from './atmosphere.js';
 import { moonPosition } from './moonPosition.js';
 import { solarPosition } from './solarPosition.js';
@@ -7,13 +10,13 @@ import { updateSky } from './updateSky.js';
 export function updateSun(state) {
   const { control, map, date, slider, output, status } = state;
   try {
-    if (control.live) control.time = new Date();
+    if (control.live) control.time = /* alloc */ new Date();
     const time = control.time.toISOString();
     date.value = time.slice(0, 10);
     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 = map._sunlight = solarPosition(control.time, center.lat, center.lng);
+    const sun = cameraByMap.get(map)._sunlight = solarPosition(control.time, center.lat, center.lng);
     Object.assign(sun, atmosphere(sun.altitude));
     sun.moon = moonPosition(control.time, center.lat, center.lng);
     status.textContent = sun.altitude <= 0
@@ -21,11 +24,14 @@ export function updateSun(state) {
       : sun.altitude < 3
         ? 'Low sun · shadows paused'
         : `Sun altitude ${sun.altitude.toFixed(1)}°`;
-    map.fire('simulationtimechange', { time: new Date(control.time), live: control.live });
+    map.fire('simulationtimechange', /* alloc */ {
+      time: /* alloc */ new Date(control.time),
+      live: control.live,
+    });
     updateSky(state);
     render(map);
   } catch (error) {
-    delete map._sunlight;
+    delete cameraByMap.get(map)._sunlight;
     updateSky(state);
     render(map);
     status.textContent = `Error: ${error.message}`;

package/src/sunlight/useSelectedTime.js

@@ -1,3 +1,6 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
 import { render } from './render.js';
 import { updateSky } from './updateSky.js';
 import { updateSun } from './updateSun.js';
@@ -6,15 +9,15 @@ export function useSelectedTime(state) {
   const { control, map, date, slider, status } = state;
   control.live = false;
   if (!date.value || !date.validity.valid) {
-    control.time = new Date(NaN);
-    map.fire('simulationtimechange', { time: null, live: false });
-    delete map._sunlight;
+    control.time = /* alloc */ new Date(NaN);
+    map.fire('simulationtimechange', /* alloc */ { time: null, live: false });
+    delete cameraByMap.get(map)._sunlight;
     updateSky(state);
     render(map);
     status.textContent = 'Error: choose a valid solar date';
     return;
   }
-  control.time = new Date(`${date.value}T00:00:00Z`);
+  control.time = /* alloc */ new Date(`${date.value}T00:00:00Z`);
   control.time.setUTCMinutes(Number(slider.value));
   updateSun(state);
 }

package/src/terrain/applyTerrain.js

@@ -0,0 +1,21 @@
+import { sceneByLayer } from '../globals/sceneByLayer.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';
+
+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);
+  }
+  if (bridges) addBridges(backend, bridges);
+  map.fire('terrainchange');
+  update(backend);
+  backend.fire('terrainready');
+}

package/src/terrain/clearLayerTerrain.js

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

package/src/terrain/copyTerrainTile.js

@@ -0,0 +1,12 @@
+export function copyTerrainTile(atlas, values, start, columns) {
+  let row, column, value;
+  for (row = 0; row < 256; row++) {
+    for (column = 0; column < 256; column++) {
+      value = values[row * 256 + column];
+      if (!Number.isFinite(value) || value <= -1000) continue;
+      atlas.elevations[start + row * columns * 256 + column] = value;
+      atlas.low = Math.min(atlas.low, value);
+      atlas.high = Math.max(atlas.high, value);
+    }
+  }
+}

package/src/terrain/getElevation.js

@@ -1,10 +1,14 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { bridgeElevation } from '../geometry/bridgeElevation.js';
 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 || !backend._terrainReady) return null;
-  const point = location instanceof L.Point ? location : backend._map.project(location, backend._terrainZoom);
-  return bridgeElevation(point, backend._bridges) ?? terrainElevation(point, backend._terrainTiles);
+  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);
 }

package/src/terrain/initTerrain.js

@@ -1,20 +1,23 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { onTerrainRemove } from './onTerrainRemove.js';
 import { onTerrainAdd } from './onTerrainAdd.js';
 import { init3D } from '../scene/init3D.js';
 
 /**
- * Renders IGN Float32 DEM tiles and PMTiles raster basemaps in the shared WebGPU scene.
- * Source options: `url` (single-zoom Float32 PMTiles DEM); `bridges` (optional GeoJSON deck polygons with Z, see _addBridges).
+ * Renders Float32 DEM tiles and archived raster basemaps in the shared WebGPU scene.
+ * Source options: `url` (single-zoom Float32 PMTiles or supported COG DEM);
+ * `bridges` (optional GeoJSON deck polygons with Z, see _addBridges).
  */
 export function initTerrain(layer, options) {
   const terrainSource = options.url;
-  const layerOptions = { ...options };
+  const layerOptions = /* alloc */ { ...options };
   delete layerOptions.url;
   init3D(layer, layerOptions);
-  layer.terrainSource = terrainSource;
-  layer._terrainTiles = new Map();
-  layer._rasterTiles = new Map();
-  layer._terrainReady = false;
-  layer.onAdd = onTerrainAdd.bind(null, layer);
-  layer.onRemove = onTerrainRemove.bind(null, layer);
+  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';
 }

package/src/terrain/loadTerrain.js

@@ -1,63 +1,43 @@
-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 { compareDistance } from '../utils/compareDistance.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { createLayer } from '../scene/createLayer.js';
+
 import { loadTerrainTiles } from './loadTerrainTiles.js';
 import { readBridges } from './readBridges.js';
-
+import { terrainTileQueue } from './terrainTileQueue.js';
+import { applyTerrain } from './applyTerrain.js';
 
 export async function loadTerrain(backend) {
-  if (backend._terrainLoading || !backend._map) return;
-  backend._terrainLoading = true;
-  backend._terrainReady = false;
-  const controller = backend._terrainController = new AbortController();
-  let x, y, i, layer;
+  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();
+  let i;
   try {
-    if (!backend.terrainSource) throw new Error('Terrain layer requires a PMTiles elevation archive');
-    const archive = backend._terrainArchive = new L.Layer({ source: { type: 'pmtiles', url: backend.terrainSource } });
-    await archive.ready;
-    const header = archive.header;
+    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,
+    } });
+    await sceneByLayer.get(archive).ready;
+    const header = sceneByLayer.get(archive).header;
     if (header.tileType !== 0 || header.minZoom !== header.maxZoom) {
-      throw new Error('Expected a single-zoom Float32 PMTiles terrain archive');
+      throw /* alloc */ new Error('Expected a single-zoom Float32 terrain archive');
     }
-    backend._terrainZoom = header.maxZoom;
     const map = backend._map;
-    const northwest = map.project([header.maxLat, header.minLon], backend._terrainZoom).divideBy(256).floor();
-    const southeast = map.project([header.minLat, header.maxLon], backend._terrainZoom).divideBy(256).floor();
-    backend._terrainBounds = new L.Bounds(northwest, southeast);
-    const tiles = [];
-    const center = map.project(map.getCenter(), backend._terrainZoom).divideBy(256);
-    for (x = northwest.x; x <= southeast.x; x++) {
-      for (y = northwest.y; y <= southeast.y; y++) {
-        tiles.push({ z: backend._terrainZoom, x, y, distance: Math.hypot(x + 0.5 - center.x, y + 0.5 - center.y) });
-      }
-    }
-    tiles.sort(compareDistance);
-    const state = { backend, archive, controller, tiles, next: 0 };
-    const workers = [];
+    const tiles = terrainTileQueue(backend, header);
+    const state = /* alloc */ { backend, 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, { signal: controller.signal })
+    const bridges = backend.options.bridges && await fetch(backend.options.bridges, /* alloc */ { signal: controller.signal })
       .then(readBridges);
     if (controller.signal.aborted || backend._map !== map) return;
-    backend._terrainReady = true;
-    backend._terrainOriginElevation = getElevation(backend, backend.location) ?? 0;
-    for (layer of Object.values(map._layers)) {
-      setTerrainHeight(layer);
-      conformModelToTerrain(layer, backend);
-    }
-
-    if (bridges) addBridges(backend, bridges);
-    map.fire('terrainchange');
-    update(backend);
-    backend.fire('terrainready');
+    applyTerrain(backend, map, bridges);
     return true;
   } catch (error) {
-    if (!controller.signal.aborted) backend.fire('error', { error });
+    if (!controller.signal.aborted) backend.fire('error', /* alloc */ { error });
     return false;
   } finally {
-    backend._terrainLoading = false;
+    sceneByLayer.get(backend)._terrainLoading = false;
   }
 }

package/src/terrain/loadTerrainTiles.js

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

package/src/terrain/onTerrainAdd.js

@@ -1,3 +1,7 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { loadTerrain } from "./loadTerrain.js";
 import { setRasterTerrain } from '../raster/setRasterTerrain.js';
 import { onAdd3DLayer } from '../scene/onAdd3DLayer.js';
@@ -5,16 +9,16 @@ import { loadReadyTerrain } from './loadReadyTerrain.js';
 import { setLayerTerrain } from './setLayerTerrain.js';
 
 export function onTerrainAdd(backend, map) {
-  if (map._terrain3D && map._terrain3D !== backend) {
-    throw new Error('Only one terrain layer can be active per map');
+  if (cameraByMap.get(map)._terrain3D && cameraByMap.get(map)._terrain3D !== backend) {
+    throw /* alloc */ new Error('Only one terrain layer can be active per map');
   }
-  map._terrain3D = backend;
+  cameraByMap.get(map)._terrain3D = backend;
   onAdd3DLayer(backend, map);
-  if (backend.root) backend._terrainPromise = loadTerrain(backend);
+  if (sceneByLayer.get(backend).root) sceneByLayer.get(backend)._terrainPromise = loadTerrain(backend);
   else {
     const pending = Promise.withResolvers();
-    backend._terrainPromise = pending.promise;
-    backend.once('ready', loadReadyTerrain, { backend, ...pending });
+    sceneByLayer.get(backend)._terrainPromise = pending.promise;
+    backend.once('ready', loadReadyTerrain, /* alloc */ { backend, ...pending });
   }
   map.eachLayer(setLayerTerrain, backend);
   map.fire('terrainchange');

package/src/terrain/onTerrainChange.js

@@ -1,3 +1,6 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { releaseArea } from '../sources/releaseArea.js';
 import { updateArea } from "../sources/updateArea.js";
 
@@ -6,9 +9,9 @@ import { updateArea } from "../sources/updateArea.js";
 export function onTerrainChange(layer) {
   if (!layer._map) return;
   let area;
-  for (area of layer._areas.values()) {
+  for (area of sceneByLayer.get(layer)._areas.values()) {
     releaseArea(layer, area);
   }
-  layer._areas.clear();
+  sceneByLayer.get(layer)._areas.clear();
   updateArea(layer);
 }

package/src/terrain/onTerrainRemove.js

@@ -1,3 +1,7 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { renderEmpty } from '../globals/renderEmpty.js';
+
 import { destroyTexture } from '../rendering/destroyTexture.js';
 import { conformModelToTerrain } from '../geometry/conformModelToTerrain.js';
 import { disposeMesh } from '../rendering/disposeMesh.js';
@@ -8,34 +12,34 @@ import { onRemove3DLayer } from '../scene/onRemove3DLayer.js';
 import { clearLayerTerrain } from './clearLayerTerrain.js';
 
 export function onTerrainRemove(layer, map) {
-  layer._terrainController?.abort();
-  layer._terrainLoading = false;
-  layer._terrainReady = false;
+  sceneByLayer.get(layer)._terrainController?.abort();
+  sceneByLayer.get(layer)._terrainLoading = false;
+  sceneByLayer.get(layer)._terrainReady = false;
   map.eachLayer(clearLayerTerrain);
   let tile, l, grid, attribute;
-  for (tile of layer._rasterTiles.keys()) removeRasterTile(layer, tile);
-  if (map._terrain3D === layer) delete map._terrain3D;
+  for (tile of sceneByLayer.get(layer)._rasterTiles.keys()) removeRasterTile(layer, tile);
+  if (cameraByMap.get(map)._terrain3D === layer) delete cameraByMap.get(map)._terrain3D;
   for (l of Object.values(map._layers)) {
     conformModelToTerrain(l, null);
     setTerrainHeight(l);
   }
 
   map.fire('terrainchange');
-  layer._terrainTiles.clear();
-  layer._terrainOriginElevation = 0;
-  layer._terrainPromise = null;
-  if (layer._rasterProgram) {
-    layer._rasterProgram.pipelineCache.clear();
+  sceneByLayer.get(layer)._terrainTiles.clear();
+  sceneByLayer.get(layer)._terrainOriginElevation = 0;
+  sceneByLayer.get(layer)._terrainPromise = null;
+  if (sceneByLayer.get(layer)._rasterProgram) {
+    sceneByLayer.get(layer)._rasterProgram.pipelineCache.clear();
   }
-  layer._rasterProgram = null;
-  if (layer._dem) destroyTexture(layer, layer._dem.texture);
-  layer._dem = null;
-  for (grid of layer._terrainGrids?.values() || []) {
+  sceneByLayer.get(layer)._rasterProgram = null;
+  if (sceneByLayer.get(layer)._dem) destroyTexture(layer, sceneByLayer.get(layer)._dem.texture);
+  sceneByLayer.get(layer)._dem = null;
+  for (grid of sceneByLayer.get(layer)._terrainGrids?.values() || renderEmpty) {
     for (attribute of Object.values(grid)) destroyTexture(layer, attribute.buffer);
   }
-  layer._terrainGrids = null;
-  layer._bridges = null;
-  disposeMesh(layer, layer._bridgeMesh);
-  layer._bridgeMesh = null;
+  sceneByLayer.get(layer)._terrainGrids = null;
+  sceneByLayer.get(layer)._bridges = null;
+  disposeMesh(layer, sceneByLayer.get(layer)._bridgeMesh);
+  sceneByLayer.get(layer)._bridgeMesh = null;
   onRemove3DLayer(layer, map);
 }

package/src/terrain/rasterProgram.js

@@ -0,0 +1,51 @@
+import { demTexture } from '../globals/demTexture.js';
+import { demTarget } from '../globals/demTarget.js';
+import { demLayout } from '../globals/demLayout.js';
+import { demSize } from '../globals/demSize.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { createProgram } from '../rendering/createProgram.js';
+import { destroyTexture } from '../rendering/destroyTexture.js';
+import { terrainAtlas } from './terrainAtlas.js';
+
+export function rasterProgram(backend, texture) {
+  const state = sceneByLayer.get(backend), device = state.renderer.device;
+  if (state._rasterProgram?.device === device) return state._rasterProgram;
+  // DEM atlas over the archive's tile grid; invalid or missing samples become -1e9 (the shader's no-data).
+  // ponytail: one texture, capped by maxTextureDimension2D (32x32 DEM tiles at 8192 px); split it for larger archives.
+  const bounds = state._terrainBounds, columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
+  const { elevations, low, high } = terrainAtlas(state._terrainTiles, bounds);
+  if (state._dem) destroyTexture(backend, state._dem.texture);
+  state._dem = /* alloc */ {
+    texture: device.createTexture((
+      demTexture.size[0] = columns * 256,
+      demTexture.size[1] = rows * 256,
+      demTexture.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+      demTexture
+    )),
+    low: Number.isFinite(low) ? low : state._terrainOriginElevation,
+    high: Number.isFinite(high) ? high : state._terrainOriginElevation,
+  };
+  device.queue.writeTexture((
+    demTarget.texture = state._dem.texture,
+    demTarget
+  ), elevations,
+    (
+      demLayout.bytesPerRow = columns * 1024,
+      demLayout
+    ), (
+      demSize[0] = columns * 256,
+      demSize[1] = rows * 256,
+      demSize
+    ));
+  demTarget.texture = null;
+  state._terrainGrids = /* alloc */ new Map();
+  state._rasterProgram = createProgram(backend, /* alloc */ {
+    baseTexture: texture,
+    unlit: true,
+    terrain: state._dem,
+    alphaMode: 'BLEND',
+    depthWrite: true,
+    doubleSided: backend.options.doubleSided,
+  });
+  return state._rasterProgram;
+}

package/src/terrain/readBridges.js

@@ -1,4 +1,4 @@
 export function readBridges(response) {
-  if (!response.ok) throw new Error(`Bridges: HTTP ${response.status}`);
+  if (!response.ok) throw /* alloc */ new Error(`Bridges: HTTP ${response.status}`);
   return response.json();
 }

package/src/terrain/setLayerTerrain.js

@@ -1,5 +1,8 @@
-import { setRasterTerrain } from '../raster/setRasterTerrain.js';
-
-export function setLayerTerrain(layer) {
-  if (layer._type === 'pmtiles') setRasterTerrain(layer, this);
-}
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { setRasterTerrain } from '../raster/setRasterTerrain.js';
+
+export function setLayerTerrain(layer) {
+  if (sceneByLayer.get(layer).kind === 'raster') setRasterTerrain(layer, this);
+}

package/src/terrain/setTerrainHeight.js

@@ -1,10 +1,14 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
 import { getElevation } from './getElevation.js';
 
 export function setTerrainHeight(layer) {
-  if (!layer.root || !layer.location) return;
-  layer._terrainBaseY ??= layer.root.position[1];
-  const terrain = layer._map?._terrain3D;
-  const elevation = terrain && getElevation(terrain, layer.location);
+  if (!sceneByLayer.get(layer).root || !sceneByLayer.get(layer).location) return;
+  sceneByLayer.get(layer)._terrainBaseY ??= sceneByLayer.get(layer).root.position[1];
+  const terrain = cameraByMap.get(layer._map)?._terrain3D;
+  const elevation = terrain && getElevation(terrain, sceneByLayer.get(layer).location);
   const offset = Number.isFinite(elevation) ? layer.options.terrainOffset ?? 0 : 0;
-  layer.root.position[1] = layer._terrainBaseY + (elevation ?? 0) + offset;
+  sceneByLayer.get(layer).root.position[1] = sceneByLayer.get(layer)._terrainBaseY + (elevation ?? 0) + offset;
 }

package/src/terrain/terrainAtlas.js

@@ -1,23 +1,17 @@
+import { copyTerrainTile } from './copyTerrainTile.js';
+
 /** Float32 DEM atlas; missing samples retain the shader no-data sentinel. */
 
 export function terrainAtlas(tiles, bounds) {
   const columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
-  const elevations = new Float32Array(columns * rows * 65536).fill(-1e9);
-  let low = Infinity, high = -Infinity;
-  let key, values, coordinates, x, y, start, row, column, value;
+  const elevations = /* alloc */ new Float32Array(columns * rows * 65536).fill(-1e9);
+  const atlas = /* alloc */ { elevations, low: Infinity, high: -Infinity };
+  let key, values, coordinates, x, y, start;
   for ([key, values] of tiles) {
     coordinates = key.split('/');
     x = Number(coordinates[0]), y = Number(coordinates[1]);
     start = (y - bounds.min.y) * 256 * columns * 256 + (x - bounds.min.x) * 256;
-    for (row = 0; row < 256; row++) {
-      for (column = 0; column < 256; column++) {
-        value = values[row * 256 + column];
-        if (!Number.isFinite(value) || value <= -1000) continue;
-        elevations[start + row * columns * 256 + column] = value;
-        low = Math.min(low, value);
-        high = Math.max(high, value);
-      }
-    }
+    copyTerrainTile(atlas, values, start, columns);
   }
-  return { elevations, low, high };
+  return atlas;
 }