leaflet-city-mapper 0.0.4 → 0.0.6

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

@@ -1,20 +1,20 @@
-import { nativeRenderByLayer } from '../globals/nativeRenderByLayer.js';
+import { nativeRenderByLayer } from '../weakmaps/nativeRenderByLayer.js';
 
 
 import { refreshNativeEvent } from './refreshNativeEvent.js';
 import { updateNativeLayerView } from './updateNativeLayerView.js';
 import { removeNativeEvents } from './removeNativeEvents.js';
 import { disposeMesh } from '../rendering/disposeMesh.js';
-import { destroyTexture } from '../rendering/destroyTexture.js';
-import { nativeImageRefresh } from './nativeImageRefresh.js';
-import { nativeImageError } from './nativeImageError.js';
-import { removeImageState } from './removeImageState.js';
+import { destroyTexture } from '../textures/destroyTexture.js';
+import { nativeImageRefresh } from '../textures/nativeImageRefresh.js';
+import { nativeImageError } from '../textures/nativeImageError.js';
+import { removeImageState } from '../textures/removeImageState.js';
 
 export function disposeNativeLayer() {
   const state = this;
   if (state.disposed) return;
   state.disposed = true;
-  const { source, map, backend, meshes, textures, images } = state;
+  const { source, map, backend: layer, meshes, textures, images } = state;
   const events = 'load tileload tileunload move drag';
   source.off(events, refreshNativeEvent, state);
   map.off('zoomend', refreshNativeEvent, state);
@@ -25,15 +25,15 @@ export function disposeNativeLayer() {
     if (methods.own) Object.defineProperty(source, name, methods.own);
     else delete source[name];
   }
-  for (mesh of meshes.values()) disposeMesh(backend, mesh);
+  for (mesh of meshes.values()) disposeMesh(layer, mesh);
   meshes.clear();
-  for (texture of textures.values()) destroyTexture(backend, texture.texture);
+  for (texture of textures.values()) destroyTexture(layer, texture.texture);
   textures.clear();
   for (image of images) {
     image.removeEventListener('load', nativeImageRefresh);
     image.removeEventListener('error', nativeImageError);
     removeImageState(image, state);
   }
-  nativeRenderByLayer.delete(backend);
-  backend.remove();
+  nativeRenderByLayer.delete(layer);
+  layer.remove();
 }

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

@@ -1,6 +1,7 @@
-import { nativeEventMaps } from '../globals/nativeEventMaps.js';
-import { renderers } from '../globals/renderers.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
+import { nativeEventMaps } from '../weakmaps/nativeEventMaps.js';
+import { renderers } from '../weakmaps/renderers.js';
 import { coreEventTypes } from '../globals/coreEventTypes.js';
 
 
@@ -12,7 +13,7 @@ import { bypassNativeEvent } from './bypassNativeEvent.js';
 export function handleNativeMapEvent(event, type = event.type, targets) {
   const map = this, context = nativeEventMaps.get(map), fireDOMEvent = context.fireDOMEvent;
   const owner = renderers.get(map);
-  if (!sceneByLayer.get(owner)?.renderer || targets || !coreEventTypes.has(type)) {
+  if (!rendererByLayer.get(owner) || targets || !coreEventTypes.has(type)) {
     return fireDOMEvent.call(this, event, type, targets);
   }
   if (bypassNativeEvent(map, context, event, type)) {

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

@@ -1,25 +1,28 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+
 
 
 import { nativeLayer } from './nativeLayer.js';
 import { hideTargets } from './hideTargets.js';
 import { removeTargets } from './removeTargets.js';
 import { readyNativeGPU } from './readyNativeGPU.js';
-import { reportError } from '../scene/reportError.js';
+import { reportError } from '../scene/reportLayerError.js';
 
 export function initNativeGPU(source, map) {
-  if (sceneByLayer.get(source)._nativeGPU) return;
+  if (nativeGPUByLayer.get(source)) return;
   if (!document.getElementById('leaflet-webgpu-targets')) {
     const style = document.createElement('style');
     style.id = 'leaflet-webgpu-targets';
     style.textContent = '.leaflet-webgpu-target{opacity:0!important}';
     document.head.append(style);
   }
-  const state = sceneByLayer.get(source)._nativeGPU = /* alloc */ {
+  const state = /* alloc */ {
     source, map, hidden: /* alloc */ new Set(),
   };
+  nativeGPUByLayer.set(source, state);
   hideTargets(state);
   source.once('remove', removeTargets.bind(null, state));
-  sceneByLayer.get(source).ready = Promise.resolve().then(readyNativeGPU.bind(null, state));
-  sceneByLayer.get(source).ready.catch(reportError.bind(null, source));
+  readyByLayer.set(source, Promise.resolve().then(readyNativeGPU.bind(null, state)));
+  readyByLayer.get(source).catch(reportError.bind(null, source));
 }

package/src/native/isCurrentNativeLayer.js

@@ -0,0 +1,7 @@
+import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
+
+
+
+export function current(state) {
+  return nativeGPUByLayer.get(state.source) === state && state.map.hasLayer(state.source);
+}

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

@@ -4,13 +4,13 @@ import { compareNativeHits } from './compareNativeHits.js';
 
 export function nativeEventSource(context, event, type) {
   const hits = /* alloc */ [];
-  let candidate, source, backend;
+  let candidate, source, layer;
   if (type !== context.out) {
     for (candidate of context.states) {
-      ({ source, backend } = candidate);
+      ({ source, backend: layer } = candidate);
       if (source instanceof L.Marker || source.options.interactive === false ||
         !(source instanceof L.Path) && !source.options.interactive) continue;
-      hits.push(...raycast(backend, event, candidate.meshes.values(), false));
+      hits.push(...raycast(layer, event, candidate.meshes.values(), false));
     }
   }
   hits.sort(compareNativeHits);

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

@@ -1,5 +1,5 @@
 import { L } from '../globals/L.js';
-import { nativeEventMaps } from '../globals/nativeEventMaps.js';
+import { nativeEventMaps } from '../weakmaps/nativeEventMaps.js';
 
 
 import { raycast } from '../picking/raycast.js';

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