leaflet-city-mapper 0.0.4 → 0.0.5

package/src/{core → native}/nativeLayer.js

@@ -1,63 +1,43 @@
+import { nativeGPUBackByMap } from '../weakmaps/nativeGPUBackByMap.js';
+import { nativeGPUOrderByMap } from '../weakmaps/nativeGPUOrderByMap.js';
+
 import { L } from '../globals/L.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
 import { nativeMethodHandlers } from '../globals/nativeMethodHandlers.js';
-import { nativeRenderByLayer } from '../globals/nativeRenderByLayer.js';
+import { nativeRenderByLayer } from '../weakmaps/nativeRenderByLayer.js';
 
 import { createLayer } from '../scene/createLayer.js';
 
 
-import { createMesh } from '../rendering/createMesh.js';
-import { destroyTexture } from '../rendering/destroyTexture.js';
-import { disposeMesh } from '../rendering/disposeMesh.js';
-import { nativeGeometry } from '../geometry/nativeGeometry.js';
 import { nativeEvents } from './nativeEvents.js';
-import { removeNativeEvents } from './removeNativeEvents.js';
-import { parseColor } from '../utils/parseColor.js';
-import { update } from '../scene/update.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
 
-import { current } from './current.js';
+import { current } from './isCurrentNativeLayer.js';
 import { refreshNativeLayer } from './refreshNativeLayer.js';
 import { refreshNativeEvent } from './refreshNativeEvent.js';
-import { reorderNativeLayer } from './reorderNativeLayer.js';
-import { nativeSetLatLng } from './nativeSetLatLng.js';
-import { nativeSetLatLngs } from './nativeSetLatLngs.js';
-import { nativeAddLatLng } from './nativeAddLatLng.js';
-import { nativeSetRadius } from './nativeSetRadius.js';
-import { nativeSetStyle } from './nativeSetStyle.js';
-import { nativeRedraw } from './nativeRedraw.js';
-import { nativeSetIcon } from './nativeSetIcon.js';
-import { nativeSetUrl } from './nativeSetUrl.js';
-import { nativeSetBounds } from './nativeSetBounds.js';
-import { nativeSetOpacity } from './nativeSetOpacity.js';
-import { nativeSetZIndex } from './nativeSetZIndex.js';
-import { nativeSetZIndexOffset } from './nativeSetZIndexOffset.js';
-import { nativeBringToFront } from './nativeBringToFront.js';
-import { nativeBringToBack } from './nativeBringToBack.js';
 import { disposeNativeLayer } from './disposeNativeLayer.js';
 import { resolveNativeReady } from './resolveNativeReady.js';
 import { rejectNativeReady } from './rejectNativeReady.js';
 import { forwardNativeError } from './forwardNativeError.js';
 import { updateNativeLayerView } from './updateNativeLayerView.js';
 import { synchronizeNativeLayer } from './synchronizeNativeLayer.js';
-import { beforeNativeRender } from './beforeNativeRender.js';
 
 /** Render from coordinates and detached raster sources; only accessible marker controls remain DOM. */
 export async function nativeLayer(state) {
   const { source, map } = state;
-  const backend = state.backend = createLayer(/* alloc */ {
+  const layer = state.backend = createLayer(/* alloc */ {
     source: /* alloc */ { type: '3d' },
   });
   state.meshes = /* alloc */ new Map();
   state.textures = /* alloc */ new Map();
   state.methods = /* alloc */ new Map();
-  state.originalMethods = /* alloc */ new Map();
   state.images = /* alloc */ new Set();
-  cameraByMap.get(map)._nativeGPUOrder ||= 0;
-  cameraByMap.get(map)._nativeGPUBack ||= 0;
+  if (!nativeGPUOrderByMap.get(map)) nativeGPUOrderByMap.set(map, 0);
+  if (!nativeGPUBackByMap.get(map)) nativeGPUBackByMap.set(map, 0);
   state.dirty = true;
   state.viewDirty = true;
   state.failed = false;
-  state.order = ++cameraByMap.get(map)._nativeGPUOrder;
+  state.order = nativeGPUOrderByMap.get(map) + 1;
+  nativeGPUOrderByMap.set(map, state.order);
   state.marker = source instanceof L.Marker;
   state.paneOrder = Number(getComputedStyle(source.getPane()).zIndex) || 0;
   state.disposed = false;
@@ -71,15 +51,14 @@ export async function nativeLayer(state) {
     if (typeof source[name] !== 'function') continue;
     own = Object.getOwnPropertyDescriptor(source, name), original = source[name];
     state.methods.set(name, /* alloc */ { own, original });
-    state.originalMethods.set(name, original);
     source[name] = nativeMethodHandlers[name];
   }
   const ready = state.ready = Promise.withResolvers();
-  backend.once('ready', resolveNativeReady, state);
-  backend.once('error', rejectNativeReady, state);
-  backend.on('error', forwardNativeError, state);
+  layer.once('ready', resolveNativeReady, state);
+  layer.once('error', rejectNativeReady, state);
+  layer.on('error', forwardNativeError, state);
   refreshNativeLayer(state);
-  backend.addTo(map);
+  layer.addTo(map);
   try {
     await ready.promise;
   } catch (error) {
@@ -88,7 +67,7 @@ export async function nativeLayer(state) {
   }
   if (!current(state)) return source;
 
-  nativeRenderByLayer.set(backend, state);
+  nativeRenderByLayer.set(layer, state);
   try {
     synchronizeNativeLayer(state);
   } catch (error) {

package/src/{core → native}/nativeLayerMethod.js

@@ -1,12 +1,15 @@
+import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
+import { nativeGPUBackByMap } from '../weakmaps/nativeGPUBackByMap.js';
+import { nativeGPUOrderByMap } from '../weakmaps/nativeGPUOrderByMap.js';
+
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
 
 
 import { refreshNativeLayer } from './refreshNativeLayer.js';
 
 export function nativeLayerMethod(name, source, args) {
-  const state = sceneByLayer.get(source)._nativeGPU, original = state.originalMethods.get(name);
+  const state = nativeGPUByLayer.get(source), original = state.methods.get(name).original;
   const result = original.apply(source, args);
   let layer, zIndex;
   if ((name === 'bringToFront' || name === 'bringToBack') && source instanceof L.GridLayer) {
@@ -19,8 +22,14 @@ export function nativeLayerMethod(name, source, args) {
     const edge = name === 'bringToFront' ? extreme + 1 : extreme - 1;
     if (Number.isFinite(edge)) source.setZIndex(edge);
   }
-  if (name === 'bringToFront') state.order = ++cameraByMap.get(state.map)._nativeGPUOrder;
-  if (name === 'bringToBack') state.order = --cameraByMap.get(state.map)._nativeGPUBack;
+  if (name === 'bringToFront') {
+    state.order = nativeGPUOrderByMap.get(state.map) + 1;
+    nativeGPUOrderByMap.set(state.map, state.order);
+  }
+  if (name === 'bringToBack') {
+    state.order = nativeGPUBackByMap.get(state.map) - 1;
+    nativeGPUBackByMap.set(state.map, state.order);
+  }
   refreshNativeLayer(state);
   return result;
 }

package/src/{core → native}/pruneNativeResources.js

@@ -1,20 +1,20 @@
 import { disposeMesh } from '../rendering/disposeMesh.js';
-import { destroyTexture } from '../rendering/destroyTexture.js';
+import { destroyTexture } from '../textures/destroyTexture.js';
 
 export function pruneNativeResources(state) {
-  const { meshes, textures, backend } = state;
+  const { meshes, textures, backend: layer } = state;
   let mesh, texture, key;
   for ([key, mesh] of meshes) {
     if (mesh._nativeUsed) continue;
-    disposeMesh(backend, mesh);
+    disposeMesh(layer, mesh);
     meshes.delete(key);
     texture = textures.get(key);
-    if (texture) destroyTexture(backend, texture.texture);
+    if (texture) destroyTexture(layer, texture.texture);
     textures.delete(key);
   }
   for ([key, texture] of textures) {
     if (texture.used) continue;
-    destroyTexture(backend, texture.texture);
+    destroyTexture(layer, texture.texture);
     textures.delete(key);
   }
 }

package/src/{core → native}/putNativeMesh.js

@@ -4,7 +4,7 @@ import { createMesh } from '../rendering/createMesh.js';
 import { styleNativeMesh } from './styleNativeMesh.js';
 
 export function putNativeMesh(state, key, position, color, opacity, texture, uv) {
-  const { backend, source, meshes } = state;
+  const { backend: layer, source, meshes } = state;
   if (!position.length) return;
   let mesh = meshes.get(key);
   if (!mesh || mesh.geometry.attributes.position.data.length !== position.length ||
@@ -18,8 +18,8 @@ export function putNativeMesh(state, key, position, color, opacity, texture, uv)
       vertexColors: false, color, opacity, unlit: true, alphaMode: 'BLEND',
     };
     if (texture) material.baseTexture = texture;
-    if (mesh) disposeMesh(backend, mesh);
-    mesh = createMesh(backend, data, material, 0, source instanceof L.GridLayer ? state.rasterProgram : undefined);
+    if (mesh) disposeMesh(layer, mesh);
+    mesh = createMesh(layer, data, material, 0, source instanceof L.GridLayer ? state.rasterProgram : undefined);
     if (source instanceof L.GridLayer) {
       state.rasterProgram ||= mesh.program;
       mesh.texture = texture;

package/src/{core → native}/quadNativeMesh.js

@@ -1,7 +1,7 @@
 import { coreQuadIndices } from '../globals/coreQuadIndices.js';
 import { coreQuadUV } from '../globals/coreQuadUV.js';
 import { coreWhite } from '../globals/coreWhite.js';
-import { textureFor } from './textureFor.js';
+import { textureFor } from '../textures/nativeTextureFor.js';
 import { putNativeMesh } from './putNativeMesh.js';
 
 

package/src/native/readyNativeGPU.js

@@ -0,0 +1,10 @@
+import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
+
+
+
+import { nativeLayer } from './nativeLayer.js';
+
+export function readyNativeGPU(state) {
+  if (nativeGPUByLayer.get(state.source) !== state) return state.source;
+  return nativeLayer(state);
+}

package/src/{core → native}/refreshNativeLayer.js

@@ -1,11 +1,12 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
 
 
-import { nativeImageRefresh } from './nativeImageRefresh.js';
-import { nativeImageError } from './nativeImageError.js';
-import { removeImageState } from './removeImageState.js';
-import { addImageState } from './addImageState.js';
-import { update } from '../scene/update.js';
+
+import { nativeImageRefresh } from '../textures/nativeImageRefresh.js';
+import { nativeImageError } from '../textures/nativeImageError.js';
+import { removeImageState } from '../textures/removeImageState.js';
+import { addImageState } from '../textures/addImageState.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
 import { hideTargets } from './hideTargets.js';
 
 export function refreshNativeLayer(state = this) {
@@ -30,5 +31,5 @@ export function refreshNativeLayer(state = this) {
     image.addEventListener('load', nativeImageRefresh);
     image.addEventListener('error', nativeImageError);
   }
-  if (sceneByLayer.get(state.backend)._shared) update(state.backend);
+  if (sharedByLayer.get(state.backend)) update(state.backend);
 }

package/src/{core → native}/refreshNativeLayerContract.js

@@ -1,8 +1,9 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
+
 
 import { refreshNativeLayer } from './refreshNativeLayer.js';
 
 export function refreshNativeLayerContract(layer = this) {
-  const native = sceneByLayer.get(layer)?._nativeGPU;
+  const native = nativeGPUByLayer.get(layer);
   if (native?.backend && !native.disposed) refreshNativeLayer(native);
 }

package/src/{core → native}/removeNativeEvents.js

@@ -1,4 +1,4 @@
-import { nativeEventMaps } from '../globals/nativeEventMaps.js';
+import { nativeEventMaps } from '../weakmaps/nativeEventMaps.js';
 
 
 export function removeNativeEvents(state) {

package/src/{core → native}/removeTargets.js

@@ -1,9 +1,10 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
+
 
 import { disposeNativeLayer } from './disposeNativeLayer.js';
 
 export function removeTargets(state) {
-  if (sceneByLayer.get(state.source)._nativeGPU === state) sceneByLayer.get(state.source)._nativeGPU = null;
+  if (nativeGPUByLayer.get(state.source) === state) nativeGPUByLayer.set(state.source, null);
   if (state.backend) disposeNativeLayer.call(state);
   let element;
   for (element of state.hidden) {

package/src/native/reorderNativeLayer.js

@@ -0,0 +1,17 @@
+import { nativeGPUBackByMap } from '../weakmaps/nativeGPUBackByMap.js';
+import { nativeGPUOrderByMap } from '../weakmaps/nativeGPUOrderByMap.js';
+
+
+
+import { refreshNativeLayer } from './refreshNativeLayer.js';
+
+export function reorderNativeLayer(front) {
+  if (front) {
+    this.order = nativeGPUOrderByMap.get(this.map) + 1;
+    nativeGPUOrderByMap.set(this.map, this.order);
+  } else {
+    this.order = nativeGPUBackByMap.get(this.map) - 1;
+    nativeGPUBackByMap.set(this.map, this.order);
+  }
+  refreshNativeLayer(this);
+}

package/src/{core → native}/styleNativeMesh.js

@@ -1,5 +1,6 @@
+import { cameraZIndexOffsetByLayer } from '../weakmaps/cameraZIndexOffsetByLayer.js';
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 export function styleNativeMesh(state, mesh, color, opacity) {
@@ -7,7 +8,7 @@ export function styleNativeMesh(state, mesh, color, opacity) {
   mesh.program.uniforms.baseColor.value = color;
   mesh.program.uniforms.opacity.value = opacity;
   if (source instanceof L.GridLayer) mesh.opacity = opacity;
-  const zIndex = marker ? source._zIndex + (sceneByLayer.get(source)._cameraZIndexOffset || 0) : source.options.zIndex;
+  const zIndex = marker ? source._zIndex + (cameraZIndexOffsetByLayer.get(source) || 0) : source.options.zIndex;
   mesh.renderOrder = paneOrder * 1e6 + (zIndex || 0) * 1000 + order;
   mesh._nativeSource = source;
   mesh._nativeUsed = true;

package/src/{core → native}/syncGridLayer.js

@@ -3,7 +3,7 @@ import { coreWhite } from '../globals/coreWhite.js';
 
 import { styleNativeMesh } from './styleNativeMesh.js';
 import { quadNativeMesh } from './quadNativeMesh.js';
-import { boundsQuad } from './boundsQuad.js';
+import { boundsQuad } from '../geometry/boundsQuad.js';
 
 
 export function syncGridLayer(state) {

package/src/{core → native}/syncImageOverlay.js

@@ -1,5 +1,5 @@
 import { quadNativeMesh } from './quadNativeMesh.js';
-import { boundsQuad } from './boundsQuad.js';
+import { boundsQuad } from '../geometry/boundsQuad.js';
 
 export function syncImageOverlay(state) {
   const { source } = state;

package/src/{core → native}/syncMarker.js

@@ -1,5 +1,5 @@
 import { quadNativeMesh } from './quadNativeMesh.js';
-import { markerQuadCorners } from './markerQuadCorners.js';
+import { markerQuadCorners } from '../geometry/markerQuadCorners.js';
 
 export function syncMarker(state) {
   const { source } = state;

package/src/{core → native}/syncVectorLayer.js

@@ -2,8 +2,8 @@ import { geometryPixelStates } from '../globals/geometryPixelStates.js';
 
 
 import { nativeGeometry } from '../geometry/nativeGeometry.js';
-import { localPixelForGeometry } from './localPixelForGeometry.js';
-import { parseColor } from '../utils/parseColor.js';
+import { localPixelForGeometry } from '../projections/localPixelForGeometry.js';
+import { parseColor } from '../colors/parseColor.js';
 import { putNativeMesh } from './putNativeMesh.js';
 
 export function syncVectorLayer(state) {

package/src/{core → native}/synchronizeNativeLayer.js

@@ -1,8 +1,9 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
-import { current } from './current.js';
+import { current } from './isCurrentNativeLayer.js';
 import { syncGridLayer } from './syncGridLayer.js';
 import { syncImageOverlay } from './syncImageOverlay.js';
 import { syncMarker } from './syncMarker.js';
@@ -11,7 +12,7 @@ import { pruneNativeResources } from './pruneNativeResources.js';
 
 export function synchronizeNativeLayer(state) {
   const { source, meshes, textures } = state;
-  if (!current(state) || !sceneByLayer.get(state.backend).renderer || state.failed) return;
+  if (!current(state) || !rendererByLayer.get(state.backend) || state.failed) return;
   if (!state.dirty && (!state.marker || !state.viewDirty)) return;
   state.dirty = false;
   state.viewDirty = false;

package/src/native/updateNativeLayerView.js

@@ -0,0 +1,10 @@
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
+
+
+import { update } from '../scene/scheduleSceneUpdate.js';
+
+export function updateNativeLayerView() {
+  this.viewDirty = true;
+  if (sharedByLayer.get(this.backend)) update(this.backend);
+}

package/src/picking/findFeature.js

@@ -1,4 +1,7 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
+import { modelByLayer } from '../weakmaps/modelByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
 
 
 import { raycast } from './raycast.js';
@@ -9,21 +12,22 @@ import { raycast } from './raycast.js';
  * @returns {PickedFeature|null}
  */
 
-export function findFeature(backend, event) {
-  if (!sceneByLayer.get(backend).root || !sceneByLayer.get(backend).camera) {
+export function findFeature(layer, event) {
+  const model = modelByLayer.get(layer)
+  if (!rootByLayer.get(layer) || !cameraByLayer.get(layer)) {
     return null;
   }
   let hit, object, ranges, low, high, middle, range;
-  for (hit of raycast(backend, event, sceneByLayer.get(backend).root.children, Boolean(sceneByLayer.get(backend).model))) {
-    if (sceneByLayer.get(backend).model) {
+  for (hit of raycast(layer, event, rootByLayer.get(layer).children, Boolean(model))) {
+    if (model) {
       object = hit.object;
-      while (object && object !== sceneByLayer.get(backend).model) {
+      while (object && object !== model) {
         object = object.parent;
       }
-      if (object === sceneByLayer.get(backend).model) {
+      if (object === model) {
         return /* alloc */ {
-          id: sceneByLayer.get(backend).model.id, properties: sceneByLayer.get(backend).model.extras,
-          model: sceneByLayer.get(backend).model, mesh: hit.object, point: hit.point
+          id: model.id, properties: model.extras,
+          model, mesh: hit.object, point: hit.point
         };
       }
     }

package/src/picking/hit.js

@@ -1,24 +1,32 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
 
 
 
 import { traverse } from '../scene/traverse.js';
-import { updateWorldMatrix } from '../scene/updateWorldMatrix.js';
-import { shouldSkipOther } from './shouldSkipOther.js';
+import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
 import { hitMesh } from './hitMesh.js';
+import { trafficCollision } from '../collision/trafficCollision.js';
 
 // Horizontal normal of the nearest wall faced within `reach` metres of the feet at world (x, y, z), walking along
 // the unit (dx, dz); knee and chest rays, so arches and tree crowns above the head let the walker through.
-// ponytail: traffic vehicles and boats move on the GPU and are not obstacles.
 
 export function hit(layer, x, y, z, dx, dz, reach, data) {
-  updateWorldMatrix(sceneByLayer.get(layer).scene);
+  updateWorldMatrix(sceneByLayer.get(layer));
   data.x = x, data.y = y, data.z = z, data.dx = dx, data.dz = dz, data.reach = reach;
   data.best = reach, data.found = false;
   let other;
-  for (other of sceneByLayer.get(sceneByLayer.get(layer)._shared)._layers) {
-    if (shouldSkipOther(other, layer)) continue;
-    traverse(sceneByLayer.get(other).root, hitMesh, data);
+  for (other of layersByLayer.get(sharedByLayer.get(layer))) {
+    if (other === layer || kindByLayer.get(other) === 'terrain') continue;
+    if (kindByLayer.get(other) === 'traffic') {
+      trafficCollision(other, x, y, z, dx, dz, reach, data);
+      continue;
+    }
+    traverse(rootByLayer.get(other), hitMesh, data);
   }
   return data.found ? data.normal : null;
 }

package/src/picking/onClick.js

@@ -1,4 +1,5 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { hoveredFeatureByLayer } from '../weakmaps/hoveredFeatureByLayer.js';
+
 
 
 import { findFeature } from './findFeature.js';
@@ -9,7 +10,7 @@ import { showFeature } from './showFeature.js';
 
 export function onClick(layer, event) {
   const feature = findFeature(layer, event);
-  sceneByLayer.get(layer).hoveredFeature = feature;
+  hoveredFeatureByLayer.set(layer, feature);
   setHighlight(layer, feature);
   showFeature(layer, feature, event);
   layer.fire('featureclick', /* alloc */ { feature, originalEvent: event });

package/src/picking/onPointerLeave.js

@@ -1,4 +1,5 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { hoveredFeatureByLayer } from '../weakmaps/hoveredFeatureByLayer.js';
+
 
 
 import { setHighlight } from './setHighlight.js';
@@ -7,7 +8,7 @@ import { showFeature } from './showFeature.js';
 /** Clear hover, highlight and tooltip without retaining a selected feature. */
 
 export function onPointerLeave(layer) {
-  sceneByLayer.get(layer).hoveredFeature = null;
+  hoveredFeatureByLayer.set(layer, null);
   setHighlight(layer, null);
   showFeature(layer, null);
   layer.fire('featurehover', /* alloc */ { feature: null });

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