leaflet-city-mapper 0.0.4 → 0.0.6

package/src/picking/onPointerMove.js

@@ -1,18 +1,24 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { hoveredFeatureByLayer } from '../weakmaps/hoveredFeatureByLayer.js';
+
 
 
 import { findFeature } from './findFeature.js';
 import { setHighlight } from './setHighlight.js';
 import { showFeature } from './showFeature.js';
+import { onPointerLeave } from './onPointerLeave.js';
 
-/** Hover is transient; featurehover also reports misses with feature:null. */
+/** Gestures clear hover once without raycasting; normal misses report feature:null. */
 
 export function onPointerMove(layer, event) {
-  sceneByLayer.get(layer).hoveredFeature = findFeature(layer, event);
-  setHighlight(layer, sceneByLayer.get(layer).hoveredFeature);
-  showFeature(layer, sceneByLayer.get(layer).hoveredFeature, event);
+  if (event.buttons || layer._map.dragging?.moving() || layer._map._animatingZoom) {
+    if (hoveredFeatureByLayer.get(layer)) onPointerLeave(layer);
+    return;
+  }
+  hoveredFeatureByLayer.set(layer, findFeature(layer, event));
+  setHighlight(layer, hoveredFeatureByLayer.get(layer));
+  showFeature(layer, hoveredFeatureByLayer.get(layer), event);
   layer.fire('featurehover', /* alloc */ {
-    feature: sceneByLayer.get(layer).hoveredFeature,
+    feature: hoveredFeatureByLayer.get(layer),
     originalEvent: event
   });
 }

package/src/picking/raycast.js

@@ -1,11 +1,16 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { trafficByLayer } from '../globals/trafficByLayer.js';
+import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
+import { raycasterByLayer } from '../weakmaps/raycasterByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
+
+import { trafficByLayer } from '../weakmaps/trafficByLayer.js';
 
 
 import { intersectMeshes } from '../collision/intersectMeshes.js';
 import { traverse } from '../scene/traverse.js';
-import { updateCamera } from '../scene/updateCamera.js';
-import { updateWorldMatrix } from '../scene/updateWorldMatrix.js';
+import { updateCamera } from '../camera/updateSceneCamera.js';
+import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
 import { collectVisibleMesh } from './collectVisibleMesh.js';
 import { placeTraffic } from '../traffic/placeTraffic.js';
 import { validateCameraInverse } from './validateCameraInverse.js';
@@ -20,18 +25,18 @@ import { validateCameraInverse } from './validateCameraInverse.js';
  * @returns {Object[]} Nearest hit per mesh: object, shared-world point/distance and triangle faceIndex.
  */
 
-export function raycast(backend, event, objects = sceneByLayer.get(backend).root.children, recursive = true) {
-  if (!sceneByLayer.get(backend).renderer) {
+export function raycast(layer, event, objects = rootByLayer.get(layer).children, recursive = true) {
+  if (!rendererByLayer.get(layer)) {
     return /* alloc */ [];
   }
-  const traffic = trafficByLayer.get(backend);
+  const traffic = trafficByLayer.get(layer);
   if (traffic) placeTraffic(traffic);
-  const rect = backend._map.getContainer().getBoundingClientRect();
-  updateWorldMatrix(sceneByLayer.get(backend).scene);
-  updateCamera(sceneByLayer.get(backend).camera);
+  const rect = layer._map.getContainer().getBoundingClientRect();
+  updateWorldMatrix(sceneByLayer.get(layer));
+  updateCamera(cameraByLayer.get(layer));
   // Unproject the mouse (-1..1) into a world-space ray from the camera.
-  const inverseCamera = sceneByLayer.get(backend).raycaster.inverse;
-  const matrix = sceneByLayer.get(backend).camera.projectionViewMatrix;
+  const inverseCamera = raycasterByLayer.get(layer).inverse;
+  const matrix = cameraByLayer.get(layer).projectionViewMatrix;
   inverseCamera.m11 = matrix[0], inverseCamera.m12 = matrix[1], inverseCamera.m13 = matrix[2], inverseCamera.m14 = matrix[3];
   inverseCamera.m21 = matrix[4], inverseCamera.m22 = matrix[5], inverseCamera.m23 = matrix[6], inverseCamera.m24 = matrix[7];
   inverseCamera.m31 = matrix[8], inverseCamera.m32 = matrix[9], inverseCamera.m33 = matrix[10], inverseCamera.m34 = matrix[11];
@@ -45,22 +50,22 @@ export function raycast(backend, event, objects = sceneByLayer.get(backend).root
   const endW = inverseCamera.m14 * x + inverseCamera.m24 * y + inverseCamera.m44;
   let object;
   validateCameraInverse(inverseCamera);
-  sceneByLayer.get(backend).raycaster.origin[0] = sceneByLayer.get(backend).camera.position[0];
-  sceneByLayer.get(backend).raycaster.origin[1] = sceneByLayer.get(backend).camera.position[1];
-  sceneByLayer.get(backend).raycaster.origin[2] = sceneByLayer.get(backend).camera.position[2];
-  sceneByLayer.get(backend).raycaster.direction[0] = endX / endW - sceneByLayer.get(backend).raycaster.origin[0];
-  sceneByLayer.get(backend).raycaster.direction[1] = endY / endW - sceneByLayer.get(backend).raycaster.origin[1];
-  sceneByLayer.get(backend).raycaster.direction[2] = endZ / endW - sceneByLayer.get(backend).raycaster.origin[2];
-  const direction = sceneByLayer.get(backend).raycaster.direction;
+  raycasterByLayer.get(layer).origin[0] = cameraByLayer.get(layer).position[0];
+  raycasterByLayer.get(layer).origin[1] = cameraByLayer.get(layer).position[1];
+  raycasterByLayer.get(layer).origin[2] = cameraByLayer.get(layer).position[2];
+  raycasterByLayer.get(layer).direction[0] = endX / endW - raycasterByLayer.get(layer).origin[0];
+  raycasterByLayer.get(layer).direction[1] = endY / endW - raycasterByLayer.get(layer).origin[1];
+  raycasterByLayer.get(layer).direction[2] = endZ / endW - raycasterByLayer.get(layer).origin[2];
+  const direction = raycasterByLayer.get(layer).direction;
   const rayLength = Math.hypot(direction[0], direction[1], direction[2]) || 1;
-  sceneByLayer.get(backend).raycaster.direction[0] /= rayLength;
-  sceneByLayer.get(backend).raycaster.direction[1] /= rayLength;
-  sceneByLayer.get(backend).raycaster.direction[2] /= rayLength;
-  const meshes = sceneByLayer.get(backend).raycaster.meshes;
+  raycasterByLayer.get(layer).direction[0] /= rayLength;
+  raycasterByLayer.get(layer).direction[1] /= rayLength;
+  raycasterByLayer.get(layer).direction[2] /= rayLength;
+  const meshes = raycasterByLayer.get(layer).meshes;
   meshes.length = 0;
   for (object of objects) {
     if (recursive) traverse(object, collectVisibleMesh, meshes);
     else if (object.geometry && object.visible && object._appearance !== 0) meshes.push(object);
   }
-  return intersectMeshes(sceneByLayer.get(backend).raycaster, meshes, sceneByLayer.get(backend).renderer.uniformData?.[55]);
+  return intersectMeshes(raycasterByLayer.get(layer), meshes, rendererByLayer.get(layer).uniformData?.[55]);
 }

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