leaflet-city-mapper 0.0.3 → 0.0.5

package/src/terrain/initTerrain.js

@@ -1,20 +1,28 @@
+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';
 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);
+  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,63 +1,52 @@
-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 { 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';
 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;
+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 (!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 (!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,
+    } });
+    terrainArchiveByLayer.set(layer, archive);
+    await readyByLayer.get(archive);
+    const header = headerByLayer.get(archive);
     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 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, { 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;
-    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');
+    if (controller.signal.aborted || layer._map !== map) return;
+    applyTerrain(layer, map, bridges);
     return true;
   } catch (error) {
-    if (!controller.signal.aborted) backend.fire('error', { error });
+    if (!controller.signal.aborted) layer.fire('error', /* alloc */ { error });
     return false;
   } finally {
-    backend._terrainLoading = false;
+    terrainLoadingByLayer.set(layer, false);
   }
 }

package/src/terrain/loadTerrainTiles.js

@@ -1,13 +1,18 @@
+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();
     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));
+    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);
+}

package/src/terrain/onTerrainAdd.js

@@ -1,21 +1,29 @@
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { terrainPromiseByLayer } from '../weakmaps/terrainPromiseByLayer.js';
+import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+
+
+
+
 import { loadTerrain } from "./loadTerrain.js";
 import { setRasterTerrain } from '../raster/setRasterTerrain.js';
 import { onAdd3DLayer } from '../scene/onAdd3DLayer.js';
 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');
+export function onTerrainAdd(layer, map) {
+
+  if (terrain3DByMap.get(map) && terrain3DByMap.get(map) !== layer) {
+    throw /* alloc */ new Error('Only one terrain layer can be active per map');
   }
-  map._terrain3D = backend;
-  onAdd3DLayer(backend, map);
-  if (backend.root) backend._terrainPromise = loadTerrain(backend);
+  terrain3DByMap.set(map, layer);
+  onAdd3DLayer(layer, map);
+  if (rootByLayer.get(layer)) terrainPromiseByLayer.set(layer, loadTerrain(layer));
   else {
     const pending = Promise.withResolvers();
-    backend._terrainPromise = pending.promise;
-    backend.once('ready', loadReadyTerrain, { backend, ...pending });
+    terrainPromiseByLayer.set(layer, pending.promise);
+    layer.once('ready', loadReadyTerrain, /* alloc */ { backend: layer, ...pending });
   }
-  map.eachLayer(setLayerTerrain, backend);
+  map.eachLayer(setLayerTerrain, layer);
   map.fire('terrainchange');
 }

package/src/terrain/onTerrainChange.js

@@ -1,3 +1,7 @@
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+
+
+
 import { releaseArea } from '../sources/releaseArea.js';
 import { updateArea } from "../sources/updateArea.js";
 
@@ -6,9 +10,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 areasByLayer.get(layer).values()) {
     releaseArea(layer, area);
   }
-  layer._areas.clear();
+  areasByLayer.get(layer).clear();
   updateArea(layer);
 }

package/src/terrain/onTerrainRemove.js

@@ -1,4 +1,21 @@
-import { destroyTexture } from '../rendering/destroyTexture.js';
+import { bridgeMeshByLayer } from '../weakmaps/bridgeMeshByLayer.js';
+import { bridgesByLayer } from '../weakmaps/bridgesByLayer.js';
+import { demByLayer } from '../weakmaps/demByLayer.js';
+import { rasterProgramByLayer } from '../weakmaps/rasterProgramByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { terrainControllerByLayer } from '../weakmaps/terrainControllerByLayer.js';
+import { terrainGridsByLayer } from '../weakmaps/terrainGridsByLayer.js';
+import { terrainLoadingByLayer } from '../weakmaps/terrainLoadingByLayer.js';
+import { terrainOriginElevationByLayer } from '../weakmaps/terrainOriginElevationByLayer.js';
+import { terrainPromiseByLayer } from '../weakmaps/terrainPromiseByLayer.js';
+import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
+import { terrainTilesByLayer } from '../weakmaps/terrainTilesByLayer.js';
+import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+
+
+import { renderEmpty } from '../globals/renderEmpty.js';
+
+import { destroyTexture } from '../textures/destroyTexture.js';
 import { conformModelToTerrain } from '../geometry/conformModelToTerrain.js';
 import { disposeMesh } from '../rendering/disposeMesh.js';
 import { setRasterTerrain } from '../raster/setRasterTerrain.js';
@@ -8,34 +25,35 @@ 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;
+
+  terrainControllerByLayer.get(layer)?.abort();
+  terrainLoadingByLayer.set(layer, false);
+  terrainReadyByLayer.set(layer, 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 rasterTilesByLayer.get(layer).keys()) removeRasterTile(layer, tile);
+  if (terrain3DByMap.get(map) === layer) terrain3DByMap.delete(map);
   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();
+  terrainTilesByLayer.get(layer).clear();
+  terrainOriginElevationByLayer.set(layer, 0);
+  terrainPromiseByLayer.set(layer, null);
+  if (rasterProgramByLayer.get(layer)) {
+    rasterProgramByLayer.get(layer).pipelineCache.clear();
   }
-  layer._rasterProgram = null;
-  if (layer._dem) destroyTexture(layer, layer._dem.texture);
-  layer._dem = null;
-  for (grid of layer._terrainGrids?.values() || []) {
+  rasterProgramByLayer.set(layer, null);
+  if (demByLayer.get(layer)) destroyTexture(layer, demByLayer.get(layer).texture);
+  demByLayer.set(layer, null);
+  for (grid of terrainGridsByLayer.get(layer)?.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;
+  terrainGridsByLayer.set(layer, null);
+  bridgesByLayer.set(layer, null);
+  disposeMesh(layer, bridgeMeshByLayer.get(layer));
+  bridgeMeshByLayer.set(layer, null);
   onRemove3DLayer(layer, map);
 }

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

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

package/src/terrain/setLayerTerrain.js

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

package/src/terrain/setTerrainHeight.js

@@ -1,10 +1,19 @@
-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);
-  const offset = Number.isFinite(elevation) ? layer.options.terrainOffset ?? 0 : 0;
-  layer.root.position[1] = layer._terrainBaseY + (elevation ?? 0) + offset;
-}
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { terrainBaseYByLayer } from '../weakmaps/terrainBaseYByLayer.js';
+import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+
+
+
+
+import { getElevation } from './getElevation.js';
+
+export function setTerrainHeight(layer) {
+
+  if (!rootByLayer.get(layer) || !locationByLayer.get(layer)) return;
+  if (terrainBaseYByLayer.get(layer) == null) terrainBaseYByLayer.set(layer, rootByLayer.get(layer).position[1]);
+  const terrain = terrain3DByMap.get(layer._map);
+  const elevation = terrain && getElevation(terrain, locationByLayer.get(layer));
+  const offset = Number.isFinite(elevation) ? layer.options.terrainOffset ?? 0 : 0;
+  rootByLayer.get(layer).position[1] = terrainBaseYByLayer.get(layer) + (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;
 }

package/src/terrain/terrainElevation.js

@@ -1,4 +1,4 @@
-import { sample } from './sample.js';
+import { sample } from './sampleTerrainTile.js';
 
 /** Bilinear DEM sampling, with the original first-valid-neighbour no-data rule. */
 
@@ -6,15 +6,10 @@ export function terrainElevation(point, tiles) {
   const x = point.x - 0.5, y = point.y - 0.5;
   const x0 = Math.floor(x), y0 = Math.floor(y);
   const fx = x - x0, fy = y - y0;
-  const values = [sample(tiles, x0, y0), sample(tiles, x0 + 1, y0), sample(tiles, x0, y0 + 1), sample(tiles, x0 + 1, y0 + 1)];
-  let valid = 0, first = null;
-  let value;
-  for (value of values) {
-    if (!Number.isFinite(value)) continue;
-    if (!valid) first = value;
-    valid++;
+  const a = sample(tiles, x0, y0), b = sample(tiles, x0 + 1, y0);
+  const c = sample(tiles, x0, y0 + 1), d = sample(tiles, x0 + 1, y0 + 1);
+  if (!Number.isFinite(a) || !Number.isFinite(b) || !Number.isFinite(c) || !Number.isFinite(d)) {
+    return Number.isFinite(a) ? a : Number.isFinite(b) ? b : Number.isFinite(c) ? c : Number.isFinite(d) ? d : null;
   }
-  if (valid < 4) return first;
-  return (values[0] * (1 - fx) + values[1] * fx) * (1 - fy) +
-    (values[2] * (1 - fx) + values[3] * fx) * fy;
+  return (a * (1 - fx) + b * fx) * (1 - fy) + (c * (1 - fx) + d * fx) * fy;
 }

package/src/terrain/terrainTileQueue.js

@@ -0,0 +1,27 @@
+import { terrainBoundsByLayer } from '../weakmaps/terrainBoundsByLayer.js';
+import { terrainZoomByLayer } from '../weakmaps/terrainZoomByLayer.js';
+
+import { L } from '../globals/L.js';
+import { archiveNorthWest } from '../globals/archiveNorthWest.js';
+import { archiveSouthEast } from '../globals/archiveSouthEast.js';
+import { compareDistance } from '../utils/compareDistance.js';
+
+export function terrainTileQueue(layer, header) {
+  const map = layer._map
+  terrainZoomByLayer.set(layer, header.maxZoom);
+  archiveNorthWest[0] = header.maxLat; archiveNorthWest[1] = header.minLon;
+  const northwest = map.project(archiveNorthWest, terrainZoomByLayer.get(layer)).divideBy(256).floor();
+  archiveSouthEast[0] = header.minLat; archiveSouthEast[1] = header.maxLon;
+  const southeast = map.project(archiveSouthEast, terrainZoomByLayer.get(layer)).divideBy(256).floor();
+  terrainBoundsByLayer.set(layer, /* alloc */ new L.Bounds(northwest, southeast));
+  const tiles = /* alloc */ [];
+  const center = map.project(map.getCenter(), terrainZoomByLayer.get(layer)).divideBy(256);
+  let x, y;
+  for (x = northwest.x; x <= southeast.x; x++) {
+    for (y = northwest.y; y <= southeast.y; y++) {
+      tiles.push(/* alloc */ { z: terrainZoomByLayer.get(layer), x, y, distance: Math.hypot(x + 0.5 - center.x, y + 0.5 - center.y) });
+    }
+  }
+  tiles.sort(compareDistance);
+  return tiles;
+}

package/src/textures/addImageState.js

@@ -0,0 +1,8 @@
+import { imageStates } from '../weakmaps/imageStates.js';
+
+
+export function addImageState(image, state) {
+  let states = imageStates.get(image);
+  if (!states) imageStates.set(image, states = /* alloc */ new Set());
+  states.add(state);
+}

package/src/{core/addRasterImage.js → textures/attachRasterImage.js}

@@ -1,10 +1,12 @@
-import { indexState } from '../constants/indexState.js';
-import { fireRasterLoad } from './fireRasterLoad.js';
+import { pendingRasterLoads } from '../globals/pendingRasterLoads.js';
+
+
+import { fireRasterLoad } from '../core/fireRasterLoad.js';
 
 export function addRasterImage() {
   if (!this._image) this._initImage();
   if (this._image.complete && this._image.naturalWidth) {
-    indexState.pendingRasterLoads.push(this);
+    pendingRasterLoads.push(this);
     queueMicrotask(fireRasterLoad);
   }
 }

package/src/textures/bindMeshTextures.js

@@ -0,0 +1,50 @@
+import { meshBindGroup } from '../globals/meshBindGroup.js';
+import { drawEntries } from '../globals/drawEntries.js';
+import { drawMeshEntry } from '../globals/drawMeshEntry.js';
+import { drawFrameEntry } from '../globals/drawFrameEntry.js';
+import { drawTerrainEntry } from '../globals/drawTerrainEntry.js';
+import { drawTextureEntries } from '../globals/drawTextureEntries.js';
+import { drawSamplerEntries } from '../globals/drawSamplerEntries.js';
+
+export function bindMeshTextures(renderer, mesh, textures) {
+  const { program } = mesh;
+  const entries = drawEntries;
+  entries.length = 0;
+  drawMeshEntry.resource.buffer = renderer.uniformBuffer;
+  drawFrameEntry.resource.buffer = renderer.uniformBuffer;
+  entries.push(drawMeshEntry, drawFrameEntry);
+  if (program.terrain) {
+    drawTerrainEntry.resource = program.terrain.texture.createView();
+    entries.push(drawTerrainEntry);
+  }
+  mesh.boundBuffer = renderer.uniformBuffer;
+  const boundTextures = mesh.boundTextures ||= /* alloc */ [];
+  boundTextures.length = textures.length;
+  let i, binding, texture;
+  for (i = 0; i < textures.length; i++) {
+    binding = program.bindings[i], texture = textures[i];
+    drawTextureEntries[i].binding = binding.texture;
+    drawTextureEntries[i].resource = texture.texture.createView();
+    drawSamplerEntries[i].binding = binding.sampler;
+    drawSamplerEntries[i].resource = texture.sampler;
+    entries.push(drawTextureEntries[i], drawSamplerEntries[i]);
+    boundTextures[i] ||= /* alloc */ [];
+    boundTextures[i][0] = texture.texture;
+    boundTextures[i][1] = texture.sampler;
+  }
+  mesh.bindGroup = renderer.device.createBindGroup((
+    meshBindGroup.layout = program.bindGroupLayout,
+    meshBindGroup.entries = entries,
+    meshBindGroup
+  ));
+  meshBindGroup.layout = null;
+  meshBindGroup.entries = null;
+  drawMeshEntry.resource.buffer = null;
+  drawFrameEntry.resource.buffer = null;
+  drawTerrainEntry.resource = null;
+  for (i = 0; i < textures.length; i++) {
+    drawTextureEntries[i].resource = null;
+    drawSamplerEntries[i].resource = null;
+  }
+  entries.length = 0;
+}

package/src/textures/collectRoofTiles.js

@@ -0,0 +1,16 @@
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+
+
+export function collectRoofTiles(rasters, tiles) {
+  let zoom = -Infinity, layer, tile;
+  for (layer of rasters) {
+    for (tile of rasterTilesByLayer.get(layer).values()) {
+      if (tile.done && !tile.request.signal.aborted && tile.image) {
+        tile._roofEntry ||= /* alloc */ { tile, layer };
+        tiles.push(tile._roofEntry);
+        zoom = Math.max(zoom, tile.coords.z);
+      }
+    }
+  }
+  return zoom;
+}

package/src/{rendering → textures}/compareRoofTiles.js

@@ -1,4 +1,4 @@
-export function compareRoofTiles(a, b) {
-  return (a.layer.options.zIndex || 0) - (b.layer.options.zIndex || 0) ||
-    a.tile.coords.z - b.tile.coords.z;
-}
+export function compareRoofTiles(a, b) {
+  return (a.layer.options.zIndex || 0) - (b.layer.options.zIndex || 0) ||
+    a.tile.coords.z - b.tile.coords.z;
+}

package/src/textures/composeRoofAtlas.js

@@ -0,0 +1,71 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { roofRasterByLayer } from '../weakmaps/roofRasterByLayer.js';
+
+import { roofBuffer } from '../globals/roofBuffer.js';
+import { roofPass } from '../globals/roofPass.js';
+import { uploadRoofTile } from './uploadRoofTile.js';
+import { roofBindGroup } from '../globals/roofBindGroup.js';
+import { roofCommands } from '../globals/roofCommands.js';
+import { roofOpacities } from '../globals/roofOpacities.js';
+import { TILE_SIZE } from '../globals/TILE_SIZE.js';
+
+
+import { compareRoofTiles } from './compareRoofTiles.js';
+
+export function composeRoofAtlas(layer, tiles, zoom, min, size, width, height) {
+  const renderer = rendererByLayer.get(layer), device = renderer.device, map = layer._map;
+  const opacityLength = Math.max(1, tiles.length) * 64;
+  if (roofOpacities.value.length < opacityLength) {
+    roofOpacities.value = /* alloc */ new Float32Array(opacityLength);
+  }
+  const opacities = roofOpacities.value;
+  const opacityBuffer = device.createBuffer((
+    roofBuffer.size = opacities.byteLength,
+    roofBuffer.usage = GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    roofBuffer
+  ));
+
+  const encoder = device.createCommandEncoder();
+  const atlasPass = encoder.beginRenderPass((
+    roofPass.colorAttachments[0].view = roofRasterByLayer.get(layer).texture.texture.createView(),
+    roofPass
+  ));
+  roofPass.colorAttachments[0].view = null;
+  atlasPass.setPipeline(renderer.roofBlit.pipeline);
+  tiles.sort(compareRoofTiles);
+  let i, tile, rasterLayer, coords, source, tileSize, x, y;
+  for ([i, { tile, layer: rasterLayer }] of tiles.entries()) {
+    ({ coords } = tile);
+    source = tile.texture;
+    uploadRoofTile(device, tile);
+
+    opacities[i * 64] = rasterLayer.options.opacity;
+    tileSize = TILE_SIZE * map.getZoomScale(zoom, coords.z);
+    x = (coords.x * tileSize - min.x) * width / size.x;
+    y = (coords.y * tileSize - min.y) * height / size.y;
+    atlasPass.setViewport(x, y, Math.min(tileSize * width / size.x, width - x),
+      Math.min(tileSize * height / size.y, height - y), 0, 1);
+    atlasPass.setBindGroup(0, device.createBindGroup((
+      roofBindGroup.layout = renderer.roofBlit.pipeline.getBindGroupLayout(0),
+      roofBindGroup.entries[0].resource = source.texture.createView(),
+      roofBindGroup.entries[1].resource = renderer.roofBlit.sampler,
+      roofBindGroup.entries[2].resource.buffer = opacityBuffer,
+      roofBindGroup.entries[2].resource.offset = i * 256,
+      roofBindGroup
+    )));
+    roofBindGroup.layout = null;
+    roofBindGroup.entries[0].resource = null;
+    roofBindGroup.entries[1].resource = null;
+    roofBindGroup.entries[2].resource.buffer = null;
+
+    atlasPass.draw(4);
+  }
+  atlasPass.end();
+  device.queue.writeBuffer(opacityBuffer, 0, opacities);
+  device.queue.submit((
+    roofCommands[0] = encoder.finish(),
+    roofCommands
+  ));
+  roofCommands[0] = null;
+  opacityBuffer.destroy();
+}