leaflet-city-mapper 0.0.4 → 0.0.5

package/src/picking/setHighlight.js

@@ -1,20 +1,21 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { highlightedFeatureByLayer } from '../weakmaps/highlightedFeatureByLayer.js';
 
 
-import { update } from '../scene/update.js';
+
+import { update } from '../scene/scheduleSceneUpdate.js';
 
 /** Highlight a source vertex range in the shader; vertex colors stay untouched. */
 
-export function setHighlight(backend, feature) {
+export function setHighlight(layer, feature) {
   if (feature?.model) feature = null;
-  if (sceneByLayer.get(backend).highlightedFeature?.mesh === feature?.mesh &&
-    sceneByLayer.get(backend).highlightedFeature?.vertexStart === feature?.vertexStart) return;
-  if (sceneByLayer.get(backend).highlightedFeature) sceneByLayer.get(backend).highlightedFeature.mesh.highlight = null;
-  sceneByLayer.get(backend).highlightedFeature = feature;
+  if (highlightedFeatureByLayer.get(layer)?.mesh === feature?.mesh &&
+    highlightedFeatureByLayer.get(layer)?.vertexStart === feature?.vertexStart) return;
+  if (highlightedFeatureByLayer.get(layer)) highlightedFeatureByLayer.get(layer).mesh.highlight = null;
+  highlightedFeatureByLayer.set(layer, feature);
   if (feature) {
     feature.mesh.highlightRange[0] = feature.vertexStart;
     feature.mesh.highlightRange[1] = feature.vertexEnd;
     feature.mesh.highlight = feature.mesh.highlightRange;
   }
-  update(backend);
+  update(layer);
 }

package/src/picking/shouldSkipOther.js

@@ -1,6 +1,7 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { typeByLayer } from '../weakmaps/typeByLayer.js';
+
 
 
 export function shouldSkipOther(other, layer) {
-  return other === layer || sceneByLayer.get(other)._type === 'terrain' || sceneByLayer.get(other)._type === 'traffic';
+  return other === layer || typeByLayer.get(other) === 'terrain' || typeByLayer.get(other) === 'traffic';
 }

package/src/picking/showFeature.js

@@ -1,37 +1,42 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { containerByLayer } from '../weakmaps/containerByLayer.js';
+import { cursorByLayer } from '../weakmaps/cursorByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+import { tooltipByLayer } from '../weakmaps/tooltipByLayer.js';
+
 
 
 /** Update tooltip content/position and arbitrate cursor ownership across shared layers. */
 
-export function showFeature(backend, feature, event) {
-  const tooltip = sceneByLayer.get(backend)._tooltip;
+export function showFeature(layer, feature, event) {
+  const tooltip = tooltipByLayer.get(layer);
   if (!tooltip) return;
   if (feature) {
-    tooltip.replaceChildren(backend.options.tooltip(feature));
+    tooltip.replaceChildren(layer.options.tooltip(feature));
     tooltip.hidden = false;
-    const rect = sceneByLayer.get(backend).container.getBoundingClientRect();
+    const rect = containerByLayer.get(layer).getBoundingClientRect();
     const x = event.clientX - rect.left, y = event.clientY - rect.top;
     tooltip.style.left = `${x + tooltip.offsetWidth + 16 > rect.width ? x - tooltip.offsetWidth - 12 : x + 12}px`;
     tooltip.style.top = `${y + tooltip.offsetHeight + 16 > rect.height ? y - tooltip.offsetHeight - 12 : y + 12}px`;
   } else {
     tooltip.hidden = true;
   }
-  const shared = sceneByLayer.get(backend)._shared;
-  let layer;
+  const shared = sharedByLayer.get(layer);
+  let sharedLayer;
   if (shared) {
     let visible = false;
-    for (layer of sceneByLayer.get(shared)._layers) {
-      if (sceneByLayer.get(layer)._tooltip && !sceneByLayer.get(layer)._tooltip.hidden) {
+    for (sharedLayer of layersByLayer.get(shared)) {
+      if (tooltipByLayer.get(sharedLayer) && !tooltipByLayer.get(sharedLayer).hidden) {
         visible = true;
         break;
       }
     }
     if (visible) {
-      if (sceneByLayer.get(shared)._cursor === undefined) sceneByLayer.get(shared)._cursor = sceneByLayer.get(backend).container.style.cursor;
-      sceneByLayer.get(backend).container.style.cursor = 'pointer';
-    } else if (sceneByLayer.get(shared)._cursor !== undefined) {
-      sceneByLayer.get(backend).container.style.cursor = sceneByLayer.get(shared)._cursor;
-      delete sceneByLayer.get(shared)._cursor;
+      if (cursorByLayer.get(shared) === undefined) cursorByLayer.set(shared, containerByLayer.get(layer).style.cursor);
+      containerByLayer.get(layer).style.cursor = 'pointer';
+    } else if (cursorByLayer.get(shared) !== undefined) {
+      containerByLayer.get(layer).style.cursor = cursorByLayer.get(shared);
+      cursorByLayer.delete(shared);
     }
   }
 }

package/src/{camera/angles.js → projections/cameraAngles.js}

@@ -1,7 +1,7 @@
 import { radians } from '../globals/radians.js';
 
-import { mapGetBearing } from './mapGetBearing.js';
-import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
 
 export function angles(map, target) {
   const bearing = mapGetBearing(map) * radians, pitch = mapGetPitch(map) * radians;

package/src/{camera → projections}/groundBounds.js

@@ -1,7 +1,7 @@
 import { L } from '../globals/L.js';
 import { cameraZeroPadding } from '../globals/cameraZeroPadding.js';
-import { pointOf } from './pointOf.js';
-import { project } from './project.js';
+import { pointOf } from './toPoint.js';
+import { project } from './projectCameraPoint.js';
 
 
 export function groundBounds(map, padding = cameraZeroPadding) {

package/src/projections/localPosition.js

@@ -0,0 +1,11 @@
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+
+import { radians } from '../globals/radians.js';
+
+
+export function localPosition(state, latlng) {
+  const { map, backend: layer } = state, crs = map.options.crs;
+  const origin = crs.project(locationByLayer.get(layer)), point = crs.project(latlng);
+  const metres = Math.cos(locationByLayer.get(layer).lat * radians);
+  return /* alloc */ [(point.x - origin.x) * metres, 0, -(point.y - origin.y) * metres];
+}

package/src/{camera/project.js → projections/projectCameraPoint.js}

@@ -1,6 +1,6 @@
 import { cameraAngles } from '../globals/cameraAngles.js';
-import { pointOf } from './pointOf.js';
-import { angles } from './angles.js';
+import { pointOf } from './toPoint.js';
+import { angles } from './cameraAngles.js';
 
 
 export function project(map, point, inverse = false, limit = false) {

package/src/{sources → projections}/projectRing.js

@@ -1,26 +1,25 @@
-import { L } from '../globals/L.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
 
-import { getElevation } from '../terrain/getElevation.js';
+import { L } from '../globals/L.js';
+import { mapElevationOf } from '../terrain/mapElevationOf.js';
 
 export function projectRing(context, ring) {
-  const { backend, crs, origin, metres, map } = context;
+  const { backend: layer, crs, origin, metres, map } = context;
   if (ring.length < 4) throw /* alloc */ new Error('Invalid GeoJSON polygon ring');
   const path = /* alloc */ [];
+  const root = rootByLayer.get(layer);
   let i, lng, lat, location, point, elevation;
   for (i = 0; i < ring.length - 1; i++) {
     lng = ring[i][0], lat = ring[i][1];
     if (!Number.isFinite(lng) || !Number.isFinite(lat)) throw /* alloc */ new Error('Invalid GeoJSON coordinates');
     location = /* alloc */ new L.LatLng(lat, lng);
     point = crs.project(location);
-    elevation = cameraByMap.get(map)._terrain3D ? getElevation(cameraByMap.get(map)._terrain3D, location) : undefined;
+    elevation = mapElevationOf(map, location);
     path.push(/* alloc */ {
       x: (point.x - origin.x) * metres,
       y: (point.y - origin.y) * metres,
-      ground: Number.isFinite(elevation) && Number.isFinite(sceneByLayer.get(backend).root.position[1])
-        ? elevation - sceneByLayer.get(backend).root.position[1] : 0,
+      ground: Number.isFinite(elevation) && Number.isFinite(root.position[1])
+        ? elevation - root.position[1] : 0,
     });
   }
   return path;

package/src/projections/projectTreePoint.js

@@ -0,0 +1,17 @@
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
+import { L } from '../globals/L.js';
+import { mapElevationOf } from '../terrain/mapElevationOf.js';
+
+export function projectedTree(context, lon, lat) {
+  const { backend: layer, crs, origin, metres, map } = context;
+  const location = /* alloc */ new L.LatLng(lat, lon);
+  const point = crs.project(location);
+  const elevation = mapElevationOf(map, location), root = rootByLayer.get(layer);
+  return /* alloc */ {
+    x: (point.x - origin.x) * metres,
+    y: (point.y - origin.y) * metres,
+    ground: Number.isFinite(elevation) && Number.isFinite(root.position[1])
+      ? elevation - root.position[1] : 0,
+  };
+}

package/src/{camera/animationPoint.js → projections/transformZoomAnimationPoint.js}

@@ -1,8 +1,9 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+
 
 
 export function animationPoint(map, point, inverse = false) {
-  const view = cameraByMap.get(map)._cameraView;
+  const view = cameraViewByMap.get(map);
   if (!view) return point;
   const half = map.getSize().divideBy(2), scale = map.getZoomScale(view.zoom);
   const shift = map.project(map.getCenter(), view.zoom).subtract(map.project(view.center, view.zoom));

package/src/projections/walkerLocalPosition.js

@@ -0,0 +1,18 @@
+
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { radians } from '../globals/radians.js';
+import { mapElevationOf } from '../terrain/mapElevationOf.js';
+
+export function local(output) {
+  const { layer, state } = this;
+  const map = layer._map, crs = map.options.crs
+  const location = locationByLayer.get(layer), root = rootByLayer.get(layer);
+  const origin = crs.project(location), metres = Math.cos(location.lat * radians);
+  const p = crs.project(state.latlng);
+  const ground = mapElevationOf(map, state.latlng) || 0;
+  output[0] = (p.x - origin.x) * metres;
+  output[1] = ground + (state.height ?? 0) - root.position[1];
+  output[2] = -(p.y - origin.y) * metres;
+  return output;
+}

package/src/raster/addRasterTile.js

@@ -1,40 +1,50 @@
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
+import { terrainBoundsByLayer } from '../weakmaps/terrainBoundsByLayer.js';
+import { terrainOriginElevationByLayer } from '../weakmaps/terrainOriginElevationByLayer.js';
+import { terrainPromiseByLayer } from '../weakmaps/terrainPromiseByLayer.js';
+import { terrainZoomByLayer } from '../weakmaps/terrainZoomByLayer.js';
+import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+
+
 import { radians } from '../globals/radians.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
 import { rasterPoint } from '../globals/rasterPoint.js';
 import { nextId } from '../globals/nextId.js';
-import { rasterProgram } from '../terrain/rasterProgram.js';
-import { terrainBuffers } from '../terrain/terrainBuffers.js';
+import { rasterProgram } from '../materials/terrainRasterProgram.js';
+import { terrainBuffers } from '../geometry/terrainBuffers.js';
 import { setParent } from '../scene/setParent.js';
-import { update } from '../scene/update.js';
-import { terrainTileGeometry } from './terrainTileGeometry.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
+import { terrainTileGeometry } from '../geometry/terrainTileGeometry.js';
 
-export async function addRasterTile(backend, layer, coords, tile) {
-  const ready = await sceneByLayer.get(backend)._terrainPromise;
-  if (!ready || !backend._map || cameraByMap.get(backend._map)._terrain3D !== backend || sceneByLayer.get(layer)._terrain3D !== backend ||
-    tile.request.signal.aborted || !sceneByLayer.get(layer)._rasterTiles.has(`${coords.z}/${coords.x}/${coords.y}`) ||
-    sceneByLayer.get(backend)._rasterTiles.has(tile)) {
+export async function addRasterTile(layer, rasterLayer, coords, tile) {
+  const ready = await terrainPromiseByLayer.get(layer);
+  if (!ready || !layer._map || terrain3DByMap.get(layer._map) !== layer || terrain3DByLayer.get(rasterLayer) !== layer ||
+    tile.request.signal.aborted || !rasterTilesByLayer.get(rasterLayer).has(`${coords.z}/${coords.x}/${coords.y}`) ||
+    rasterTilesByLayer.get(layer).has(tile)) {
     return;
   }
   // Match DEM pixel spacing, capped at 64 subdivisions per tile.
-  const divisions = Math.max(1, Math.min(64, 256 / 2 ** (coords.z - sceneByLayer.get(backend)._terrainZoom)));
-  const map = backend._map, crs = map.options.crs;
-  const origin = crs.project(sceneByLayer.get(backend).location), metres = Math.cos(sceneByLayer.get(backend).location.lat * radians);
+  const divisions = Math.max(1, Math.min(64, 256 / 2 ** (coords.z - terrainZoomByLayer.get(layer))));
+  const map = layer._map, crs = map.options.crs;
+  const origin = crs.project(locationByLayer.get(layer)), metres = Math.cos(locationByLayer.get(layer).lat * radians);
   // Tile pixels map linearly to projected metres: one scaled unit grid per tile, elevation in the vertex shader.
-  const scale = crs.scale(coords.z), terrainScale = 2 ** (sceneByLayer.get(backend)._terrainZoom - coords.z);
+  const scale = crs.scale(coords.z), terrainScale = 2 ** (terrainZoomByLayer.get(layer) - coords.z);
   const point = rasterPoint;
   point.x = coords.x * 256; point.y = coords.y * 256;
   const corner = crs.transformation.untransform(point, scale);
   point.x = (coords.x + 1) * 256; point.y = (coords.y + 1) * 256;
   const opposite = crs.transformation.untransform(point, scale);
-  const device = sceneByLayer.get(backend).renderer.device;
+  const device = rendererByLayer.get(layer).device;
   const texture = tile.texture;
-  const program = rasterProgram(backend, texture);
-  const attributes = terrainBuffers(backend, divisions);
-  const base = sceneByLayer.get(backend)._terrainOriginElevation;
+  const program = rasterProgram(layer, texture);
+  const attributes = terrainBuffers(layer, divisions);
+  const base = terrainOriginElevationByLayer.get(layer);
   const sizeX = (opposite.x - corner.x) * metres, sizeZ = -(opposite.y - corner.y) * metres;
   // ponytail: ray picking sees the flat unit grid; read the DEM back if terrain must be pickable.
-  const geometry = terrainTileGeometry(backend, attributes, sizeX, sizeZ);
+  const geometry = terrainTileGeometry(layer, attributes, sizeX, sizeZ);
   const mesh = /* alloc */ {
     position: /* alloc */ [(corner.x - origin.x) * metres, 0, -(corner.y - origin.y) * metres],
     rotation: /* alloc */ [0, 0, 0],
@@ -48,22 +58,22 @@ export async function addRasterTile(backend, layer, coords, tile) {
     texture,
     // DEM pixel of the tile's corner, DEM pixels per tile, and the elevation at the layer origin.
     terrain: /* alloc */ [
-      coords.x * 256 * terrainScale - sceneByLayer.get(backend)._terrainBounds.min.x * 256,
-      coords.y * 256 * terrainScale - sceneByLayer.get(backend)._terrainBounds.min.y * 256,
+      coords.x * 256 * terrainScale - terrainBoundsByLayer.get(layer).min.x * 256,
+      coords.y * 256 * terrainScale - terrainBoundsByLayer.get(layer).min.y * 256,
       256 * terrainScale,
       base,
     ],
     tile,
-    opacity: layer.options.opacity ?? 1,
+    opacity: rasterLayer.options.opacity ?? 1,
     id: nextId.value++,
-    renderOrder: layer.options.zIndex || 0,
+    renderOrder: rasterLayer.options.zIndex || 0,
     fadeDuration: 250,
     fadeStart: tile.loadedAt,
     ground: true,
-    _rasterSource: layer,
+    _rasterSource: rasterLayer,
   };
   tile.mesh.visible = false;
-  setParent(mesh, sceneByLayer.get(backend).root);
-  update(backend);
-  sceneByLayer.get(backend)._rasterTiles.set(tile, mesh);
+  setParent(mesh, rootByLayer.get(layer));
+  update(layer);
+  rasterTilesByLayer.get(layer).set(tile, mesh);
 }

package/src/raster/createRasterMesh.js

@@ -1,7 +1,12 @@
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { rasterGeometryByLayer } from '../weakmaps/rasterGeometryByLayer.js';
+import { rasterProgramByLayer } from '../weakmaps/rasterProgramByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
 import { radians } from '../globals/radians.js';
 import { rasterTexture } from '../globals/rasterTexture.js';
 import { rasterSampler } from '../globals/rasterSampler.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { meshImage } from '../globals/meshImage.js';
 import { meshTarget } from '../globals/meshTarget.js';
 import { meshCopySize } from '../globals/meshCopySize.js';
@@ -11,13 +16,13 @@ import { nextId } from '../globals/nextId.js';
 
 
 
-import { createProgram } from "../rendering/createProgram.js";
+import { createProgram } from "../materials/createProgram.js";
 import { setParent } from "../scene/setParent.js";
 
-import { createGeometry } from './createGeometry.js';
+import { createGeometry } from '../geometry/createRasterQuadGeometry.js';
 
-export function createRasterMesh(backend, tile) {
-  const device = sceneByLayer.get(backend).renderer.device;
+export function createRasterMesh(layer, tile) {
+  const device = rendererByLayer.get(layer).device;
   const texture = /* alloc */ {
     device,
     texture: device.createTexture((
@@ -42,16 +47,16 @@ export function createRasterMesh(backend, tile) {
   destination.texture = null;
   texture.uploaded = tile.image;
 
-  if (!sceneByLayer.get(backend)._rasterProgram) {
-    sceneByLayer.get(backend)._rasterProgram = createProgram(backend, /* alloc */ {
-      baseTexture: texture, unlit: true, alphaMode: 'BLEND', doubleSided: backend.options.doubleSided,
-    });
+  if (!rasterProgramByLayer.get(layer)) {
+    rasterProgramByLayer.set(layer, createProgram(layer, /* alloc */ {
+      baseTexture: texture, unlit: true, alphaMode: 'BLEND', doubleSided: layer.options.doubleSided,
+    }));
   }
-  if (!sceneByLayer.get(backend)._rasterGeometry) sceneByLayer.get(backend)._rasterGeometry = createGeometry(device);
+  if (!rasterGeometryByLayer.get(layer)) rasterGeometryByLayer.set(layer, createGeometry(device));
   const { coords } = tile;
-  const crs = backend._map.options.crs;
-  const origin = crs.project(sceneByLayer.get(backend).location);
-  const metres = Math.cos(sceneByLayer.get(backend).location.lat * radians);
+  const crs = layer._map.options.crs;
+  const origin = crs.project(locationByLayer.get(layer));
+  const metres = Math.cos(locationByLayer.get(layer).lat * radians);
   const scale = crs.scale(coords.z);
   const point = rasterPoint;
   point.x = coords.x * TILE_SIZE; point.y = coords.y * TILE_SIZE;
@@ -66,11 +71,11 @@ export function createRasterMesh(backend, tile) {
     rotation: /* alloc */ [0, 0, 0],
     scale: /* alloc */ [sizeX, 1, sizeZ],
     worldMatrix: /* alloc */ [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-    children: /* alloc */ [], visible: true, device, geometry: sceneByLayer.get(backend)._rasterGeometry,
-    program: sceneByLayer.get(backend)._rasterProgram, texture,
-    opacity: backend.options.opacity, id: nextId.value++,
-    renderOrder: backend.options.zIndex || 0, tile, fadeDuration: 250, ground: true,
-    _rasterSource: backend,
+    children: /* alloc */ [], visible: true, device, geometry: rasterGeometryByLayer.get(layer),
+    program: rasterProgramByLayer.get(layer), texture,
+    opacity: layer.options.opacity, id: nextId.value++,
+    renderOrder: layer.options.zIndex || 0, tile, fadeDuration: 250, ground: true,
+    _rasterSource: layer,
   };
-  setParent(tile.mesh, sceneByLayer.get(backend).root);
+  setParent(tile.mesh, rootByLayer.get(layer));
 }

package/src/raster/finishRasterAttachment.js

@@ -0,0 +1,17 @@
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+
+
+
+
+import { setRasterTerrain } from "./setRasterTerrain.js";
+
+export async function finishAttachment(layer, map, attached) {
+  try {
+    await attached;
+    addedByLayer.get(layer).resolve();
+    setRasterTerrain(layer, terrain3DByMap.get(map));
+  } catch (error) {
+    layer.fire('error', /* alloc */ { error });
+  }
+}

package/src/raster/finishRasterTile.js

@@ -1,17 +1,20 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+import { rasterVersionByLayer } from '../weakmaps/rasterVersionByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+
 import { blobParts } from '../globals/blobParts.js';
 
-import { update } from "../scene/update.js";
+import { update } from "../scene/scheduleSceneUpdate.js";
 import { registerTerrainTile } from "./registerTerrainTile.js";
 import { pruneRasterTiles } from "./pruneRasterTiles.js";
 import { pumpRasterTiles } from './pumpRasterTiles.js';
 import { createRasterMesh } from './createRasterMesh.js';
 import { getZxy } from '../archives/getZxy.js';
 
-export async function finishRasterTile(backend, tile) {
+export async function finishRasterTile(layer, tile) {
   try {
-    await sceneByLayer.get(backend).ready;
-    const result = await getZxy(backend.options.archive,
+    await readyByLayer.get(layer);
+    const result = await getZxy(layer.options.archive,
       tile.coords.z, tile.coords.x, tile.coords.y, tile.request.signal
     );
     if (tile.request.signal.aborted) {
@@ -36,26 +39,26 @@ export async function finishRasterTile(backend, tile) {
       tile.image = null;
       return;
     }
-    createRasterMesh(backend, tile);
+    createRasterMesh(layer, tile);
     tile.loadedAt = performance.now();
     tile.done = true;
-    sceneByLayer.get(backend)._rasterVersion = (sceneByLayer.get(backend)._rasterVersion || 0) + 1;
-    registerTerrainTile(backend, tile.coords, tile);
-    backend.fire('tileload', /* alloc */ { tile, coords: tile.coords });
-    update(backend);
+    rasterVersionByLayer.set(layer, (rasterVersionByLayer.get(layer) || 0) + 1);
+    registerTerrainTile(layer, tile.coords, tile);
+    layer.fire('tileload', /* alloc */ { tile, coords: tile.coords });
+    update(layer);
   } catch (error) {
     if (tile.request.signal.aborted) return;
     tile.error = error.message;
-    sceneByLayer.get(backend)._rasterVersion = (sceneByLayer.get(backend)._rasterVersion || 0) + 1;
-    backend.fire('tileerror', /* alloc */ { tile, coords: tile.coords, error });
-    backend.fire('error', /* alloc */ { error, coords: tile.coords });
+    rasterVersionByLayer.set(layer, (rasterVersionByLayer.get(layer) || 0) + 1);
+    layer.fire('tileerror', /* alloc */ { tile, coords: tile.coords, error });
+    layer.fire('error', /* alloc */ { error, coords: tile.coords });
   } finally {
-    sceneByLayer.get(backend)._loadingTiles--;
-    if (backend._map) {
-      pumpRasterTiles(backend);
-      pruneRasterTiles(backend);
-      if (!sceneByLayer.get(backend)._loadingTiles) backend.fire('load');
-      update(backend);
+    loadingTilesByLayer.set(layer, loadingTilesByLayer.get(layer) - 1);
+    if (layer._map) {
+      pumpRasterTiles(layer);
+      pruneRasterTiles(layer);
+      if (!loadingTilesByLayer.get(layer)) layer.fire('load');
+      update(layer);
     }
   }
 }

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