leaflet-city-mapper 0.0.4 → 0.0.6

package/src/terrain/onTerrainAdd.js

@@ -1,5 +1,8 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { terrainPromiseByLayer } from '../weakmaps/terrainPromiseByLayer.js';
+import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+
+
 
 
 import { loadTerrain } from "./loadTerrain.js";
@@ -8,18 +11,19 @@ import { onAdd3DLayer } from '../scene/onAdd3DLayer.js';
 import { loadReadyTerrain } from './loadReadyTerrain.js';
 import { setLayerTerrain } from './setLayerTerrain.js';
 
-export function onTerrainAdd(backend, map) {
-  if (cameraByMap.get(map)._terrain3D && cameraByMap.get(map)._terrain3D !== backend) {
+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');
   }
-  cameraByMap.get(map)._terrain3D = backend;
-  onAdd3DLayer(backend, map);
-  if (sceneByLayer.get(backend).root) sceneByLayer.get(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();
-    sceneByLayer.get(backend)._terrainPromise = pending.promise;
-    backend.once('ready', loadReadyTerrain, /* alloc */ { 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,4 +1,5 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+
 
 
 import { releaseArea } from '../sources/releaseArea.js';
@@ -9,9 +10,9 @@ import { updateArea } from "../sources/updateArea.js";
 export function onTerrainChange(layer) {
   if (!layer._map) return;
   let area;
-  for (area of sceneByLayer.get(layer)._areas.values()) {
+  for (area of areasByLayer.get(layer).values()) {
     releaseArea(layer, area);
   }
-  sceneByLayer.get(layer)._areas.clear();
+  areasByLayer.get(layer).clear();
   updateArea(layer);
 }

package/src/terrain/onTerrainRemove.js

@@ -1,8 +1,21 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { cameraByMap } from '../globals/cameraByMap.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 '../rendering/destroyTexture.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';
@@ -12,34 +25,35 @@ import { onRemove3DLayer } from '../scene/onRemove3DLayer.js';
 import { clearLayerTerrain } from './clearLayerTerrain.js';
 
 export function onTerrainRemove(layer, map) {
-  sceneByLayer.get(layer)._terrainController?.abort();
-  sceneByLayer.get(layer)._terrainLoading = false;
-  sceneByLayer.get(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 sceneByLayer.get(layer)._rasterTiles.keys()) removeRasterTile(layer, tile);
-  if (cameraByMap.get(map)._terrain3D === layer) delete cameraByMap.get(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');
-  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();
+  terrainTilesByLayer.get(layer).clear();
+  terrainOriginElevationByLayer.set(layer, 0);
+  terrainPromiseByLayer.set(layer, null);
+  if (rasterProgramByLayer.get(layer)) {
+    rasterProgramByLayer.get(layer).pipelineCache.clear();
   }
-  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) {
+  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);
   }
-  sceneByLayer.get(layer)._terrainGrids = null;
-  sceneByLayer.get(layer)._bridges = null;
-  disposeMesh(layer, sceneByLayer.get(layer)._bridgeMesh);
-  sceneByLayer.get(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/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,8 +1,9 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
 
 
 import { setRasterTerrain } from '../raster/setRasterTerrain.js';
 
 export function setLayerTerrain(layer) {
-  if (sceneByLayer.get(layer).kind === 'raster') setRasterTerrain(layer, this);
+  if (kindByLayer.get(layer) === 'raster') setRasterTerrain(layer, this);
 }

package/src/terrain/setTerrainHeight.js

@@ -1,14 +1,19 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
-
-
-import { getElevation } from './getElevation.js';
-
-export function setTerrainHeight(layer) {
-  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;
-  sceneByLayer.get(layer).root.position[1] = sceneByLayer.get(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/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. */
 

package/src/terrain/terrainTileQueue.js

@@ -1,23 +1,25 @@
+import { terrainBoundsByLayer } from '../weakmaps/terrainBoundsByLayer.js';
+import { terrainZoomByLayer } from '../weakmaps/terrainZoomByLayer.js';
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { archiveNorthWest } from '../globals/archiveNorthWest.js';
 import { archiveSouthEast } from '../globals/archiveSouthEast.js';
 import { compareDistance } from '../utils/compareDistance.js';
 
-export function terrainTileQueue(backend, header) {
-  const scene = sceneByLayer.get(backend), map = backend._map;
-  scene._terrainZoom = header.maxZoom;
+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, scene._terrainZoom).divideBy(256).floor();
+  const northwest = map.project(archiveNorthWest, terrainZoomByLayer.get(layer)).divideBy(256).floor();
   archiveSouthEast[0] = header.minLat; archiveSouthEast[1] = header.maxLon;
-  const southeast = map.project(archiveSouthEast, scene._terrainZoom).divideBy(256).floor();
-  scene._terrainBounds = /* alloc */ new L.Bounds(northwest, southeast);
+  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(), scene._terrainZoom).divideBy(256);
+  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: scene._terrainZoom, x, y, distance: Math.hypot(x + 0.5 - center.x, y + 0.5 - center.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);

package/src/{core → textures}/addImageState.js

@@ -1,4 +1,4 @@
-import { imageStates } from '../globals/imageStates.js';
+import { imageStates } from '../weakmaps/imageStates.js';
 
 
 export function addImageState(image, state) {

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

@@ -1,7 +1,7 @@
 import { pendingRasterLoads } from '../globals/pendingRasterLoads.js';
 
 
-import { fireRasterLoad } from './fireRasterLoad.js';
+import { fireRasterLoad } from '../core/fireRasterLoad.js';
 
 export function addRasterImage() {
   if (!this._image) this._initImage();

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

@@ -1,9 +1,10 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+
 
 export function collectRoofTiles(rasters, tiles) {
   let zoom = -Infinity, layer, tile;
   for (layer of rasters) {
-    for (tile of sceneByLayer.get(layer)._rasterTiles.values()) {
+    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);

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

@@ -1,17 +1,19 @@
+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 { sceneByLayer } from '../globals/sceneByLayer.js';
 import { roofOpacities } from '../globals/roofOpacities.js';
 import { TILE_SIZE } from '../globals/TILE_SIZE.js';
 
 
 import { compareRoofTiles } from './compareRoofTiles.js';
 
-export function composeRoofAtlas(backend, tiles, zoom, min, size, width, height) {
-  const renderer = sceneByLayer.get(backend).renderer, device = renderer.device, map = backend._map;
+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);
@@ -25,19 +27,19 @@ export function composeRoofAtlas(backend, tiles, zoom, min, size, width, height)
 
   const encoder = device.createCommandEncoder();
   const atlasPass = encoder.beginRenderPass((
-    roofPass.colorAttachments[0].view = sceneByLayer.get(backend)._roofRaster.texture.texture.createView(),
+    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, layer, coords, source, tileSize, x, y;
-  for ([i, { tile, layer }] of tiles.entries()) {
+  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] = layer.options.opacity;
+    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;

package/src/textures/destroyTexture.js

@@ -0,0 +1,10 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
+
+
+
+import { destroyAfterSubmission } from './destroyTextureAfterSubmission.js';
+
+export function destroyTexture(layer, texture) {
+  destroyAfterSubmission(layer, texture, rendererByLayer.get(layer).device.queue.onSubmittedWorkDone());
+}

package/src/{models/textureFor.js → textures/modelTextureFor.js}

@@ -1,15 +1,16 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
 
 
-import { textureSampler } from './textureSampler.js';
+
+import { textureSampler } from './modelTextureSampler.js';
 
 export function textureFor(context, reference, color = false) {
-  const { backend, description, images, textures } = context;
+  const { backend: layer, description, images, textures } = context;
   if (!reference) return null;
   if ((reference.texCoord || 0) !== 0 || reference.extensions) {
     throw /* alloc */ new Error('Model textures currently require untransformed TEXCOORD_0 UVs');
   }
-  const device = sceneByLayer.get(backend).renderer.device;
+  const device = rendererByLayer.get(layer).device;
   // A glTF image may serve both color and data maps: those cannot share a GPU format.
   const key = `${reference.index}:${color}`;
   if (!textures.has(key)) {

package/src/{core → textures}/nativeImageError.js

@@ -1,4 +1,4 @@
-import { imageStates } from '../globals/imageStates.js';
+import { imageStates } from '../weakmaps/imageStates.js';
 
 
 export function nativeImageError(event) {

package/src/{core → textures}/nativeImageRefresh.js

@@ -1,7 +1,7 @@
-import { imageStates } from '../globals/imageStates.js';
+import { imageStates } from '../weakmaps/imageStates.js';
 
 
-import { refreshNativeLayer } from './refreshNativeLayer.js';
+import { refreshNativeLayer } from '../native/refreshNativeLayer.js';
 
 export function nativeImageRefresh(event) {
   const states = imageStates.get(event.currentTarget);

package/src/{core/textureFor.js → textures/nativeTextureFor.js}

@@ -1,8 +1,9 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
 import { coreSampler } from '../globals/coreSampler.js';
 
 import { disposeMesh } from '../rendering/disposeMesh.js';
-import { destroyTexture } from '../rendering/destroyTexture.js';
+import { destroyTexture } from './destroyTexture.js';
 import { uploadCanvasTexture } from './uploadCanvasTexture.js';
 import { uploadNativeImage } from './uploadNativeImage.js';
 
@@ -11,20 +12,20 @@ export function textureFor(state, key, image) {
   if (!(image instanceof HTMLImageElement) && !(image instanceof HTMLCanvasElement)) {
     throw /* alloc */ new Error('WebGPU native raster layers require image or canvas tiles');
   }
-  const { backend, textures, meshes } = state;
+  const { backend: layer, textures, meshes } = state;
   let texture = textures.get(key);
   const url = image.currentSrc || image.src;
   if (!texture || texture.image !== image || texture.url !== url) {
     if (texture) {
       const mesh = meshes.get(key);
-      if (mesh) disposeMesh(backend, mesh);
+      if (mesh) disposeMesh(layer, mesh);
       meshes.delete(key);
-      destroyTexture(backend, texture.texture);
+      destroyTexture(layer, texture.texture);
       textures.delete(key);
     }
     const width = image.naturalWidth || image.width, height = image.naturalHeight || image.height;
     if (!width || !height) return;
-    const { device } = sceneByLayer.get(backend).renderer;
+    const { device } = rendererByLayer.get(layer);
     texture = /* alloc */ {
       device, image, url, format: 'rgba8unorm', uploaded: null,
       texture: device.createTexture(/* alloc */ {

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

@@ -1,6 +1,9 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { roofRasterByLayer } from '../weakmaps/roofRasterByLayer.js';
+import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
+
 import { radians } from '../globals/radians.js';
 import { earthCirc } from '../globals/earthCirc.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { roofTiles } from '../globals/roofTiles.js';
 import { TILE_SIZE } from '../globals/TILE_SIZE.js';
 import { roofMin } from '../globals/roofMin.js';
@@ -12,8 +15,8 @@ import { composeRoofAtlas } from './composeRoofAtlas.js';
 import { collectRoofTiles } from './collectRoofTiles.js';
 import { resizeRoofTexture } from './resizeRoofTexture.js';
 
-export function rebuildRoofAtlas(backend, rasters, signature, now) {
-  const map = backend._map, renderer = sceneByLayer.get(backend).renderer;
+export function rebuildRoofAtlas(layer, rasters, signature, now) {
+  const map = layer._map, renderer = rendererByLayer.get(layer);
   const tiles = roofTiles;
   tiles.length = 0;
   let zoom = collectRoofTiles(rasters, tiles);
@@ -25,27 +28,27 @@ export function rebuildRoofAtlas(backend, rasters, signature, now) {
     minX = Math.min(minX, coords.x * tileSize); minY = Math.min(minY, coords.y * tileSize);
     maxX = Math.max(maxX, (coords.x + 1) * tileSize); maxY = Math.max(maxY, (coords.y + 1) * tileSize);
   }
-  const origin = map.project(sceneByLayer.get(backend)._sceneOrigin, zoom);
+  const origin = map.project(sceneOriginByLayer.get(layer), zoom);
   const min = roofMin, size = roofSize;
   min.x = tiles.length ? minX : origin.x; min.y = tiles.length ? minY : origin.y;
   size.x = tiles.length ? maxX - minX : 1; size.y = tiles.length ? maxY - minY : 1;
   // ponytail: cap at 4096 px; virtual textures if wide views need native detail.
   const scale = Math.min(1, 4096 / Math.max(size.x, size.y));
   const width = Math.max(1, Math.ceil(size.x * scale)), height = Math.max(1, Math.ceil(size.y * scale));
-  const pixels = map.options.crs.scale(zoom) / (earthCirc * Math.cos(sceneByLayer.get(backend)._sceneOrigin.lat * radians));
+  const pixels = map.options.crs.scale(zoom) / (earthCirc * Math.cos(sceneOriginByLayer.get(layer).lat * radians));
   const roof = /* alloc */ {
     matrix: /* alloc */ [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-    texture: sceneByLayer.get(backend)._roofRaster?.texture,
+    texture: roofRasterByLayer.get(layer)?.texture,
   };
-  sceneByLayer.get(backend)._roofRaster = roof;
+  roofRasterByLayer.set(layer, roof);
   roof.signature = signature; roof.updatedAt = now;
   roof.matrix[0] = pixels / size.x; roof.matrix[10] = pixels / size.y;
   roof.matrix[12] = (origin.x - min.x) / size.x; roof.matrix[14] = (origin.y - min.y) / size.y;
-  resizeRoofTexture(backend, roof, width, height);
+  resizeRoofTexture(layer, roof, width, height);
   // Compose the atlas on the GPU: re-uploading a large canvas stalls Firefox for hundreds of ms.
   ensureRoofBlit(renderer);
   try {
-    composeRoofAtlas(backend, tiles, zoom, min, size, width, height);
+    composeRoofAtlas(layer, tiles, zoom, min, size, width, height);
   } finally {
     tiles.length = 0;
   }

package/src/{core → textures}/removeImageState.js

@@ -1,4 +1,4 @@
-import { imageStates } from '../globals/imageStates.js';
+import { imageStates } from '../weakmaps/imageStates.js';
 
 
 export function removeImageState(image, state) {

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

@@ -1,15 +1,16 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
 import { roofTexture } from '../globals/roofTexture.js';
 import { roofSampler } from '../globals/roofSampler.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { destroyTexture } from './destroyTexture.js';
 
-export function resizeRoofTexture(backend, roof, width, height) {
-  const renderer = sceneByLayer.get(backend).renderer;
+export function resizeRoofTexture(layer, roof, width, height) {
+  const renderer = rendererByLayer.get(layer);
   const descriptor = roofTexture;
   descriptor.size[0] = width; descriptor.size[1] = height;
   descriptor.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT;
   if (roof.texture && (roof.texture.width !== width || roof.texture.height !== height)) {
-    destroyTexture(backend, roof.texture.texture);
+    destroyTexture(layer, roof.texture.texture);
     roof.texture.texture = renderer.device.createTexture(descriptor);
     roof.texture.width = width; roof.texture.height = height;
   }

package/src/textures/updateRoofAtlas.js

@@ -0,0 +1,23 @@
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+import { rasterVersionByLayer } from '../weakmaps/rasterVersionByLayer.js';
+import { roofRasterByLayer } from '../weakmaps/roofRasterByLayer.js';
+
+import { L } from '../globals/L.js';
+import { roofSignatures } from '../globals/roofSignatures.js';
+import { rebuildRoofAtlas } from './rebuildRoofAtlas.js';
+
+export function updateRoofAtlas(layer, rasters, now) {
+  const signatures = roofSignatures;
+  signatures.length = 0;
+  let loading = false, rasterLayer;
+  for (rasterLayer of rasters) {
+    signatures.push(`${L.Util.stamp(rasterLayer)}:${rasterVersionByLayer.get(rasterLayer) || 0}:${rasterLayer.options.opacity}:${rasterLayer.options.zIndex}`);
+    loading ||= Boolean(loadingTilesByLayer.get(rasterLayer));
+  }
+  const signature = signatures.join('|');
+  signatures.length = 0;
+  if (!roofRasterByLayer.get(layer) || roofRasterByLayer.get(layer).signature !== signature &&
+    (!loading || now - roofRasterByLayer.get(layer).updatedAt >= 50)) {
+    rebuildRoofAtlas(layer, rasters, signature, now);
+  }
+}

package/src/textures/updateRoofRaster.js

@@ -0,0 +1,29 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { roofRasterByLayer } from '../weakmaps/roofRasterByLayer.js';
+import { roofRastersByLayer } from '../weakmaps/roofRastersByLayer.js';
+import { updateRoofAtlas } from './updateRoofAtlas.js';
+import { destroyTexture } from './destroyTexture.js';
+
+export function updateRoofRaster(layer, now) {
+  const map = layer._map;
+  let rasters = roofRastersByLayer.get(layer);
+  if (!rasters) roofRastersByLayer.set(layer, rasters = /* alloc */ []);
+  rasters.length = 0;
+  let hasRoofTexture = false;
+  let sceneLayer, rasterLayer;
+  for (sceneLayer of layersByLayer.get(layer)) {
+    if (sceneLayer.options.roofTexture || sceneLayer.options.wallTexture) { hasRoofTexture = true; break; }
+  }
+  if (hasRoofTexture) {
+    for (rasterLayer of Object.values(map._layers)) {
+      if (kindByLayer.get(rasterLayer) === 'raster' && rasterTilesByLayer.get(rasterLayer) && rasterLayer.options.opacity > 0) rasters.push(rasterLayer);
+    }
+    updateRoofAtlas(layer, rasters, now);
+  } else if (roofRasterByLayer.get(layer)) {
+    destroyTexture(layer, roofRasterByLayer.get(layer).texture.texture);
+    roofRasterByLayer.set(layer, null);
+  }
+  return rasters;
+}

package/src/{core → textures}/uploadCanvasTexture.js

@@ -1,5 +1,5 @@
-import { current } from './current.js';
-import { refreshNativeLayer } from './refreshNativeLayer.js';
+import { current } from '../native/isCurrentNativeLayer.js';
+import { refreshNativeLayer } from '../native/refreshNativeLayer.js';
 
 export async function uploadCanvasTexture(state, key, texture, image, device, width, height) {
   let bitmap;

package/src/traffic/addTraffic.js

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

package/src/traffic/disposeTrafficObject.js

@@ -1,4 +1,6 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { highlightedFeatureByLayer } from '../weakmaps/highlightedFeatureByLayer.js';
+import { hoveredFeatureByLayer } from '../weakmaps/hoveredFeatureByLayer.js';
+
 
 
 import * as disposeMesh from '../rendering/disposeMesh.js';
@@ -7,9 +9,9 @@ import * as showFeature from '../picking/showFeature.js';
 
 export function disposeTrafficObject(state, object) {
   if (!object) return;
-  if (sceneByLayer.get(state.layer).highlightedFeature?.mesh === object) {
+  if (highlightedFeatureByLayer.get(state.layer)?.mesh === object) {
     setHighlight.setHighlight(state.layer, null);
-    sceneByLayer.get(state.layer).hoveredFeature = null;
+    hoveredFeatureByLayer.set(state.layer, null);
     showFeature.showFeature(state.layer, null);
   };
   disposeMesh.disposeMesh(state.layer, object);

package/src/traffic/drawTrafficRoute.js

@@ -1,5 +1,5 @@
 import { trafficRouteMaterial } from '../globals/trafficRouteMaterial.js';
-import { routeGeometry } from './routeGeometry.js';
+import { routeGeometry } from '../geometry/routeGeometry.js';
 import { createTrafficMesh } from './createTrafficMesh.js';
 
 

package/src/traffic/groundTraffic.js

@@ -1,16 +1,16 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
 
-
-import { getElevation } from '../terrain/getElevation.js';
+import { readyTerrainOf } from '../terrain/readyTerrainOf.js';
+import { mapElevationOf } from '../terrain/mapElevationOf.js';
 
 export function groundTraffic(state) {
   const { layer, lanes } = state;
-  const terrain = sceneByLayer.get(cameraByMap.get(layer._map)._terrain3D)?._terrainReady && cameraByMap.get(layer._map)._terrain3D, base = sceneByLayer.get(layer).root.position[1];
+  const terrain = readyTerrainOf(layer._map);
+  const base = rootByLayer.get(layer).position[1];
   let lane, i, elevation;
   for (lane of lanes) {
     for (i = 0; i < lane.points.length; i++) {
-      elevation = terrain && (lane.elevation ?? getElevation(terrain, lane.latlngs[i]));
+      elevation = terrain && (lane.elevation ?? mapElevationOf(layer._map, lane.latlngs[i]));
       lane.points[i][2] = Number.isFinite(elevation) && Number.isFinite(base) ? elevation - base : 0;
     }
   }