leaflet-city-mapper 0.0.4 → 0.0.5

package/src/scene/init3D.js

@@ -1,43 +1,45 @@
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+import { countStatusByLayer } from '../weakmaps/countStatusByLayer.js';
+import { directoriesByLayer } from '../weakmaps/directoriesByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { inflightByLayer } from '../weakmaps/inflightByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { modelUrlByLayer } from '../weakmaps/modelUrlByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+import { state3dByLayer } from '../weakmaps/state3dByLayer.js';
+import { urlByLayer } from '../weakmaps/urlByLayer.js';
+
 import { L } from '../globals/L.js';
 import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
-import { attach } from './attach.js';
-import { emptyNode } from './emptyNode.js';
-import { onAdd3DLayer } from './onAdd3DLayer.js';
-import { onRemove3DLayer } from './onRemove3DLayer.js';
-import { update } from './update.js';
-import { updateArea } from '../sources/updateArea.js';
-import { onTerrainChange } from '../terrain/onTerrainChange.js';
-import { getHeader } from '../archives/getHeader.js';
-import { loadModel } from '../models/loadModel.js';
-import { get3DEvents } from './get3DEvents.js';
 import { ready3D } from './ready3D.js';
 import { noOperation } from '../utils/noOperation.js';
-import { updateLayerCount } from './updateLayerCount.js';
+import { updateLayerCount } from '../layer-controls/updateLayerCount.js';
 
 export function init3D(layer, options = sceneEmptyOptions) {
-  sceneByLayer.get(layer)._3d = true;
+  state3dByLayer.set(layer, true);
   L.Util.setOptions(layer, /* alloc */ { ariaLabel: '3D scene', ...options });
-  sceneByLayer.get(layer).kind = '3d';
-  const isModel = !sceneByLayer.get(layer)._geojson && /\.(glb|gltf)(?:[?#]|$)/i.test(layer.options.url);
-  sceneByLayer.get(layer).modelUrl = isModel ? layer.options.url : null;
-  sceneByLayer.get(layer).url = layer.options.url && !isModel && !sceneByLayer.get(layer)._geojson ? /* alloc */ new URL(layer.options.url, document.baseURI).href : null;
-  sceneByLayer.get(layer)._directories = /* alloc */ new Map();
+  kindByLayer.set(layer, '3d');
+  const isModel = !geojsonByLayer.get(layer) && /\.(glb|gltf)(?:[?#]|$)/i.test(layer.options.url);
+  modelUrlByLayer.set(layer, isModel ? layer.options.url : null);
+  urlByLayer.set(layer, layer.options.url && !isModel && !geojsonByLayer.get(layer) ? /* alloc */ new URL(layer.options.url, document.baseURI).href : null);
+  directoriesByLayer.set(layer, /* alloc */ new Map());
   if (layer.options.center) {
-    sceneByLayer.get(layer).location = /* alloc */ new L.LatLng(layer.options.center[0], layer.options.center[1]);
+    locationByLayer.set(layer, /* alloc */ new L.LatLng(layer.options.center[0], layer.options.center[1]));
   }
-  sceneByLayer.get(layer)._areas = /* alloc */ new Map();
-  sceneByLayer.get(layer)._inflight = 0;
-  if (sceneByLayer.get(layer).url || sceneByLayer.get(layer)._geojson || isModel) {
+  areasByLayer.set(layer, /* alloc */ new Map());
+  inflightByLayer.set(layer, 0);
+  if (urlByLayer.get(layer) || geojsonByLayer.get(layer) || isModel) {
     const status = L.DomUtil.create('small', 'layer-count');
     status.style.cssText = 'float:right;margin-left:12px;color:#555;font-variant-numeric:tabular-nums';
-    sceneByLayer.get(layer)._countStatus = status;
+    countStatusByLayer.set(layer, status);
     layer.on('add error', updateLayerCount);
     layer.on('ready progress', L.Util.throttle(updateLayerCount, 250, layer));
   }
-  sceneByLayer.get(layer)._added = Promise.withResolvers();
-  sceneByLayer.get(layer).ready = Promise.resolve().then(ready3D.bind(null, layer));
-  sceneByLayer.get(layer).ready.catch(noOperation);
+  addedByLayer.set(layer, Promise.withResolvers());
+  readyByLayer.set(layer, Promise.resolve().then(ready3D.bind(null, layer)));
+  readyByLayer.get(layer).catch(noOperation);
 }

package/src/scene/initializeLayer.js

@@ -1,5 +1,7 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { reportError } from './reportError.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+
+import { reportError } from './reportLayerError.js';
 
 
 export function initializeLayer(task) {
@@ -11,10 +13,10 @@ export function initializeLayer(task) {
   try {
     const map = layer._map;
     map?.removeLayer(layer);
-    delete sceneByLayer.get(layer).kind;
+    kindByLayer.delete(layer);
     task.initialize(layer, task.settings);
     map?.addLayer(layer);
-    return sceneByLayer.get(layer).ready === ready ? layer : sceneByLayer.get(layer).ready;
+    return readyByLayer.get(layer) === ready ? layer : readyByLayer.get(layer);
   } catch (error) {
     layer.fire('error', /* alloc */ { error });
     throw error;

package/src/scene/isNativeLayer.js

@@ -1,8 +1,9 @@
+import { state3dByLayer } from '../weakmaps/state3dByLayer.js';
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 export function isNativeLayer(layer) {
-  return !sceneByLayer.get(layer)._3d && (
+  return !state3dByLayer.get(layer) && (
     layer instanceof L.GridLayer ||
     layer instanceof L.Polyline ||
     layer instanceof L.CircleMarker ||

package/src/scene/layerInitialize.js

@@ -1,7 +1,11 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+import { sceneLayers } from '../weakmaps/sceneLayers.js';
+import { typeByLayer } from '../weakmaps/typeByLayer.js';
+
 import { L } from '../globals/L.js';
 import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
 import { layerProto } from '../globals/layerProto.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { pendingInitializations } from '../globals/pendingInitializations.js';
 import { loading } from '../globals/loading.js';
 
@@ -13,8 +17,8 @@ import { resolveNextInitialization } from './resolveNextInitialization.js';
 import { initializeLayer } from './initializeLayer.js';
 
 export function layerInitialize(options = sceneEmptyOptions) {
-  if (!sceneByLayer.has(this)) {
-    sceneByLayer.set(this, /* alloc */ {});
+  if (!sceneLayers.has(this)) {
+    sceneLayers.add(this);
   }
   if (Object.getPrototypeOf(this) !== L.Layer.prototype || !options?.source) {
     if (layerProto.value.initialize) return layerProto.value.initialize.apply(this, arguments);
@@ -33,16 +37,17 @@ export function layerInitialize(options = sceneEmptyOptions) {
   } = options;
   const settings = /* alloc */ { ...source, ...core };
   L.Util.setOptions(this, core);
-  sceneByLayer.get(this)._type = type;
+  typeByLayer.set(this, type);
   if (type === '3d') {
     init3D(this, settings);
     return;
   }
-  sceneByLayer.get(this).kind = 'pending';
+  kindByLayer.set(this, 'pending');
   const task = /* alloc */ { layer: this, type, settings, ready: null };
   pendingInitializations.push(task);
   loading.value = loading.value.catch(noOperation).then(resolveNextInitialization);
-  const ready = sceneByLayer.get(this).ready = loading.value.then(initializeLayer);
+  const ready = loading.value.then(initializeLayer);
+  readyByLayer.set(this, ready);
   task.ready = ready;
   ready.catch(noOperation);
 }

package/src/scene/onAdd3DLayer.js

@@ -1,39 +1,45 @@
+import { containerByLayer } from '../weakmaps/containerByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { modelUrlByLayer } from '../weakmaps/modelUrlByLayer.js';
+import { pointerEventsByLayer } from '../weakmaps/pointerEventsByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { tooltipByLayer } from '../weakmaps/tooltipByLayer.js';
+import { urlByLayer } from '../weakmaps/urlByLayer.js';
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
-import * as attach from './attach.js';
-import * as onClick from '../picking/onClick.js';
-import * as onPointerLeave from '../picking/onPointerLeave.js';
-import * as onPointerMove from '../picking/onPointerMove.js';
 import { pointerMove } from '../picking/pointerMove.js';
 import { pointerClick } from '../picking/pointerClick.js';
 import { pointerLeave } from '../picking/pointerLeave.js';
 import { attachLayer } from './attachLayer.js';
 
 /** Attach interaction immediately; initialization may finish before or after onAdd. */
-export function onAdd3DLayer(backend, map) {
-  if (!sceneByLayer.get(backend).location) {
+export function onAdd3DLayer(layer, map) {
+  if (!locationByLayer.get(layer)) {
     const center = map.getCenter();
-    sceneByLayer.get(backend).location = /* alloc */ new L.LatLng(center.lat, center.lng);
+    locationByLayer.set(layer, /* alloc */ new L.LatLng(center.lat, center.lng));
   }
-  if (sceneByLayer.get(backend).url || sceneByLayer.get(backend)._geojson || backend.options.tooltip || sceneByLayer.get(backend).modelUrl) {
-    sceneByLayer.get(backend).container = map.getContainer();
-    sceneByLayer.get(backend)._pointerEvents ||= /* alloc */ {
-      mousemove: pointerMove,
-      click: pointerClick,
-      mouseleave: pointerLeave,
-    };
-    if (backend.options.tooltip) {
-      sceneByLayer.get(backend)._tooltip = L.DomUtil.create('div', 'leaflet-3d-tooltip', sceneByLayer.get(backend).container);
-      sceneByLayer.get(backend)._tooltip.hidden = true;
-      sceneByLayer.get(backend)._tooltip.setAttribute('role', 'tooltip');
-      sceneByLayer.get(backend)._tooltip.setAttribute('aria-live', 'polite');
-      sceneByLayer.get(backend)._tooltip.style.cssText = 'position:absolute;z-index:600;max-width:220px;padding:10px 12px;border:1px solid #6b5140;border-radius:6px;background:#fffaf0;box-shadow:0 3px 12px #0005;color:#30251d;font:13px/1.45 sans-serif;pointer-events:none';
+  if (urlByLayer.get(layer) || geojsonByLayer.get(layer) || layer.options.tooltip || modelUrlByLayer.get(layer)) {
+    containerByLayer.set(layer, map.getContainer());
+    if (!pointerEventsByLayer.get(layer)) {
+      pointerEventsByLayer.set(layer, /* alloc */ {
+        mousemove: pointerMove,
+        click: pointerClick,
+        mouseleave: pointerLeave,
+      });
+    }
+    if (layer.options.tooltip) {
+      tooltipByLayer.set(layer, L.DomUtil.create('div', 'leaflet-3d-tooltip', containerByLayer.get(layer)));
+      tooltipByLayer.get(layer).hidden = true;
+      tooltipByLayer.get(layer).setAttribute('role', 'tooltip');
+      tooltipByLayer.get(layer).setAttribute('aria-live', 'polite');
+      tooltipByLayer.get(layer).style.cssText = 'position:absolute;z-index:600;max-width:220px;padding:10px 12px;border:1px solid #6b5140;border-radius:6px;background:#fffaf0;box-shadow:0 3px 12px #0005;color:#30251d;font:13px/1.45 sans-serif;pointer-events:none';
     }
-    L.DomEvent.on(sceneByLayer.get(backend).container, sceneByLayer.get(backend)._pointerEvents, backend);
+    L.DomEvent.on(containerByLayer.get(layer), pointerEventsByLayer.get(layer), layer);
   }
-  if (sceneByLayer.get(backend).root) {
-    attachLayer(backend, map);
+  if (rootByLayer.get(layer)) {
+    attachLayer(layer, map);
   }
 }

package/src/scene/onMapChange.js

@@ -1,8 +1,9 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { queuedByLayer } from '../weakmaps/queuedByLayer.js';
+
 import { pendingMapChanges } from '../globals/pendingMapChanges.js';
 
 
-import { update } from './update.js';
+import { update } from './scheduleSceneUpdate.js';
 import { render } from "../rendering/render.js";
 
 import { renderPendingMapChange } from './renderPendingMapChange.js';
@@ -11,8 +12,8 @@ import { renderPendingMapChange } from './renderPendingMapChange.js';
 
 export function onMapChange() {
   const layer = this;
-  if (sceneByLayer.get(layer)._queued) return;
-  sceneByLayer.get(layer)._queued = true;
+  if (queuedByLayer.get(layer)) return;
+  queuedByLayer.set(layer, true);
   pendingMapChanges.push(layer);
   queueMicrotask(renderPendingMapChange);
 }

package/src/scene/onRemove3DLayer.js

@@ -1,54 +1,69 @@
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
+import { containerByLayer } from '../weakmaps/containerByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { pointerEventsByLayer } from '../weakmaps/pointerEventsByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
+import { sceneFields } from '../weakmaps/sceneFields.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+import { tooltipByLayer } from '../weakmaps/tooltipByLayer.js';
+import { urlByLayer } from '../weakmaps/urlByLayer.js';
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { sceneTransferFields } from '../globals/sceneTransferFields.js';
-import { renderers } from '../globals/renderers.js';
+import { renderers } from '../weakmaps/renderers.js';
 
 
 
-import * as endZoom from './endZoom.js';
+import * as endZoom from '../animations/endZoom.js';
 import * as onMapChange from './onMapChange.js';
 import * as onPointerLeave from '../picking/onPointerLeave.js';
-import * as onZoomAnim from './onZoomAnim.js';
+import * as onZoomAnim from '../animations/onZoomAnim.js';
 import { releaseArea } from '../sources/releaseArea.js';
-import { updateStatus } from '../sources/updateStatus.js';
+import { updateStatus } from '../sources/updateSourceStatus.js';
 import { setParent } from './setParent.js';
-import * as startZoom from './startZoom.js';
+import * as startZoom from '../animations/startZoom.js';
 import { cancelUpdate } from './cancelUpdate.js';
-import { update } from './update.js';
+import { update } from './scheduleSceneUpdate.js';
 import { releaseSharedScene } from './releaseSharedScene.js';
 
 /** Release source meshes/UI; retain manually added objects and model CPU data. */
-export function onRemove3DLayer(backend, map) {
-  sceneByLayer.get(backend)._added = Promise.withResolvers();
-  if (sceneByLayer.get(backend).container) {
-    onPointerLeave.onPointerLeave(backend);
-    L.DomEvent.off(sceneByLayer.get(backend).container, sceneByLayer.get(backend)._pointerEvents, backend);
-    sceneByLayer.get(backend).container = null;
+export function onRemove3DLayer(layer, map) {
+  addedByLayer.set(layer, Promise.withResolvers());
+  if (containerByLayer.get(layer)) {
+    onPointerLeave.onPointerLeave(layer);
+    L.DomEvent.off(containerByLayer.get(layer), pointerEventsByLayer.get(layer), layer);
+    containerByLayer.set(layer, null);
   }
-  let area, key, layer;
-  for (area of sceneByLayer.get(backend)._areas.values()) releaseArea(backend, area);
-  sceneByLayer.get(backend)._areas.clear();
-  sceneByLayer.get(backend)._tooltip?.remove();
-  sceneByLayer.get(backend)._tooltip = null;
-  if (sceneByLayer.get(backend).url || sceneByLayer.get(backend)._geojson) updateStatus(backend, false);
-  const shared = sceneByLayer.get(backend)._shared;
+  let area, key, sceneLayer, field;
+  for (area of areasByLayer.get(layer).values()) releaseArea(layer, area);
+  areasByLayer.get(layer).clear();
+  tooltipByLayer.get(layer)?.remove();
+  tooltipByLayer.set(layer, null);
+  if (urlByLayer.get(layer) || geojsonByLayer.get(layer)) updateStatus(layer, false);
+  const shared = sharedByLayer.get(layer);
   if (!shared) return;
-  setParent(sceneByLayer.get(backend).root, null);
-  sceneByLayer.get(shared)._layers.delete(backend);
-  if (shared === backend) {
-    map.off('move zoom rotate pitch resize viewreset layeradd layerremove', onMapChange.onMapChange, backend);
-    map.off('zoomstart', startZoom.startZoom, backend);
-    map.off('zoomanim', onZoomAnim.onZoomAnim, backend);
-    map.off('zoomend', endZoom.endZoom, backend);
-    cancelUpdate(backend);
-    if (sceneByLayer.get(backend)._layers.size) {
+  setParent(rootByLayer.get(layer), null);
+  layersByLayer.get(shared).delete(layer);
+  if (shared === layer) {
+    map.off('move zoom rotate pitch resize viewreset layeradd layerremove', onMapChange.onMapChange, layer);
+    map.off('zoomstart', startZoom.startZoom, layer);
+    map.off('zoomanim', onZoomAnim.onZoomAnim, layer);
+    map.off('zoomend', endZoom.endZoom, layer);
+    cancelUpdate(layer);
+    if (layersByLayer.get(layer).size) {
       // Keep the original scene origin and GPU resources when ownership changes.
-      const next = sceneByLayer.get(backend)._layers.values().next().value;
+      const next = layersByLayer.get(layer).values().next().value;
       for (key of sceneTransferFields) {
-        sceneByLayer.get(next)[key] = sceneByLayer.get(backend)[key];
-        delete sceneByLayer.get(backend)[key];
+        field = sceneFields[key];
+        field.set(next, field.get(layer));
+        field.delete(layer);
       }
-      for (layer of sceneByLayer.get(next)._layers) sceneByLayer.get(layer)._shared = next;
+      for (sceneLayer of layersByLayer.get(next)) sharedByLayer.set(sceneLayer, next);
       renderers.set(map, next);
       map.on('move zoom rotate pitch resize viewreset layeradd layerremove', onMapChange.onMapChange, next);
       map.on('zoomstart', startZoom.startZoom, next);
@@ -56,8 +71,11 @@ export function onRemove3DLayer(backend, map) {
       map.on('zoomend', endZoom.endZoom, next);
       update(next);
     } else {
-      releaseSharedScene(backend, map);
+      releaseSharedScene(layer, map);
     }
   } else update(shared);
-  sceneByLayer.get(backend)._shared = sceneByLayer.get(backend).renderer = sceneByLayer.get(backend).scene = sceneByLayer.get(backend).camera = null;
+  sharedByLayer.set(layer, null);
+  rendererByLayer.set(layer, null);
+  sceneByLayer.set(layer, null);
+  cameraByLayer.set(layer, null);
 }

package/src/scene/ready3D.js

@@ -1,31 +1,40 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { groupByLayer } from '../weakmaps/groupByLayer.js';
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { modelUrlByLayer } from '../weakmaps/modelUrlByLayer.js';
+import { raycasterByLayer } from '../weakmaps/raycasterByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+import { urlByLayer } from '../weakmaps/urlByLayer.js';
 
 
-import { emptyNode } from './emptyNode.js';
+
+import { emptyNode } from './createSceneNode.js';
 import { getHeader } from '../archives/getHeader.js';
-import { attach } from './attach.js';
+import { attach } from './attachSharedScene.js';
 import { loadModel } from '../models/loadModel.js';
-import { update } from './update.js';
+import { update } from './scheduleSceneUpdate.js';
 
 export async function ready3D(layer) {
   try {
-    sceneByLayer.get(layer).root = emptyNode();
-    sceneByLayer.get(layer).raycaster = /* alloc */ {
+    rootByLayer.set(layer, emptyNode());
+    raycasterByLayer.set(layer, /* alloc */ {
       origin: /* alloc */ [0, 0, 0],
       direction: /* alloc */ [0, 0, 0],
       inverse: /* alloc */ new DOMMatrix(),
       meshes: /* alloc */ [],
-    };
-    if (sceneByLayer.get(layer).url || sceneByLayer.get(layer)._geojson) {
-      sceneByLayer.get(layer).group = sceneByLayer.get(layer).root;
-      if (sceneByLayer.get(layer).url) sceneByLayer.get(layer).header = await getHeader(layer);
+    });
+    if (urlByLayer.get(layer) || geojsonByLayer.get(layer)) {
+      groupByLayer.set(layer, rootByLayer.get(layer));
+      if (urlByLayer.get(layer)) headerByLayer.set(layer, await getHeader(layer));
     }
     if (layer._map) {
       await attach(layer, layer._map);
-      sceneByLayer.get(layer)._added.resolve();
+      addedByLayer.get(layer).resolve();
     }
-    if (sceneByLayer.get(layer).modelUrl) await loadModel(layer);
-    if (sceneByLayer.get(layer)._shared) update(layer);
+    if (modelUrlByLayer.get(layer)) await loadModel(layer);
+    if (sharedByLayer.get(layer)) update(layer);
     layer.fire('ready');
     return layer;
   } catch (error) {

package/src/scene/releaseSharedScene.js

@@ -1,25 +1,31 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { renderers } from '../globals/renderers.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
-import { sceneCleanupFields } from '../globals/sceneCleanupFields.js';
-import { destroyTexture } from '../rendering/destroyTexture.js';
-import { releaseRenderer } from './releaseRenderer.js';
-
-export function releaseSharedScene(backend, map) {
-  if (sceneByLayer.get(backend)._roofRaster) destroyTexture(backend, sceneByLayer.get(backend)._roofRaster.texture.texture);
-  sceneByLayer.get(backend)._roofRaster = null;
-  if (sceneByLayer.get(backend)._zoomTransitions) {
-    let animation;
-    for (animation of sceneByLayer.get(backend)._zoomTransitions.keys()) animation.play();
-  }
-  sceneByLayer.get(backend)._zoomTransitions = null;
-  sceneByLayer.get(backend)._zoomView = null;
-  delete cameraByMap.get(map)._cameraView;
-  map.getContainer().classList.remove('leaflet-camera-zoom');
-  const renderer = sceneByLayer.get(backend).renderer;
-  renderer.canvas.remove();
-  releaseRenderer(renderer, backend);
-  renderers.delete(map);
-  let key;
-  for (key of sceneCleanupFields) delete sceneByLayer.get(backend)[key];
-}
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { roofRasterByLayer } from '../weakmaps/roofRasterByLayer.js';
+import { sceneFields } from '../weakmaps/sceneFields.js';
+import { zoomTransitionsByLayer } from '../weakmaps/zoomTransitionsByLayer.js';
+import { zoomViewByLayer } from '../weakmaps/zoomViewByLayer.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+
+
+import { renderers } from '../weakmaps/renderers.js';
+import { sceneCleanupFields } from '../globals/sceneCleanupFields.js';
+import { destroyTexture } from '../textures/destroyTexture.js';
+import { releaseRenderer } from '../gpu/releaseRenderer.js';
+
+export function releaseSharedScene(layer, map) {
+  if (roofRasterByLayer.get(layer)) destroyTexture(layer, roofRasterByLayer.get(layer).texture.texture);
+  roofRasterByLayer.set(layer, null);
+  if (zoomTransitionsByLayer.get(layer)) {
+    let animation;
+    for (animation of zoomTransitionsByLayer.get(layer).keys()) animation.play();
+  }
+  zoomTransitionsByLayer.set(layer, null);
+  zoomViewByLayer.set(layer, null);
+  cameraViewByMap.delete(map);
+  map.getContainer().classList.remove('leaflet-camera-zoom');
+  const renderer = rendererByLayer.get(layer);
+  renderer.canvas.remove();
+  releaseRenderer(renderer, layer);
+  renderers.delete(map);
+  let key;
+  for (key of sceneCleanupFields) sceneFields[key].delete(layer);
+}

package/src/scene/removeLayerEvents.js

@@ -1,9 +1,12 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-
-
-export function removeLayerEvents() {
-  const state = sceneByLayer.get(this);
-  state.eventMap.off(state.events, this);
-  state.events = state.eventMap = null;
-}
+import { eventMapByLayer } from '../weakmaps/eventMapByLayer.js';
+import { eventsByLayer } from '../weakmaps/eventsByLayer.js';
+
+
+
+
+export function removeLayerEvents() {
+
+  eventMapByLayer.get(this).off(eventsByLayer.get(this), this);
+  eventMapByLayer.set(this, null);
+  eventsByLayer.set(this, null);
+}

package/src/scene/removeSceneLayer.js

@@ -1,4 +1,5 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
 
 import { onRemove3DLayer } from './onRemove3DLayer.js';
 import { onPMTileRemove } from '../raster/onPMTileRemove.js';
@@ -6,7 +7,7 @@ import { onTerrainRemove } from '../terrain/onTerrainRemove.js';
 import { removeTimeLayer } from '../sunlight/removeTimeLayer.js';
 
 export function removeSceneLayer(layer, map) {
-  switch (sceneByLayer.get(layer).kind) {
+  switch (kindByLayer.get(layer)) {
     case '3d': return onRemove3DLayer(layer, map);
     case 'raster': return onPMTileRemove(layer, map);
     case 'terrain': return onTerrainRemove(layer, map);

package/src/scene/renderPendingMapChange.js

@@ -1,15 +1,18 @@
+import { queuedByLayer } from '../weakmaps/queuedByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
 import { pendingMapChanges } from '../globals/pendingMapChanges.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 
-import { update } from './update.js';
+import { update } from './scheduleSceneUpdate.js';
 import { render } from '../rendering/render.js';
 
 export function renderPendingMapChange() {
   const layer = pendingMapChanges.shift();
-  sceneByLayer.get(layer)._queued = false;
-  if (sceneByLayer.get(layer)._shared !== layer || !sceneByLayer.get(layer).renderer) return;
+  queuedByLayer.set(layer, false);
+  if (sharedByLayer.get(layer) !== layer || !rendererByLayer.get(layer)) return;
   if (layer._map._animatingZoom) update(layer);
   else render(layer);
 }

package/src/scene/renderPendingUpdates.js

@@ -1,5 +1,8 @@
+import { frameByLayer } from '../weakmaps/frameByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
 import { pendingUpdates } from '../globals/pendingUpdates.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 
@@ -9,12 +12,12 @@ export function renderPendingUpdates() {
   const updates = /* alloc */ [...pendingUpdates];
   pendingUpdates.clear();
   let failure;
-  let backend;
-  for (backend of updates) {
-    sceneByLayer.get(backend)._frame = null;
-    if (sceneByLayer.get(backend)._shared !== backend || !sceneByLayer.get(backend).renderer) continue;
+  let layer;
+  for (layer of updates) {
+    frameByLayer.set(layer, null);
+    if (sharedByLayer.get(layer) !== layer || !rendererByLayer.get(layer)) continue;
     try {
-      render(backend);
+      render(layer);
     } catch (error) {
       failure ||= error;
     }

package/src/scene/restoreObject.js

@@ -1,35 +1,37 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
 
 
-import { createProgram } from '../rendering/createProgram.js';
-import { restoreGeometry } from './restoreGeometry.js';
-import { restoreMaterialTextures } from './restoreMaterialTextures.js';
 
-export function restoreObject(object, backend) {
-  const shared = sceneByLayer.get(backend)._shared;
+import { createProgram } from '../materials/createProgram.js';
+import { restoreGeometry } from '../geometry/restoreGeometry.js';
+import { restoreMaterialTextures } from '../textures/restoreMaterialTextures.js';
+
+export function restoreObject(object, layer) {
+  const shared = sharedByLayer.get(layer);
   let texture;
-  if (object.geometry && object.geometry.device !== sceneByLayer.get(shared).renderer.device) {
+  if (object.geometry && object.geometry.device !== rendererByLayer.get(shared).device) {
     const geometry = object.geometry;
     const material = object.program._layerMaterial;
-    const device = sceneByLayer.get(shared).renderer.device;
+    const device = rendererByLayer.get(shared).device;
     restoreGeometry(geometry, device);
     object.bindGroup = null;
     if (object.boundTextures) object.boundTextures.length = 0;
     else object.boundTextures = /* alloc */ [];
     restoreMaterialTextures(material, device);
     object.program.pipelineCache.clear();
-    object.program = createProgram(backend, material);
+    object.program = createProgram(layer, material);
     object.device = device;
   }
-  if (object.texture && object.texture.device !== sceneByLayer.get(shared).renderer.device) {
+  if (object.texture && object.texture.device !== rendererByLayer.get(shared).device) {
     texture = object.texture;
-    texture.device = sceneByLayer.get(shared).renderer.device;
-    texture.texture = sceneByLayer.get(shared).renderer.device.createTexture(/* alloc */ {
+    texture.device = rendererByLayer.get(shared).device;
+    texture.texture = rendererByLayer.get(shared).device.createTexture(/* alloc */ {
         size: /* alloc */ [object.texture.image.width, object.texture.image.height],
         format: object.texture.format,
         usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
       });
-    texture.sampler = sceneByLayer.get(shared).renderer.device.createSampler(texture.samplerOptions);
+    texture.sampler = rendererByLayer.get(shared).device.createSampler(texture.samplerOptions);
     texture.uploaded = null;
   }
 }