leaflet-city-mapper 0.0.3 → 0.0.5

package/src/raster/pruneRasterTiles.js

@@ -1,26 +1,35 @@
+import { pruneAfterByLayer } from '../weakmaps/pruneAfterByLayer.js';
+import { pruneVersionByLayer } from '../weakmaps/pruneVersionByLayer.js';
+import { pruneWantedByLayer } from '../weakmaps/pruneWantedByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { rasterVersionByLayer } from '../weakmaps/rasterVersionByLayer.js';
+import { wantedRasterTilesByLayer } from '../weakmaps/wantedRasterTilesByLayer.js';
+
+
+
 import { releaseRasterTile } from './releaseRasterTile.js';
 
-export function pruneRasterTiles(backend) {
-  const wanted = backend._wantedRasterTiles;
+export function pruneRasterTiles(layer) {
+  const wanted = wantedRasterTilesByLayer.get(layer);
   const now = performance.now();
-  if (backend._pruneVersion === backend._rasterVersion && backend._pruneWanted === wanted &&
-    now < backend._pruneAfter) return Number.isFinite(backend._pruneAfter);
-  backend._pruneVersion = backend._rasterVersion;
-  backend._pruneWanted = wanted;
-  backend._pruneAfter = Infinity;
-  const pending = [];
+  if (pruneVersionByLayer.get(layer) === rasterVersionByLayer.get(layer) && pruneWantedByLayer.get(layer) === wanted &&
+    now < pruneAfterByLayer.get(layer)) return Number.isFinite(pruneAfterByLayer.get(layer));
+  pruneVersionByLayer.set(layer, rasterVersionByLayer.get(layer));
+  pruneWantedByLayer.set(layer, wanted);
+  pruneAfterByLayer.set(layer, Infinity);
+  const pending = /* alloc */ [];
   let key, tile, parts, overlaps, coords, zoom;
   for (key of wanted) {
-    tile = backend._rasterTiles.get(key);
+    tile = rasterTilesByLayer.get(layer).get(key);
     if (tile?.done && now - tile.loadedAt < 250) {
-      backend._pruneAfter = Math.min(backend._pruneAfter, tile.loadedAt + 250);
+      pruneAfterByLayer.set(layer, Math.min(pruneAfterByLayer.get(layer), tile.loadedAt + 250));
     }
     if (!tile?.done || now - tile.loadedAt < 250) {
       parts = key.split('/');
-      pending.push({ z: Number(parts[0]), x: Number(parts[1]), y: Number(parts[2]) });
+      pending.push(/* alloc */ { z: Number(parts[0]), x: Number(parts[1]), y: Number(parts[2]) });
     }
   }
-  for ([key, tile] of backend._rasterTiles) {
+  for ([key, tile] of rasterTilesByLayer.get(layer)) {
     if (wanted.has(key)) continue;
     overlaps = false;
     for (coords of pending) {
@@ -31,7 +40,7 @@ export function pruneRasterTiles(backend) {
         break;
       }
     }
-    if (!overlaps) releaseRasterTile(backend, tile);
+    if (!overlaps) releaseRasterTile(layer, tile);
   }
-  return Number.isFinite(backend._pruneAfter);
+  return Number.isFinite(pruneAfterByLayer.get(layer));
 }

package/src/raster/pumpRasterTiles.js

@@ -1,22 +1,28 @@
-import { TILE_SIZE } from "../constants/TILE_SIZE.js";
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+
+import { TILE_SIZE } from '../globals/TILE_SIZE.js';
+
+
+
 import { comparePendingTiles } from './comparePendingTiles.js';
 import { loadRasterTile } from './loadRasterTile.js';
 
-export function pumpRasterTiles(backend) {
-  const map = backend._map;
+export function pumpRasterTiles(layer) {
+  const map = layer._map;
   if (!map) return;
   const center = map.project(map.getCenter(), 0).divideBy(TILE_SIZE);
-  const pending = [];
+  const pending = /* alloc */ [];
   let tile, coords;
-  for (tile of backend._rasterTiles.values()) {
+  for (tile of rasterTilesByLayer.get(layer).values()) {
     if (tile.started || tile.request.signal.aborted) continue;
     ({ coords } = tile);
-    pending.push({ tile, distance: Math.hypot((coords.x + 0.5) / 2 ** coords.z - center.x,
+    pending.push(/* alloc */ { tile, distance: Math.hypot((coords.x + 0.5) / 2 ** coords.z - center.x,
       (coords.y + 0.5) / 2 ** coords.z - center.y) });
   }
   pending.sort(comparePendingTiles);
   for ({ tile } of pending) {
-    if (backend._loadingTiles >= 4) break;
-    loadRasterTile(backend, tile);
+    if (loadingTilesByLayer.get(layer) >= 4) break;
+    loadRasterTile(layer, tile);
   }
 }

package/src/raster/rasterTileRange.js

@@ -0,0 +1,23 @@
+import { TILE_SIZE } from '../globals/TILE_SIZE.js';
+import { TILE_RADIUS } from '../globals/TILE_RADIUS.js';
+import { archiveNorthWest } from '../globals/archiveNorthWest.js';
+import { archiveSouthEast } from '../globals/archiveSouthEast.js';
+
+export function rasterTileRange(map, header, zoom) {
+  const bounds = map.getBounds();
+  const northwest = map.project(bounds.getNorthWest(), zoom).divideBy(TILE_SIZE).floor();
+  const southeast = map.project(bounds.getSouthEast(), zoom).divideBy(TILE_SIZE).floor();
+  archiveNorthWest[0] = header.maxLat; archiveNorthWest[1] = header.minLon;
+  archiveSouthEast[0] = header.minLat; archiveSouthEast[1] = header.maxLon;
+  const archiveMin = header.maxLat === undefined || header.minLon === undefined
+    ? null : map.project(archiveNorthWest, zoom).divideBy(TILE_SIZE).floor();
+  const archiveMax = header.minLat === undefined || header.maxLon === undefined
+    ? null : map.project(archiveSouthEast, zoom).divideBy(TILE_SIZE).floor();
+  const center = map.project(map.getCenter(), zoom).divideBy(TILE_SIZE).floor();
+  return /* alloc */ {
+    minX: Math.max(0, northwest.x, archiveMin?.x ?? 0, center.x - TILE_RADIUS),
+    maxX: Math.min(2 ** zoom - 1, southeast.x, archiveMax?.x ?? 2 ** zoom - 1, center.x + TILE_RADIUS),
+    minY: Math.max(0, northwest.y, archiveMin?.y ?? 0, center.y - TILE_RADIUS),
+    maxY: Math.min(2 ** zoom - 1, southeast.y, archiveMax?.y ?? 2 ** zoom - 1, center.y + TILE_RADIUS),
+  };
+}

package/src/raster/readyRaster.js

@@ -1,13 +1,17 @@
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+
+
+
 import { getHeader } from "../archives/getHeader.js";
 
-export async function readyRaster(layer, archive) {
-  const header = await archive.getHeader();
-  layer.options.archive = archive;
-  layer.header = header;
-  if (layer.options.maxNativeZoom === undefined) {
-    layer.options.maxNativeZoom = header.maxZoom;
-  }
-  layer.options.maxZoom = Math.max(layer.options.minZoom || 0, layer.options.maxZoom);
-  layer.fire('ready');
-  return layer;
+export async function readyRaster(layer, archive) {
+  const header = await getHeader(archive);
+  layer.options.archive = archive;
+  headerByLayer.set(layer, header);
+  if (layer.options.maxNativeZoom === undefined) {
+    layer.options.maxNativeZoom = header.maxZoom;
+  }
+  layer.options.maxZoom = Math.max(layer.options.minZoom || 0, layer.options.maxZoom);
+  layer.fire('ready');
+  return layer;
 }

package/src/raster/registerTerrainTile.js

@@ -1,12 +1,17 @@
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
+
+
+
 import { addRasterTile } from './addRasterTile.js';
 
-export async function registerTerrainTile(backend, coords, tile) {
-  if (backend._terrain3D && tile.done && !tile.request.signal.aborted &&
-    backend._rasterTiles.get(`${coords.z}/${coords.x}/${coords.y}`) === tile) {
-    try {
-      await addRasterTile(backend._terrain3D, backend, coords, tile);
-    } catch (error) {
-      backend.fire('tileerror', { tile, coords, error });
-    }
-  }
+export async function registerTerrainTile(layer, coords, tile) {
+  if (terrain3DByLayer.get(layer) && tile.done && !tile.request.signal.aborted &&
+    rasterTilesByLayer.get(layer).get(`${coords.z}/${coords.x}/${coords.y}`) === tile) {
+    try {
+      await addRasterTile(terrain3DByLayer.get(layer), layer, coords, tile);
+    } catch (error) {
+      layer.fire('tileerror', /* alloc */ { tile, coords, error });
+    }
+  }
 }

package/src/raster/releaseRasterTile.js

@@ -1,18 +1,24 @@
-import { destroyTexture } from '../rendering/destroyTexture.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { rasterVersionByLayer } from '../weakmaps/rasterVersionByLayer.js';
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
+
+
+
+import { destroyTexture } from '../textures/destroyTexture.js';
 import { removeRasterTile } from './removeRasterTile.js';
 import { setParent } from '../scene/setParent.js';
-import { update } from '../scene/update.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
 
-export function releaseRasterTile(backend, tile) {
-  const key = `${tile.coords.z}/${tile.coords.x}/${tile.coords.y}`;
-  if (backend._rasterTiles.get(key) !== tile) return;
-  backend._rasterTiles.delete(key);
-  backend._rasterVersion = (backend._rasterVersion || 0) + 1;
-  tile.request.abort();
-  if(backend._terrain3D) removeRasterTile(backend._terrain3D, tile);
-  if (tile.mesh) setParent(tile.mesh, null);
-  if (tile.texture) destroyTexture(backend, tile.texture.texture);
-  tile.image?.close();
-  backend.fire('tileunload', { tile, coords: tile.coords });
-  update(backend);
+export function releaseRasterTile(layer, tile) {
+  const key = `${tile.coords.z}/${tile.coords.x}/${tile.coords.y}`;
+  if (rasterTilesByLayer.get(layer).get(key) !== tile) return;
+  rasterTilesByLayer.get(layer).delete(key);
+  rasterVersionByLayer.set(layer, (rasterVersionByLayer.get(layer) || 0) + 1);
+  tile.request.abort();
+  if(terrain3DByLayer.get(layer)) removeRasterTile(terrain3DByLayer.get(layer), tile);
+  if (tile.mesh) setParent(tile.mesh, null);
+  if (tile.texture) destroyTexture(layer, tile.texture.texture);
+  tile.image?.close();
+  layer.fire('tileunload', /* alloc */ { tile, coords: tile.coords });
+  update(layer);
 }

package/src/raster/releaseRasterTiles.js

@@ -1,15 +1,21 @@
-import { destroyTexture } from '../rendering/destroyTexture.js';
+import { rasterGeometryByLayer } from '../weakmaps/rasterGeometryByLayer.js';
+import { rasterProgramByLayer } from '../weakmaps/rasterProgramByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+
+
+
+import { destroyTexture } from '../textures/destroyTexture.js';
 import { releaseRasterTile } from './releaseRasterTile.js';
 
-export function releaseRasterTiles(backend) {
+export function releaseRasterTiles(layer) {
   let tile, attribute;
-  for (tile of backend._rasterTiles.values()) releaseRasterTile(backend, tile);
-  backend._rasterProgram?.pipelineCache.clear();
-  backend._rasterProgram = null;
-  if (backend._rasterGeometry) {
-    for (attribute of Object.values(backend._rasterGeometry.attributes)) {
-      destroyTexture(backend, attribute.buffer);
+  for (tile of rasterTilesByLayer.get(layer).values()) releaseRasterTile(layer, tile);
+  rasterProgramByLayer.get(layer)?.pipelineCache.clear();
+  rasterProgramByLayer.set(layer, null);
+  if (rasterGeometryByLayer.get(layer)) {
+    for (attribute of Object.values(rasterGeometryByLayer.get(layer).attributes)) {
+      destroyTexture(layer, attribute.buffer);
     }
-    backend._rasterGeometry = null;
+    rasterGeometryByLayer.set(layer, null);
   }
 }

package/src/raster/removeRasterTile.js

@@ -1,13 +1,18 @@
-import { destroyTexture } from '../rendering/destroyTexture.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { terrainRequestByLayer } from '../weakmaps/terrainRequestByLayer.js';
+
+
+
+import { destroyTexture } from '../textures/destroyTexture.js';
 import { setParent } from '../scene/setParent.js';
-import { update } from '../scene/update.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
 
 export function removeRasterTile(layer, tile) {
-  layer._terrainRequest?.abort();
-  const mesh = layer._rasterTiles.get(tile);
+  terrainRequestByLayer.get(layer)?.abort();
+  const mesh = rasterTilesByLayer.get(layer).get(tile);
   if (!mesh) return;
   setParent(mesh, null);
   update(layer);
   if (mesh.texture !== tile.texture) destroyTexture(layer, mesh.texture.texture);
-  layer._rasterTiles.delete(tile);
+  rasterTilesByLayer.get(layer).delete(tile);
 }

package/src/raster/{reportError.js → reportRasterError.js}

@@ -1,6 +1,6 @@
 
 
-export function reportError(layer, error) {
-  layer.fire('error', { error });
-  throw error;
+export function reportError(layer, error) {
+  layer.fire('error', /* alloc */ { error });
+  throw error;
 }

package/src/raster/retainRasterTiles.js

@@ -0,0 +1,16 @@
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+
+import { releaseRasterTile } from './releaseRasterTile.js';
+
+export function retainRasterTiles(layer, required) {
+  const tiles = rasterTilesByLayer.get(layer);
+  let key, tile, coords;
+  for ([key, tile] of tiles) {
+    if (!required.has(key) && !tile.done) releaseRasterTile(layer, tile);
+  }
+  for ([key, coords] of required) {
+    if (tiles.has(key)) continue;
+    tile = /* alloc */ { coords, request: /* alloc */ new AbortController(), done: false };
+    tiles.set(key, tile);
+  }
+}

package/src/raster/setPMTileOpacity.js

@@ -1,7 +1,7 @@
 import { setRasterOpacity } from './setRasterOpacity.js';
 
-export function setPMTileOpacity(backend, opacity) {
-  backend.options.opacity = opacity;
-  setRasterOpacity(backend, opacity);
-  return backend;
+export function setPMTileOpacity(layer, opacity) {
+  layer.options.opacity = opacity;
+  setRasterOpacity(layer, opacity);
+  return layer;
 }

package/src/raster/setPMTileZIndex.js

@@ -1,7 +1,7 @@
 import { setRasterZIndex } from './setRasterZIndex.js';
 
-export function setPMTileZIndex(backend, zIndex) {
-  backend.options.zIndex = zIndex;
-  setRasterZIndex(backend, zIndex);
-  return backend;
+export function setPMTileZIndex(layer, zIndex) {
+  layer.options.zIndex = zIndex;
+  setRasterZIndex(layer, zIndex);
+  return layer;
 }

package/src/raster/setRasterOpacity.js

@@ -1,11 +1,16 @@
-import { update } from '../scene/update.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
 
-export function setRasterOpacity(backend, opacity) {
+
+
+import { update } from '../scene/scheduleSceneUpdate.js';
+
+export function setRasterOpacity(layer, opacity) {
   let tile, terrainMesh;
-  for (tile of backend._rasterTiles.values()) {
+  for (tile of rasterTilesByLayer.get(layer).values()) {
     if (tile.mesh) tile.mesh.opacity = opacity;
-    terrainMesh = backend._terrain3D?._rasterTiles.get(tile);
+    terrainMesh = rasterTilesByLayer.get(terrain3DByLayer.get(layer)).get(tile);
     if (terrainMesh) terrainMesh.opacity = opacity;
   }
-  update(backend);
+  update(layer);
 }

package/src/raster/setRasterTerrain.js

@@ -1,21 +1,28 @@
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
+
+
+
 import { removeRasterTile } from './removeRasterTile.js';
 import { setParent } from '../scene/setParent.js';
 import { registerTerrainTile } from './registerTerrainTile.js';
 
-export function setRasterTerrain(backend, terrain) {
-  if (backend._terrain3D === terrain) return;
+export function setRasterTerrain(layer, terrain) {
+  // Pending sources bind the current terrain when their raster attachment is ready.
+  if (!rasterTilesByLayer.get(layer) || terrain3DByLayer.get(layer) === terrain) return;
   let tile;
-  for (tile of backend._rasterTiles.values()) {
-    if(backend._terrain3D) removeRasterTile(backend._terrain3D, tile);
+  for (tile of rasterTilesByLayer.get(layer).values()) {
+    if(terrain3DByLayer.get(layer)) removeRasterTile(terrain3DByLayer.get(layer), tile);
     if (tile.mesh) {
       tile.mesh.visible = true;
-      setParent(tile.mesh, backend.root);
+      setParent(tile.mesh, rootByLayer.get(layer));
     }
   }
-  backend._terrain3D = terrain || null;
+  terrain3DByLayer.set(layer, terrain || null);
   if (terrain) {
-    for (tile of backend._rasterTiles.values()) {
-      if (tile.done) registerTerrainTile(backend, tile.coords, tile);
+    for (tile of rasterTilesByLayer.get(layer).values()) {
+      if (tile.done) registerTerrainTile(layer, tile.coords, tile);
     }
   }
 }

package/src/raster/setRasterZIndex.js

@@ -1,11 +1,16 @@
-import { update } from '../scene/update.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
 
-export function setRasterZIndex(backend, zIndex) {
+
+
+import { update } from '../scene/scheduleSceneUpdate.js';
+
+export function setRasterZIndex(layer, zIndex) {
   let tile, terrainMesh;
-  for (tile of backend._rasterTiles.values()) {
+  for (tile of rasterTilesByLayer.get(layer).values()) {
     if (tile.mesh) tile.mesh.renderOrder = zIndex;
-    terrainMesh = backend._terrain3D?._rasterTiles.get(tile);
+    terrainMesh = rasterTilesByLayer.get(terrain3DByLayer.get(layer)).get(tile);
     if (terrainMesh) terrainMesh.renderOrder = zIndex;
   }
-  update(backend);
+  update(layer);
 }

package/src/raster/updateAttachedTiles.js

@@ -1,10 +1,14 @@
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+
+
+
 import { updateRasterTiles } from "./updateRasterTiles.js";
 
-export async function updateAttachedTiles(backend, map, attached) {
+export async function updateAttachedTiles(layer, map, attached) {
   try {
-    await Promise.all([attached, backend.ready]);
-    if (backend._map === map && map.hasLayer(backend)) updateRasterTiles(backend);
+    await Promise.all(/* alloc */ [attached, readyByLayer.get(layer)]);
+    if (layer._map === map && map.hasLayer(layer)) updateRasterTiles(layer);
   } catch (error) {
-    backend.fire('error', { error });
+    layer.fire('error', /* alloc */ { error });
   }
 }

package/src/raster/updateRasterTiles.js

@@ -1,59 +1,56 @@
-import { TILE_RADIUS } from '../constants/TILE_RADIUS.js';
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+import { tileZoomByLayer } from '../weakmaps/tileZoomByLayer.js';
+import { wantedRasterTilesByLayer } from '../weakmaps/wantedRasterTilesByLayer.js';
+
+import { wantedTiles } from '../globals/wantedTiles.js';
+import { coverageTiles } from '../globals/coverageTiles.js';
+
+
+
 import { pumpRasterTiles } from './pumpRasterTiles.js';
-import { TILE_SIZE } from '../constants/TILE_SIZE.js';
-import { releaseRasterTile } from './releaseRasterTile.js';
+
+import { retainRasterTiles } from './retainRasterTiles.js';
 import { pruneRasterTiles } from './pruneRasterTiles.js';
+import { rasterTileRange } from './rasterTileRange.js';
 
 // ponytail: cap horizon views at 169 tiles; raise the radius if extreme pitches need more.
 
-export function updateRasterTiles(backend) {
-  const map = backend._map;
-  if (!map || !backend._shared || !backend.header) return;
+export function updateRasterTiles(layer) {
+  const map = layer._map;
+  if (!map || !sharedByLayer.get(layer) || !headerByLayer.get(layer)) return;
 
-  const zoom = Math.max(backend.header.minZoom ?? 0, Math.min(
+  const zoom = Math.max(headerByLayer.get(layer).minZoom ?? 0, Math.min(
     Math.round(map.getZoom()),
-    backend.options.maxZoom,
-    backend.options.maxNativeZoom
+    layer.options.maxZoom,
+    layer.options.maxNativeZoom
   ));
-  backend._tileZoom = zoom;
-  const bounds = map.getBounds();
-  const northWest = map.project(bounds.getNorthWest(), zoom).divideBy(TILE_SIZE).floor();
-  const southEast = map.project(bounds.getSouthEast(), zoom).divideBy(TILE_SIZE).floor();
-  const archiveNorthWest = backend.header.maxLat === undefined || backend.header.minLon === undefined
-    ? new L.Point(0, 0)
-    : map.project([backend.header.maxLat, backend.header.minLon], zoom).divideBy(TILE_SIZE).floor();
-  const archiveSouthEast = backend.header.minLat === undefined || backend.header.maxLon === undefined
-    ? new L.Point(2 ** zoom - 1, 2 ** zoom - 1)
-    : map.project([backend.header.minLat, backend.header.maxLon], zoom).divideBy(TILE_SIZE).floor();
-  const center = map.project(map.getCenter(), zoom).divideBy(TILE_SIZE).floor();
-  const wanted = new Map();
-  let x, y, key, coords, parent, tile;
-  for (x = Math.max(0, northWest.x, archiveNorthWest.x, center.x - TILE_RADIUS);
-    x <= Math.min(2 ** zoom - 1, southEast.x, archiveSouthEast.x, center.x + TILE_RADIUS); x++) {
-    for (y = Math.max(0, northWest.y, archiveNorthWest.y, center.y - TILE_RADIUS);
-      y <= Math.min(2 ** zoom - 1, southEast.y, archiveSouthEast.y, center.y + TILE_RADIUS); y++) {
-      wanted.set(`${zoom}/${x}/${y}`, { z: zoom, x, y });
+  tileZoomByLayer.set(layer, zoom);
+  const range = rasterTileRange(map, headerByLayer.get(layer), zoom);
+  const wanted = wantedTiles;
+  wanted.clear();
+  let x, y, key, coords, parent;
+  for (x = range.minX; x <= range.maxX; x++) {
+    for (y = range.minY; y <= range.maxY; y++) {
+      wanted.set(`${zoom}/${x}/${y}`, /* alloc */ { z: zoom, x, y });
     }
   }
-  backend._wantedRasterTiles = new Set(wanted.keys());
-  const coverage = new Map();
-  const parentZoom = Math.max(backend.header.minZoom ?? 0, zoom - 2), factor = 2 ** (zoom - parentZoom);
+  wantedRasterTilesByLayer.set(layer, /* alloc */ new Set(wanted.keys()));
+  const coverage = coverageTiles;
+  coverage.clear();
+  const parentZoom = Math.max(headerByLayer.get(layer).minZoom ?? 0, zoom - 2), factor = 2 ** (zoom - parentZoom);
   if (parentZoom < zoom) {
     for ([key, coords] of wanted) {
-      if (backend._rasterTiles.get(key)?.done) continue;
-      parent = { z: parentZoom, x: Math.floor(coords.x / factor), y: Math.floor(coords.y / factor) };
+      if (rasterTilesByLayer.get(layer).get(key)?.done) continue;
+      parent = /* alloc */ { z: parentZoom, x: Math.floor(coords.x / factor), y: Math.floor(coords.y / factor) };
       coverage.set(`${parent.z}/${parent.x}/${parent.y}`, parent);
     }
   }
-  const required = new Map([...coverage, ...wanted]);
-  for ([key, tile] of backend._rasterTiles) {
-    if (!required.has(key) && !tile.done) releaseRasterTile(backend, tile);
-  }
-  for ([key, coords] of required) {
-    if (backend._rasterTiles.has(key)) continue;
-    tile = { coords, request: new AbortController(), done: false };
-    backend._rasterTiles.set(key, tile);
-  }
-  pumpRasterTiles(backend);
-  pruneRasterTiles(backend);
+  const required = /* alloc */ new Map(coverage);
+  for ([key, coords] of wanted) required.set(key, coords);
+  wanted.clear(); coverage.clear();
+  retainRasterTiles(layer, required);
+  pumpRasterTiles(layer);
+  pruneRasterTiles(layer);
 }

package/src/rendering/collectFrameMeshes.js

@@ -1,15 +1,27 @@
-import { updateWorldMatrix } from "../scene/updateWorldMatrix.js";
+import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
+import { shadowMeshesByLayer } from '../weakmaps/shadowMeshesByLayer.js';
+import { visibleMeshesByLayer } from '../weakmaps/visibleMeshesByLayer.js';
+
+
+
+import { updateWorldMatrix } from "../transforms/updateWorldMatrix.js";
 import { collectMeshes } from './collectMeshes.js';
 
-export function collectFrameMeshes(backend, sunlight, sceneChanged) {
-  const camera = backend.camera;
+export function collectFrameMeshes(layer, sunlight, sceneChanged) {
+  const camera = cameraByLayer.get(layer);
   const projection = camera.projectionViewMatrix;
-  const renderer = backend.renderer;
-  const frustum = renderer.frustum ||= [
-    new Float64Array(4), new Float64Array(4), new Float64Array(4),
-    new Float64Array(4), new Float64Array(4), new Float64Array(4),
+  const renderer = rendererByLayer.get(layer);
+  const frustum = renderer.frustum ||= /* alloc */ [
+    /* alloc */ new Float64Array(4),
+    /* alloc */ new Float64Array(4),
+    /* alloc */ new Float64Array(4),
+    /* alloc */ new Float64Array(4),
+    /* alloc */ new Float64Array(4),
+    /* alloc */ new Float64Array(4),
   ];
-  const frustumLengths = renderer.frustumLengths ||= new Float64Array(6);
+  const frustumLengths = renderer.frustumLengths ||= /* alloc */ new Float64Array(6);
   let i, axis, plane, j, offset;
   for (i = 0; i < 6; i++) {
     axis = Math.floor(i / 2);
@@ -22,10 +34,12 @@ export function collectFrameMeshes(backend, sunlight, sceneChanged) {
     }
     frustumLengths[i] = Math.hypot(plane[0], plane[1], plane[2]);
   }
-  const candidates = backend._visibleMeshes ||= [];
+  let candidates = visibleMeshesByLayer.get(layer);
+  if (!candidates) visibleMeshesByLayer.set(layer, candidates = /* alloc */ []);
   candidates.length = 0;
-  const shadowMeshes = backend._shadowMeshes ||= [];
+  let shadowMeshes = shadowMeshesByLayer.get(layer);
+  if (!shadowMeshes) shadowMeshesByLayer.set(layer, shadowMeshes = /* alloc */ []);
   shadowMeshes.length = 0;
-  if (sceneChanged) updateWorldMatrix(backend.scene);
-  collectMeshes(backend.scene, sunlight, projection, frustum, frustumLengths, candidates, shadowMeshes);
+  if (sceneChanged) updateWorldMatrix(sceneByLayer.get(layer));
+  collectMeshes(sceneByLayer.get(layer), sunlight, projection, frustum, frustumLengths, candidates, shadowMeshes);
 }

package/src/rendering/collectMeshes.js

@@ -1,33 +1,11 @@
-import { computeBounds } from '../geometry/computeBounds.js';
+import { collectVisibleMesh } from './collectVisibleMesh.js';
 
 export function collectMeshes(mesh, sunlight, projection, frustum, frustumLengths, candidates, shadowMeshes) {
   if (!mesh.visible) return;
   if (mesh.geometry) {
     if (sunlight?.altitude >= 3 && !mesh.tile && mesh._appearance !== 0 &&
       !mesh.program.nightLight && mesh.program.depthTest !== false) shadowMeshes.push(mesh);
-    if (!mesh.geometry.bounds) computeBounds(mesh.geometry);
-    const bounds = mesh.geometry.bounds;
-    const world = mesh.worldMatrix;
-    const center = bounds.center;
-    const x = world[0] * center[0] + world[4] * center[1] + world[8] * center[2] + world[12];
-    const y = world[1] * center[0] + world[5] * center[1] + world[9] * center[2] + world[13];
-    const z = world[2] * center[0] + world[6] * center[1] + world[10] * center[2] + world[14];
-    const clipZ = projection[2] * x + projection[6] * y + projection[10] * z + projection[14];
-    const clipW = projection[3] * x + projection[7] * y + projection[11] * z + projection[15];
-    mesh._sortDepth = clipZ / clipW;
-    const radius = bounds.radius * Math.max(
-      Math.hypot(world[0], world[1], world[2]),
-      Math.hypot(world[4], world[5], world[6]),
-      Math.hypot(world[8], world[9], world[10])
-    );
-    mesh._visibleInFrame =
-      frustum[0][0] * x + frustum[0][1] * y + frustum[0][2] * z + frustum[0][3] >= -radius * frustumLengths[0] &&
-      frustum[1][0] * x + frustum[1][1] * y + frustum[1][2] * z + frustum[1][3] >= -radius * frustumLengths[1] &&
-      frustum[2][0] * x + frustum[2][1] * y + frustum[2][2] * z + frustum[2][3] >= -radius * frustumLengths[2] &&
-      frustum[3][0] * x + frustum[3][1] * y + frustum[3][2] * z + frustum[3][3] >= -radius * frustumLengths[3] &&
-      frustum[4][0] * x + frustum[4][1] * y + frustum[4][2] * z + frustum[4][3] >= -radius * frustumLengths[4] &&
-      frustum[5][0] * x + frustum[5][1] * y + frustum[5][2] * z + frustum[5][3] >= -radius * frustumLengths[5];
-    if (mesh._visibleInFrame) candidates.push(mesh);
+    collectVisibleMesh(mesh, projection, frustum, frustumLengths, candidates);
   }
   let child;
   for (child of mesh.children) {