leaflet-city-mapper 0.0.3 → 0.0.4

package/src/raster/pumpRasterTiles.js

@@ -1,4 +1,8 @@
-import { TILE_SIZE } from "../constants/TILE_SIZE.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';
 
@@ -6,17 +10,17 @@ export function pumpRasterTiles(backend) {
   const map = backend._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 sceneByLayer.get(backend)._rasterTiles.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;
+    if (sceneByLayer.get(backend)._loadingTiles >= 4) break;
     loadRasterTile(backend, 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,16 @@
+import { sceneByLayer } from '../globals/sceneByLayer.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;
+  sceneByLayer.get(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;
 }

package/src/raster/registerTerrainTile.js

@@ -1,12 +1,15 @@
+import { sceneByLayer } from '../globals/sceneByLayer.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(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) {
+    try {
+      await addRasterTile(sceneByLayer.get(backend)._terrain3D, backend, coords, tile);
+    } catch (error) {
+      backend.fire('tileerror', /* alloc */ { tile, coords, error });
+    }
+  }
 }

package/src/raster/releaseRasterTile.js

@@ -1,18 +1,21 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { destroyTexture } from '../rendering/destroyTexture.js';
 import { removeRasterTile } from './removeRasterTile.js';
 import { setParent } from '../scene/setParent.js';
 import { update } from '../scene/update.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(backend, 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;
+  tile.request.abort();
+  if(sceneByLayer.get(backend)._terrain3D) removeRasterTile(sceneByLayer.get(backend)._terrain3D, tile);
+  if (tile.mesh) setParent(tile.mesh, null);
+  if (tile.texture) destroyTexture(backend, tile.texture.texture);
+  tile.image?.close();
+  backend.fire('tileunload', /* alloc */ { tile, coords: tile.coords });
+  update(backend);
 }

package/src/raster/releaseRasterTiles.js

@@ -1,15 +1,18 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { destroyTexture } from '../rendering/destroyTexture.js';
 import { releaseRasterTile } from './releaseRasterTile.js';
 
 export function releaseRasterTiles(backend) {
   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)) {
+  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);
     }
-    backend._rasterGeometry = null;
+    sceneByLayer.get(backend)._rasterGeometry = null;
   }
 }

package/src/raster/removeRasterTile.js

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

package/src/raster/reportError.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,15 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { releaseRasterTile } from './releaseRasterTile.js';
+
+export function retainRasterTiles(backend, required) {
+  const tiles = sceneByLayer.get(backend)._rasterTiles;
+  let key, tile, coords;
+  for ([key, tile] of tiles) {
+    if (!required.has(key) && !tile.done) releaseRasterTile(backend, 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/setRasterOpacity.js

@@ -1,10 +1,13 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { update } from '../scene/update.js';
 
 export function setRasterOpacity(backend, opacity) {
   let tile, terrainMesh;
-  for (tile of backend._rasterTiles.values()) {
+  for (tile of sceneByLayer.get(backend)._rasterTiles.values()) {
     if (tile.mesh) tile.mesh.opacity = opacity;
-    terrainMesh = backend._terrain3D?._rasterTiles.get(tile);
+    terrainMesh = sceneByLayer.get(sceneByLayer.get(backend)._terrain3D)?._rasterTiles.get(tile);
     if (terrainMesh) terrainMesh.opacity = opacity;
   }
   update(backend);

package/src/raster/setRasterTerrain.js

@@ -1,20 +1,24 @@
+import { sceneByLayer } from '../globals/sceneByLayer.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;
+  // Pending sources bind the current terrain when their raster attachment is ready.
+  if (!sceneByLayer.get(backend)._rasterTiles || sceneByLayer.get(backend)._terrain3D === terrain) return;
   let tile;
-  for (tile of backend._rasterTiles.values()) {
-    if(backend._terrain3D) removeRasterTile(backend._terrain3D, tile);
+  for (tile of sceneByLayer.get(backend)._rasterTiles.values()) {
+    if(sceneByLayer.get(backend)._terrain3D) removeRasterTile(sceneByLayer.get(backend)._terrain3D, tile);
     if (tile.mesh) {
       tile.mesh.visible = true;
-      setParent(tile.mesh, backend.root);
+      setParent(tile.mesh, sceneByLayer.get(backend).root);
     }
   }
-  backend._terrain3D = terrain || null;
+  sceneByLayer.get(backend)._terrain3D = terrain || null;
   if (terrain) {
-    for (tile of backend._rasterTiles.values()) {
+    for (tile of sceneByLayer.get(backend)._rasterTiles.values()) {
       if (tile.done) registerTerrainTile(backend, tile.coords, tile);
     }
   }

package/src/raster/setRasterZIndex.js

@@ -1,10 +1,13 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { update } from '../scene/update.js';
 
 export function setRasterZIndex(backend, zIndex) {
   let tile, terrainMesh;
-  for (tile of backend._rasterTiles.values()) {
+  for (tile of sceneByLayer.get(backend)._rasterTiles.values()) {
     if (tile.mesh) tile.mesh.renderOrder = zIndex;
-    terrainMesh = backend._terrain3D?._rasterTiles.get(tile);
+    terrainMesh = sceneByLayer.get(sceneByLayer.get(backend)._terrain3D)?._rasterTiles.get(tile);
     if (terrainMesh) terrainMesh.renderOrder = zIndex;
   }
   update(backend);

package/src/raster/terrainTileGeometry.js

@@ -0,0 +1,16 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+export function terrainTileGeometry(backend, attributes, sizeX, sizeZ) {
+  const scene = sceneByLayer.get(backend), base = scene._terrainOriginElevation;
+  const bottom = Math.min(scene._dem.low, base) - base, top = Math.max(scene._dem.high, base) - base;
+  return /* alloc */ {
+    device: scene.renderer.device,
+    attributes,
+    drawRange: /* alloc */ { start: 0, count: attributes.index.count },
+    // Bounds must cover the DEM-displaced tile, although picking uses the flat grid.
+    bounds: /* alloc */ {
+      min: /* alloc */ [0, bottom, 0], max: /* alloc */ [1, top, 1], center: /* alloc */ [0.5, (bottom + top) / 2, 0.5],
+      radius: Math.hypot(sizeX, top - bottom, sizeZ) / 2 / Math.max(sizeX, 1, sizeZ),
+    },
+  };
+}

package/src/raster/updateAttachedTiles.js

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

package/src/raster/updateRasterTiles.js

@@ -1,59 +1,51 @@
-import { TILE_RADIUS } from '../constants/TILE_RADIUS.js';
+import { sceneByLayer } from '../globals/sceneByLayer.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;
+  if (!map || !sceneByLayer.get(backend)._shared || !sceneByLayer.get(backend).header) return;
 
-  const zoom = Math.max(backend.header.minZoom ?? 0, Math.min(
+  const zoom = Math.max(sceneByLayer.get(backend).header.minZoom ?? 0, Math.min(
     Math.round(map.getZoom()),
     backend.options.maxZoom,
     backend.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 });
+  sceneByLayer.get(backend)._tileZoom = zoom;
+  const range = rasterTileRange(map, sceneByLayer.get(backend).header, 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);
+  sceneByLayer.get(backend)._wantedRasterTiles = /* 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);
   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 (sceneByLayer.get(backend)._rasterTiles.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);
-  }
+  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);
 }

package/src/rendering/bindMeshTextures.js

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

package/src/rendering/collectFrameMeshes.js

@@ -1,15 +1,22 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { updateWorldMatrix } from "../scene/updateWorldMatrix.js";
 import { collectMeshes } from './collectMeshes.js';
 
 export function collectFrameMeshes(backend, sunlight, sceneChanged) {
-  const camera = backend.camera;
+  const camera = sceneByLayer.get(backend).camera;
   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 = sceneByLayer.get(backend).renderer;
+  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 +29,10 @@ export function collectFrameMeshes(backend, sunlight, sceneChanged) {
     }
     frustumLengths[i] = Math.hypot(plane[0], plane[1], plane[2]);
   }
-  const candidates = backend._visibleMeshes ||= [];
+  const candidates = sceneByLayer.get(backend)._visibleMeshes ||= /* alloc */ [];
   candidates.length = 0;
-  const shadowMeshes = backend._shadowMeshes ||= [];
+  const shadowMeshes = sceneByLayer.get(backend)._shadowMeshes ||= /* alloc */ [];
   shadowMeshes.length = 0;
-  if (sceneChanged) updateWorldMatrix(backend.scene);
-  collectMeshes(backend.scene, sunlight, projection, frustum, frustumLengths, candidates, shadowMeshes);
+  if (sceneChanged) updateWorldMatrix(sceneByLayer.get(backend).scene);
+  collectMeshes(sceneByLayer.get(backend).scene, 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) {

package/src/rendering/collectRoofTiles.js

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

package/src/rendering/collectVisibleMesh.js

@@ -0,0 +1,27 @@
+import { computeBounds } from '../geometry/computeBounds.js';
+
+export function collectVisibleMesh(mesh, projection, frustum, frustumLengths, candidates) {
+  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);
+}

package/src/rendering/compareMeshDepth.js

@@ -0,0 +1,6 @@
+export function compareMeshDepth(a, b) {
+  return a.program.transparent
+    ? (a.renderOrder || 0) - (b.renderOrder || 0) ||
+      b._sortDepth - a._sortDepth || a.id - b.id
+    : (a._sortDepth ?? 0) - (b._sortDepth ?? 0) || a.id - b.id;
+}

package/src/rendering/compareMeshes.js

@@ -1,10 +1,8 @@
-export function compareMeshes(a, b) {
-  return Number(Boolean(b.ground)) - Number(Boolean(a.ground)) ||
-    (a.ground && b.ground ? (a.renderOrder || 0) - (b.renderOrder || 0) ||
-      a.tile.coords.z - b.tile.coords.z : 0) ||
-    Number(a.program.transparent) - Number(b.program.transparent) ||
-    (a.program.transparent
-      ? (a.renderOrder || 0) - (b.renderOrder || 0) ||
-      b._sortDepth - a._sortDepth || a.id - b.id
-      : (a._sortDepth ?? 0) - (b._sortDepth ?? 0) || a.id - b.id);
-}
+export function compareMeshes(a, b) {
+  return Number(Boolean(b.ground)) - Number(Boolean(a.ground)) ||
+    (a.ground && b.ground ? (a.renderOrder || 0) - (b.renderOrder || 0) ||
+      a.tile.coords.z - b.tile.coords.z : 0) ||
+    Number(a.program.transparent) - Number(b.program.transparent) ||
+    compareMeshDepth(a, b);
+}
+import { compareMeshDepth } from './compareMeshDepth.js';

package/src/rendering/compareRoofTiles.js

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