leaflet-city-mapper 0.0.4 → 0.0.5

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);
 }

package/src/rendering/collectVisibleMesh.js

@@ -4,18 +4,27 @@ export function collectVisibleMesh(mesh, projection, frustum, frustumLengths, ca
   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];
+  let sphere = mesh._cullingSphere;
+  if (!sphere || sphere.bounds !== bounds || sphere.matrix !== world ||
+      sphere.version !== mesh._worldMatrixVersion || mesh._worldMatrixVersion === undefined) {
+    sphere ||= mesh._cullingSphere = /* alloc */ {};
+    const center = bounds.center;
+    sphere.x = world[0] * center[0] + world[4] * center[1] + world[8] * center[2] + world[12];
+    sphere.y = world[1] * center[0] + world[5] * center[1] + world[9] * center[2] + world[13];
+    sphere.z = world[2] * center[0] + world[6] * center[1] + world[10] * center[2] + world[14];
+    sphere.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])
+    );
+    sphere.bounds = bounds;
+    sphere.matrix = world;
+    sphere.version = mesh._worldMatrixVersion;
+  }
+  const { x, y, z, radius } = sphere;
   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] &&

package/src/rendering/createMesh.js

@@ -1,14 +1,16 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
 import { defaultMaterial } from '../globals/defaultMaterial.js';
 import { meshBuffer } from '../globals/meshBuffer.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { nextId } from '../globals/nextId.js';
 
 
 
-import { emptyNode } from '../scene/emptyNode.js';
-import { createProgram } from './createProgram.js';
+import { emptyNode } from '../scene/createSceneNode.js';
+import { createProgram } from '../materials/createProgram.js';
 import { setParent } from '../scene/setParent.js';
-import { update } from '../scene/update.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
 
 /**
  * Add a non-indexed, vertex-coloured mesh from flat vec3 arrays `{ position, normal, color }` in layer-local metres.
@@ -16,8 +18,8 @@ import { update } from '../scene/update.js';
  * A supplied `program` shares compiled shaders and pipelines across compatible meshes.
  */
 
-export function createMesh(backend, data, material = defaultMaterial, usage = 0, program) {
-  const { device } = sceneByLayer.get(backend).renderer, attributes = /* alloc */ {};
+export function createMesh(layer, data, material = defaultMaterial, usage = 0, program) {
+  const { device } = rendererByLayer.get(layer), attributes = /* alloc */ {};
   let name, values, array, size, buffer;
   for ([name, values] of Object.entries(data)) {
     array = /* alloc */ new Float32Array(values);
@@ -35,10 +37,10 @@ export function createMesh(backend, data, material = defaultMaterial, usage = 0,
     ...emptyNode(),
     device,
     geometry: /* alloc */ { device, attributes, drawRange: /* alloc */ { start: 0, count: attributes.position.count } },
-    program: program || createProgram(backend, /* alloc */ { vertexColors: true, doubleSided: true, ...material }),
+    program: program || createProgram(layer, /* alloc */ { vertexColors: true, doubleSided: true, ...material }),
     id: nextId.value++, renderOrder: 0, extras: /* alloc */ {},
   };
-  setParent(mesh, sceneByLayer.get(backend).root);
-  update(backend);
+  setParent(mesh, rootByLayer.get(layer));
+  update(layer);
   return mesh;
 }

package/src/rendering/disposeMesh.js

@@ -1,12 +1,12 @@
 import { setParent } from '../scene/setParent.js';
-import { update } from '../scene/update.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
 
-export function disposeMesh(backend, mesh) {
+export function disposeMesh(layer, mesh) {
   if (!mesh) {
     return;
   }
   setParent(mesh, null);
-  update(backend);
+  update(layer);
   let attribute;
   for (attribute of Object.values(mesh.geometry.attributes)) {
     attribute.buffer.destroy();

package/src/rendering/drawGeometry.js

@@ -1,13 +1,14 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
 import { meshOffsets } from '../globals/meshOffsets.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { drawPipeline } from './drawPipeline.js';
 import { prepareMeshUniforms } from './prepareMeshUniforms.js';
-import { prepareMeshTextures } from './prepareMeshTextures.js';
+import { prepareMeshTextures } from '../textures/prepareMeshTextures.js';
 
 /** Upload retained CPU data and draw one mesh in the active WebGPU render pass. */
-export function drawGeometry(backend, mesh, pass, cullMode, frontFace) {
+export function drawGeometry(layer, mesh, pass, cullMode, frontFace) {
   const { geometry } = mesh;
-  const renderer = sceneByLayer.get(backend).renderer;
+  const renderer = rendererByLayer.get(layer);
   const { device } = renderer;
   const pipeline = drawPipeline(renderer, mesh, cullMode, frontFace);
   const offset = prepareMeshUniforms(renderer, mesh);
@@ -24,12 +25,13 @@ export function drawGeometry(backend, mesh, pass, cullMode, frontFace) {
   if (geometry.attributes.uv) pass.setVertexBuffer(3, geometry.attributes.uv.buffer);
   const instances = geometry.attributes.instanceOffset;
   if (instances) pass.setVertexBuffer(4, instances.buffer);
-  let attribute;
-  for (attribute of Object.values(geometry.attributes)) {
+  let name, attribute;
+  for (name in geometry.attributes) {
+    attribute = geometry.attributes[name];
     if (!attribute.needsUpdate) continue;
     device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
     attribute.needsUpdate = false;
-    geometry.bounds = null;
+    if (name === 'position' || name === 'instanceOffset') geometry.bounds = null;
   }
   const index = geometry.attributes.index;
   if (index) {