leaflet-city-mapper 0.0.4 → 0.0.6

package/src/raster/initRaster.js

@@ -1,13 +1,22 @@
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+import { directoriesByLayer } from '../weakmaps/directoriesByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { urlByLayer } from '../weakmaps/urlByLayer.js';
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
-import { isLoading } from './isLoading.js';
+import { isLoading } from './isRasterLoading.js';
 import { getRasterEvents } from './getRasterEvents.js';
 import { readyRaster } from './readyRaster.js';
-import { reportError } from './reportError.js';
-import { emptyNode } from '../scene/emptyNode.js';
-import { read } from '../archives/read.js';
+import { reportError } from './reportRasterError.js';
+import { emptyNode } from '../scene/createSceneNode.js';
+import { read } from '../archives/readArchiveRange.js';
 import { getHeader } from '../archives/getHeader.js';
 import { getZxy } from '../archives/getZxy.js';
 import { onPMTileAdd } from './onPMTileAdd.js';
@@ -17,17 +26,17 @@ import { setPMTileOpacity } from './setPMTileOpacity.js';
 import { setPMTileZIndex } from './setPMTileZIndex.js';
 
 export function initRaster(layer, options) {
-  sceneByLayer.get(layer).kind = 'raster';
+  kindByLayer.set(layer, 'raster');
   options = /* alloc */ { ariaLabel: 'PMTiles raster', maxZoom: 18, opacity: 1, zIndex: 0, ...options };
   L.Util.setOptions(layer, options);
-  sceneByLayer.get(layer).root = emptyNode();
-  sceneByLayer.get(layer)._areas = /* alloc */ new Map();
-  sceneByLayer.get(layer)._rasterTiles = /* alloc */ new Map();
-  sceneByLayer.get(layer)._loadingTiles = 0;
-  sceneByLayer.get(layer)._added = Promise.withResolvers();
-  sceneByLayer.get(layer).url = /* alloc */ new URL(options.url, document.baseURI).href;
-  sceneByLayer.get(layer)._directories = /* alloc */ new Map();
-  sceneByLayer.get(layer).ready = Promise.resolve(layer.options.archive || layer)
+  rootByLayer.set(layer, emptyNode());
+  areasByLayer.set(layer, /* alloc */ new Map());
+  rasterTilesByLayer.set(layer, /* alloc */ new Map());
+  loadingTilesByLayer.set(layer, 0);
+  addedByLayer.set(layer, Promise.withResolvers());
+  urlByLayer.set(layer, /* alloc */ new URL(options.url, document.baseURI).href);
+  directoriesByLayer.set(layer, /* alloc */ new Map());
+  readyByLayer.set(layer, Promise.resolve(layer.options.archive || layer)
     .then(readyRaster.bind(null, layer))
-    .catch(reportError.bind(null, layer));
+    .catch(reportError.bind(null, layer)));
 }

package/src/raster/isRasterLoading.js

@@ -0,0 +1,8 @@
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+
+
+
+
+export function isLoading(layer) {
+  return loadingTilesByLayer.get(layer) > 0;
+}

package/src/raster/loadRasterTile.js

@@ -1,13 +1,14 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+
 
 
 import { finishRasterTile } from './finishRasterTile.js';
 
-export function loadRasterTile(backend, tile) {
+export function loadRasterTile(layer, tile) {
   tile.started = true;
-  const first = sceneByLayer.get(backend)._loadingTiles === 0;
-  sceneByLayer.get(backend)._loadingTiles++;
-  backend.fire('tileloadstart', /* alloc */ { tile, coords: tile.coords });
-  if (first) backend.fire('loading');
-  return finishRasterTile(backend, tile);
+  const first = loadingTilesByLayer.get(layer) === 0;
+  loadingTilesByLayer.set(layer, loadingTilesByLayer.get(layer) + 1);
+  layer.fire('tileloadstart', /* alloc */ { tile, coords: tile.coords });
+  if (first) layer.fire('loading');
+  return finishRasterTile(layer, tile);
 }

package/src/raster/onPMTileAdd.js

@@ -1,13 +1,14 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
 
 
-import { finishAttachment } from './finishAttachment.js';
+
+import { finishAttachment } from './finishRasterAttachment.js';
 import { updateAttachedTiles } from './updateAttachedTiles.js';
-import { attach } from '../scene/attach.js';
+import { attach } from '../scene/attachSharedScene.js';
 
-export function onPMTileAdd(backend, map) {
-  if (!sceneByLayer.get(backend).location) sceneByLayer.get(backend).location = map.getCenter();
-  const attached = attach(backend, map);
-  finishAttachment(backend, map, attached);
-  updateAttachedTiles(backend, map, attached);
+export function onPMTileAdd(layer, map) {
+  if (!locationByLayer.get(layer)) locationByLayer.set(layer, map.getCenter());
+  const attached = attach(layer, map);
+  finishAttachment(layer, map, attached);
+  updateAttachedTiles(layer, map, attached);
 }

package/src/raster/onPMTileRemove.js

@@ -1,11 +1,12 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
+
 
 
 import { releaseRasterTiles } from './releaseRasterTiles.js';
 import { onRemove3DLayer } from '../scene/onRemove3DLayer.js';
 
-export function onPMTileRemove(backend, map) {
-  releaseRasterTiles(backend);
-  sceneByLayer.get(backend)._terrain3D = null;
-  onRemove3DLayer(backend, map);
+export function onPMTileRemove(layer, map) {
+  releaseRasterTiles(layer);
+  terrain3DByLayer.set(layer, null);
+  onRemove3DLayer(layer, map);
 }

package/src/raster/pruneRasterTiles.js

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

package/src/raster/pumpRasterTiles.js

@@ -1,18 +1,20 @@
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+
 import { TILE_SIZE } from '../globals/TILE_SIZE.js';
-import { sceneByLayer } from '../globals/sceneByLayer.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 = /* alloc */ [];
   let tile, coords;
-  for (tile of sceneByLayer.get(backend)._rasterTiles.values()) {
+  for (tile of rasterTilesByLayer.get(layer).values()) {
     if (tile.started || tile.request.signal.aborted) continue;
     ({ coords } = tile);
     pending.push(/* alloc */ { tile, distance: Math.hypot((coords.x + 0.5) / 2 ** coords.z - center.x,
@@ -20,7 +22,7 @@ export function pumpRasterTiles(backend) {
   }
   pending.sort(comparePendingTiles);
   for ({ tile } of pending) {
-    if (sceneByLayer.get(backend)._loadingTiles >= 4) break;
-    loadRasterTile(backend, tile);
+    if (loadingTilesByLayer.get(layer) >= 4) break;
+    loadRasterTile(layer, tile);
   }
 }

package/src/raster/readyRaster.js

@@ -1,4 +1,5 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+
 
 
 import { getHeader } from "../archives/getHeader.js";
@@ -6,7 +7,7 @@ import { getHeader } from "../archives/getHeader.js";
 export async function readyRaster(layer, archive) {
   const header = await getHeader(archive);
   layer.options.archive = archive;
-  sceneByLayer.get(layer).header = header;
+  headerByLayer.set(layer, header);
   if (layer.options.maxNativeZoom === undefined) {
     layer.options.maxNativeZoom = header.maxZoom;
   }

package/src/raster/registerTerrainTile.js

@@ -1,15 +1,17 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+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 (sceneByLayer.get(backend)._terrain3D && tile.done && !tile.request.signal.aborted &&
-    sceneByLayer.get(backend)._rasterTiles.get(`${coords.z}/${coords.x}/${coords.y}`) === tile) {
+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(sceneByLayer.get(backend)._terrain3D, backend, coords, tile);
+      await addRasterTile(terrain3DByLayer.get(layer), layer, coords, tile);
     } catch (error) {
-      backend.fire('tileerror', /* alloc */ { tile, coords, error });
+      layer.fire('tileerror', /* alloc */ { tile, coords, error });
     }
   }
 }

package/src/raster/releaseRasterTile.js

@@ -1,21 +1,24 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { rasterVersionByLayer } from '../weakmaps/rasterVersionByLayer.js';
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
 
 
-import { destroyTexture } from '../rendering/destroyTexture.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) {
+export function releaseRasterTile(layer, tile) {
   const key = `${tile.coords.z}/${tile.coords.x}/${tile.coords.y}`;
-  if (sceneByLayer.get(backend)._rasterTiles.get(key) !== tile) return;
-  sceneByLayer.get(backend)._rasterTiles.delete(key);
-  sceneByLayer.get(backend)._rasterVersion = (sceneByLayer.get(backend)._rasterVersion || 0) + 1;
+  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(sceneByLayer.get(backend)._terrain3D) removeRasterTile(sceneByLayer.get(backend)._terrain3D, tile);
+  if(terrain3DByLayer.get(layer)) removeRasterTile(terrain3DByLayer.get(layer), tile);
   if (tile.mesh) setParent(tile.mesh, null);
-  if (tile.texture) destroyTexture(backend, tile.texture.texture);
+  if (tile.texture) destroyTexture(layer, tile.texture.texture);
   tile.image?.close();
-  backend.fire('tileunload', /* alloc */ { tile, coords: tile.coords });
-  update(backend);
+  layer.fire('tileunload', /* alloc */ { tile, coords: tile.coords });
+  update(layer);
 }

package/src/raster/releaseRasterTiles.js

@@ -1,18 +1,21 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rasterGeometryByLayer } from '../weakmaps/rasterGeometryByLayer.js';
+import { rasterProgramByLayer } from '../weakmaps/rasterProgramByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
 
 
-import { destroyTexture } from '../rendering/destroyTexture.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 sceneByLayer.get(backend)._rasterTiles.values()) releaseRasterTile(backend, tile);
-  sceneByLayer.get(backend)._rasterProgram?.pipelineCache.clear();
-  sceneByLayer.get(backend)._rasterProgram = null;
-  if (sceneByLayer.get(backend)._rasterGeometry) {
-    for (attribute of Object.values(sceneByLayer.get(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);
     }
-    sceneByLayer.get(backend)._rasterGeometry = null;
+    rasterGeometryByLayer.set(layer, null);
   }
 }

package/src/raster/removeRasterTile.js

@@ -1,16 +1,18 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { terrainRequestByLayer } from '../weakmaps/terrainRequestByLayer.js';
 
 
-import { destroyTexture } from '../rendering/destroyTexture.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) {
-  sceneByLayer.get(layer)._terrainRequest?.abort();
-  const mesh = sceneByLayer.get(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);
-  sceneByLayer.get(layer)._rasterTiles.delete(tile);
+  rasterTilesByLayer.get(layer).delete(tile);
 }

package/src/raster/retainRasterTiles.js

@@ -1,11 +1,12 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+
 import { releaseRasterTile } from './releaseRasterTile.js';
 
-export function retainRasterTiles(backend, required) {
-  const tiles = sceneByLayer.get(backend)._rasterTiles;
+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(backend, tile);
+    if (!required.has(key) && !tile.done) releaseRasterTile(layer, tile);
   }
   for ([key, coords] of required) {
     if (tiles.has(key)) continue;

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,14 +1,16 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
 
 
-import { update } from '../scene/update.js';
 
-export function setRasterOpacity(backend, opacity) {
+import { update } from '../scene/scheduleSceneUpdate.js';
+
+export function setRasterOpacity(layer, opacity) {
   let tile, terrainMesh;
-  for (tile of sceneByLayer.get(backend)._rasterTiles.values()) {
+  for (tile of rasterTilesByLayer.get(layer).values()) {
     if (tile.mesh) tile.mesh.opacity = opacity;
-    terrainMesh = sceneByLayer.get(sceneByLayer.get(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,25 +1,28 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+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) {
+export function setRasterTerrain(layer, terrain) {
   // Pending sources bind the current terrain when their raster attachment is ready.
-  if (!sceneByLayer.get(backend)._rasterTiles || sceneByLayer.get(backend)._terrain3D === terrain) return;
+  if (!rasterTilesByLayer.get(layer) || terrain3DByLayer.get(layer) === terrain) return;
   let tile;
-  for (tile of sceneByLayer.get(backend)._rasterTiles.values()) {
-    if(sceneByLayer.get(backend)._terrain3D) removeRasterTile(sceneByLayer.get(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, sceneByLayer.get(backend).root);
+      setParent(tile.mesh, rootByLayer.get(layer));
     }
   }
-  sceneByLayer.get(backend)._terrain3D = terrain || null;
+  terrain3DByLayer.set(layer, terrain || null);
   if (terrain) {
-    for (tile of sceneByLayer.get(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,14 +1,16 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
 
 
-import { update } from '../scene/update.js';
 
-export function setRasterZIndex(backend, zIndex) {
+import { update } from '../scene/scheduleSceneUpdate.js';
+
+export function setRasterZIndex(layer, zIndex) {
   let tile, terrainMesh;
-  for (tile of sceneByLayer.get(backend)._rasterTiles.values()) {
+  for (tile of rasterTilesByLayer.get(layer).values()) {
     if (tile.mesh) tile.mesh.renderOrder = zIndex;
-    terrainMesh = sceneByLayer.get(sceneByLayer.get(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,13 +1,14 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+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(/* alloc */ [attached, sceneByLayer.get(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', /* alloc */ { error });
+    layer.fire('error', /* alloc */ { error });
   }
 }

package/src/raster/updateRasterTiles.js

@@ -1,4 +1,9 @@
-import { sceneByLayer } from '../globals/sceneByLayer.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';
 
@@ -12,17 +17,17 @@ 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 || !sceneByLayer.get(backend)._shared || !sceneByLayer.get(backend).header) return;
+export function updateRasterTiles(layer) {
+  const map = layer._map;
+  if (!map || !sharedByLayer.get(layer) || !headerByLayer.get(layer)) return;
 
-  const zoom = Math.max(sceneByLayer.get(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
   ));
-  sceneByLayer.get(backend)._tileZoom = zoom;
-  const range = rasterTileRange(map, sceneByLayer.get(backend).header, zoom);
+  tileZoomByLayer.set(layer, zoom);
+  const range = rasterTileRange(map, headerByLayer.get(layer), zoom);
   const wanted = wantedTiles;
   wanted.clear();
   let x, y, key, coords, parent;
@@ -31,13 +36,13 @@ export function updateRasterTiles(backend) {
       wanted.set(`${zoom}/${x}/${y}`, /* alloc */ { z: zoom, x, y });
     }
   }
-  sceneByLayer.get(backend)._wantedRasterTiles = /* alloc */ new Set(wanted.keys());
+  wantedRasterTilesByLayer.set(layer, /* alloc */ new Set(wanted.keys()));
   const coverage = coverageTiles;
   coverage.clear();
-  const parentZoom = Math.max(sceneByLayer.get(backend).header.minZoom ?? 0, zoom - 2), factor = 2 ** (zoom - parentZoom);
+  const parentZoom = Math.max(headerByLayer.get(layer).minZoom ?? 0, zoom - 2), factor = 2 ** (zoom - parentZoom);
   if (parentZoom < zoom) {
     for ([key, coords] of wanted) {
-      if (sceneByLayer.get(backend)._rasterTiles.get(key)?.done) continue;
+      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);
     }
@@ -45,7 +50,7 @@ export function updateRasterTiles(backend) {
   const required = /* alloc */ new Map(coverage);
   for ([key, coords] of wanted) required.set(key, coords);
   wanted.clear(); coverage.clear();
-  retainRasterTiles(backend, required);
-  pumpRasterTiles(backend);
-  pruneRasterTiles(backend);
+  retainRasterTiles(layer, required);
+  pumpRasterTiles(layer);
+  pruneRasterTiles(layer);
 }

package/src/rendering/collectFrameMeshes.js

@@ -1,13 +1,18 @@
-import { sceneByLayer } from '../globals/sceneByLayer.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 "../scene/updateWorldMatrix.js";
+
+import { updateWorldMatrix } from "../transforms/updateWorldMatrix.js";
 import { collectMeshes } from './collectMeshes.js';
 
-export function collectFrameMeshes(backend, sunlight, sceneChanged) {
-  const camera = sceneByLayer.get(backend).camera;
+export function collectFrameMeshes(layer, sunlight, sceneChanged) {
+  const camera = cameraByLayer.get(layer);
   const projection = camera.projectionViewMatrix;
-  const renderer = sceneByLayer.get(backend).renderer;
+  const renderer = rendererByLayer.get(layer);
   const frustum = renderer.frustum ||= /* alloc */ [
     /* alloc */ new Float64Array(4),
     /* alloc */ new Float64Array(4),
@@ -29,10 +34,12 @@ export function collectFrameMeshes(backend, sunlight, sceneChanged) {
     }
     frustumLengths[i] = Math.hypot(plane[0], plane[1], plane[2]);
   }
-  const candidates = sceneByLayer.get(backend)._visibleMeshes ||= /* alloc */ [];
+  let candidates = visibleMeshesByLayer.get(layer);
+  if (!candidates) visibleMeshesByLayer.set(layer, candidates = /* alloc */ []);
   candidates.length = 0;
-  const shadowMeshes = sceneByLayer.get(backend)._shadowMeshes ||= /* alloc */ [];
+  let shadowMeshes = shadowMeshesByLayer.get(layer);
+  if (!shadowMeshes) shadowMeshesByLayer.set(layer, shadowMeshes = /* alloc */ []);
   shadowMeshes.length = 0;
-  if (sceneChanged) updateWorldMatrix(sceneByLayer.get(backend).scene);
-  collectMeshes(sceneByLayer.get(backend).scene, sunlight, projection, frustum, frustumLengths, candidates, shadowMeshes);
+  if (sceneChanged) updateWorldMatrix(sceneByLayer.get(layer));
+  collectMeshes(sceneByLayer.get(layer), sunlight, projection, frustum, frustumLengths, candidates, shadowMeshes);
 }