leaflet-city-mapper 0.0.3 → 0.0.4

package/src/rendering/updateRoofAtlas.js

@@ -0,0 +1,20 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { roofSignatures } from '../globals/roofSignatures.js';
+import { rebuildRoofAtlas } from './rebuildRoofAtlas.js';
+
+export function updateRoofAtlas(backend, rasters, now) {
+  const signatures = roofSignatures;
+  signatures.length = 0;
+  let loading = false, layer;
+  for (layer of rasters) {
+    signatures.push(`${L.Util.stamp(layer)}:${sceneByLayer.get(layer)._rasterVersion || 0}:${layer.options.opacity}:${layer.options.zIndex}`);
+    loading ||= Boolean(sceneByLayer.get(layer)._loadingTiles);
+  }
+  const signature = signatures.join('|');
+  signatures.length = 0;
+  if (!sceneByLayer.get(backend)._roofRaster || sceneByLayer.get(backend)._roofRaster.signature !== signature &&
+    (!loading || now - sceneByLayer.get(backend)._roofRaster.updatedAt >= 50)) {
+    rebuildRoofAtlas(backend, rasters, signature, now);
+  }
+}

package/src/rendering/updateRoofRaster.js

@@ -1,32 +1,25 @@
-import { rebuildRoofAtlas } from './rebuildRoofAtlas.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+import { updateRoofAtlas } from './updateRoofAtlas.js';
 import { destroyTexture } from './destroyTexture.js';
 
 export function updateRoofRaster(backend, now) {
   const map = backend._map;
-  const rasters = [];
+  const rasters = sceneByLayer.get(backend)._roofRasters ||= /* alloc */ [];
+  rasters.length = 0;
   let hasRoofTexture = false;
   let layer;
-  for (layer of backend._layers) {
-    if (layer.options.roofTexture) { hasRoofTexture = true; break; }
+  for (layer of sceneByLayer.get(backend)._layers) {
+    if (layer.options.roofTexture || layer.options.wallTexture) { hasRoofTexture = true; break; }
   }
   if (hasRoofTexture) {
     for (layer of Object.values(map._layers)) {
-      if (layer._type === 'pmtiles' && layer._rasterTiles && layer.options.opacity > 0) rasters.push(layer);
-    }
-    const signatures = [];
-    let loading = false;
-    for (layer of rasters) {
-      signatures.push(`${L.Util.stamp(layer)}:${layer._rasterVersion || 0}:${layer.options.opacity}:${layer.options.zIndex}`);
-      loading ||= Boolean(layer._loadingTiles);
-    }
-    const signature = signatures.join('|');
-    if (!backend._roofRaster || backend._roofRaster.signature !== signature &&
-      (!loading || now - backend._roofRaster.updatedAt >= 50)) {
-      rebuildRoofAtlas(backend, rasters, signature, now);
+      if (sceneByLayer.get(layer).kind === 'raster' && sceneByLayer.get(layer)._rasterTiles && layer.options.opacity > 0) rasters.push(layer);
     }
-  } else if (backend._roofRaster) {
-    destroyTexture(backend, backend._roofRaster.texture.texture);
-    backend._roofRaster = null;
+    updateRoofAtlas(backend, rasters, now);
+  } else if (sceneByLayer.get(backend)._roofRaster) {
+    destroyTexture(backend, sceneByLayer.get(backend)._roofRaster.texture.texture);
+    sceneByLayer.get(backend)._roofRaster = null;
   }
   return rasters;
 }

package/src/rendering/updateZoomCamera.js

@@ -0,0 +1,18 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { mapUpdateCameraOverlays } from '../camera/mapUpdateCameraOverlays.js';
+
+export function updateZoomCamera(backend, now) {
+  const map = backend._map;
+  const view = sceneByLayer.get(backend)._zoomView;
+  let proxy, animation;
+  for (animation of sceneByLayer.get(backend)._zoomTransitions.keys()) {
+    if (animation.effect.target === map._proxy) { proxy = animation; break; }
+  }
+  const progress = proxy?.effect.getComputedTiming().progress ?? Math.min(1, (now - view.start) / 250);
+  const targetScale = map.getZoomScale(view.targetZoom, view.zoom), scale = 1 + (targetScale - 1) * progress;
+  const from = map.project(view.from, view.zoom), to = map.project(view.to, view.zoom);
+  cameraByMap.get(map)._cameraView = /* alloc */ { zoom: map.getScaleZoom(scale, view.zoom),
+    center: map.unproject(from.add(to.subtract(from).multiplyBy(targetScale * progress / scale)), view.zoom) };
+  mapUpdateCameraOverlays(map);
+}

package/src/rendering/uploadMeshTexture.js

@@ -0,0 +1,26 @@
+import { meshImage } from '../globals/meshImage.js';
+import { meshTarget } from '../globals/meshTarget.js';
+import { meshCopySize } from '../globals/meshCopySize.js';
+
+export function uploadMeshTexture(device, texture) {
+  if (texture.uploaded === texture.image) return;
+  device.queue.copyExternalImageToTexture(
+    (
+      meshImage.source = texture.image,
+      meshImage.flipY = Boolean(texture.flipY),
+      meshImage
+    ),
+    (
+      meshTarget.texture = texture.texture,
+      meshTarget
+    ),
+    (
+      meshCopySize[0] = texture.image.width,
+      meshCopySize[1] = texture.image.height,
+      meshCopySize
+    )
+  );
+  meshImage.source = null;
+  meshTarget.texture = null;
+  texture.uploaded = texture.image;
+}

package/src/rendering/uploadRoofTile.js

@@ -0,0 +1,23 @@
+import { roofImage } from '../globals/roofImage.js';
+import { roofTarget } from '../globals/roofTarget.js';
+import { roofCopySize } from '../globals/roofCopySize.js';
+
+export function uploadRoofTile(device, tile) {
+  const source = tile.texture;
+  if (source.uploaded !== source.image) {
+    device.queue.copyExternalImageToTexture((
+      roofImage.source = tile.image,
+      roofImage
+    ), (
+      roofTarget.texture = source.texture,
+      roofTarget
+    ), (
+      roofCopySize[0] = source.texture.width,
+      roofCopySize[1] = source.texture.height,
+      roofCopySize
+    ));
+    roofImage.source = null;
+    roofTarget.texture = null;
+    source.uploaded = source.image;
+  }
+}

package/src/scene/addSceneLayer.js

@@ -0,0 +1,17 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+import { onAdd3DLayer } from './onAdd3DLayer.js';
+import { onPMTileAdd } from '../raster/onPMTileAdd.js';
+import { onTerrainAdd } from '../terrain/onTerrainAdd.js';
+import { addRasterImage } from '../core/addRasterImage.js';
+import { addTimeLayer } from '../sunlight/addTimeLayer.js';
+
+export function addSceneLayer(layer, map) {
+  switch (sceneByLayer.get(layer).kind) {
+    case '3d': return onAdd3DLayer(layer, map);
+    case 'raster': return onPMTileAdd(layer, map);
+    case 'terrain': return onTerrainAdd(layer, map);
+    case 'image': return addRasterImage.call(layer, map);
+    case 'time': return addTimeLayer.call(layer, map);
+  }
+}

package/src/scene/attach.js

@@ -1,161 +1,54 @@
-import { cityMapper } from '../constants/cityMapper.js';
-import { emptyNode } from './emptyNode.js';
-import { setParent } from './setParent.js';
-import { createProgram } from '../rendering/createProgram.js';
-import { endZoom } from './endZoom.js';
-import { onMapChange } from './onMapChange.js';
-import { onZoomAnim } from './onZoomAnim.js';
-import { render } from '../rendering/render.js';
-import { startZoom } from './startZoom.js';
-import { update } from './update.js';
-import { updateArea } from '../sources/updateArea.js';
-import { setTerrainHeight } from '../terrain/setTerrainHeight.js';
-import { resizeSunlight } from '../shadows/resizeSunlight.js';
-import { attachState } from '../constants/attachState.js';
-import { noOperation } from '../utils/noOperation.js';
-import { failAttachment } from './failAttachment.js';
-import { requestAdapter } from './requestAdapter.js';
-import { requestDevice } from './requestDevice.js';
-import { rendererDeviceError } from './rendererDeviceError.js';
-import { rendererDeviceLost } from './rendererDeviceLost.js';
-import { restoreObject } from './restoreObject.js';
-
-attachState.rendererDevices = new WeakMap();
-
-/** WebGPU device attachment, materials/pipelines and draw calls. */
-/**
- * Join/create this map's shared scene and rebuild GPU objects if its context changed.
- * Buffer/program handles belong to one context; typed arrays and decoded images do not.
- * @private
- */
-
-export async function attach(backend, map) {
-  let shared = cityMapper.renderers.get(map);
-  if (shared?._rendererReady) {
-    await shared._rendererReady.promise;
-  }
-  if (!shared) {
-    shared = backend;
-    backend._rendererReady = Promise.withResolvers();
-    backend._rendererReady.promise.catch(noOperation);
-    cityMapper.renderers.set(map, shared);
-    const canvas = document.createElement('canvas');
-    if (!navigator.gpu) {
-      failAttachment(new Error('Layer3D requires WebGPU'), backend, map);
-    }
-    const adapter = await requestAdapter(backend, map);
-    const device = await requestDevice(adapter, backend, map);
-    attachState.rendererDevices.set(device, map);
-    device.addEventListener('uncapturederror', rendererDeviceError);
-    Promise.all([device.lost, Promise.resolve(device)]).then(rendererDeviceLost);
-    const context = canvas.getContext('webgpu');
-    if (!context) {
-      device.destroy();
-      failAttachment(new Error('Unable to create a WebGPU canvas context'), backend, map);
-    }
-    const format = navigator.gpu.getPreferredCanvasFormat();
-    context.configure({ device, format, alphaMode: 'premultiplied' });
-    map.getContainer().querySelector('.leaflet-webgpu-warning')?.remove();
-    backend._shared = backend;
-    backend._layers = new Set();
-    backend._sceneOrigin = backend.location;
-    backend.scene = emptyNode();
-    // Perspective camera state: fov in degrees, near/far in scene metres.
-    backend.camera = {
-      position: [0, 0, 0],
-      up: [0, 1, 0],
-      target: [0, 0, 0],
-      viewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-      projectionMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-      projectionViewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-      fov: 45,
-      aspect: 1,
-      near: 0.1,
-      far: 10000,
-    };
-    backend.renderer = {
-      device,
-      context,
-      format,
-      canvas,
-      dpr: Math.min(window.devicePixelRatio, 2)
-    };
-    const layout = device.createBindGroupLayout({
-      entries: [
-        { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: 'uniform' } },
-        { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'depth' } },
-        { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' } },
-        { binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'read-only-storage' } },
-      ]
-    });
-    const buffer = backend.renderer.device.createBuffer({ size: 80, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-    const sampler = backend.renderer.device.createSampler({ compare: 'less-equal', minFilter: 'linear', magFilter: 'linear' });
-    const lights = backend.renderer.device.createBuffer({ size: 32, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
-    backend.renderer.sunlight = { layout, buffer, sampler, lights, size: 0 };
-    const values = new Float32Array(20);
-    values.set([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-    backend.renderer.device.queue.writeBuffer(buffer, 0, values);
-    resizeSunlight(backend, 1);
-    const emptyImage = document.createElement('canvas');
-    emptyImage.width = 1;
-    emptyImage.height = 1;
-    backend.renderer.roofFallbackTexture = {
-      device,
-      texture: device.createTexture({
-        size: [1, 1],
-        format: 'rgba8unorm',
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-      }),
-      sampler: device.createSampler({
-        addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge',
-      }),
-      image: emptyImage, format: 'rgba8unorm', srgb: false, uploaded: null,
-    };
-    shared._size = null;
-    canvas.className = 'leaflet-3d';
-    canvas.style.cssText = 'position:absolute;top:0;left:0;pointer-events:none';
-    canvas.setAttribute('role', 'img');
-    canvas.setAttribute('aria-label', backend.options.ariaLabel ?? '3D scene');
-    let pane = map.getPane('webgpuPane');
-    if (!pane) {
-      pane = map.createPane('webgpuPane', map.getContainer());
-      // The pitch sky uses 0 and may be inserted after this pane.
-      pane.style.zIndex = 1;
-      pane.style.pointerEvents = 'none';
-    }
-    pane.append(canvas);
-    map.on('move zoom rotate pitch resize viewreset layeradd layerremove', onMapChange, shared);
-    map.on('zoomstart', startZoom, shared);
-    map.on('zoomanim', onZoomAnim, shared);
-    map.on('zoomend', endZoom, shared);
-    backend._rendererReady.resolve();
-    delete shared._rendererReady;
-    render(shared);
-    cityMapper.renderers.set(map, shared);
-  }
-  const origin = map.options.crs.project(shared._sceneOrigin);
-  const point = map.options.crs.project(backend.location);
-  const metres = Math.cos(shared._sceneOrigin.lat * Math.PI / 180);
-  backend._terrainBaseY ??= backend.root.position[1];
-  backend.root.position[0] = (point.x - origin.x) * metres;
-  backend.root.position[1] = backend._terrainBaseY;
-  backend.root.position[2] = -(point.y - origin.y) * metres;
-  setTerrainHeight(backend);
-  // Each group's metres are measured at its own latitude, not the shared camera origin.
-  backend.root.scale.fill(metres / Math.cos(backend.location.lat * Math.PI / 180));
-  backend._shared = shared;
-  backend.renderer = shared.renderer;
-  backend.scene = shared.scene;
-  backend.camera = shared.camera;
-  shared._layers.add(backend);
-  setParent(backend.root, shared.scene);
-  const pendingObjects = [backend.root];
-  let object, i;
-  while (pendingObjects.length) {
-    object = pendingObjects.pop();
-    restoreObject(backend, shared, object);
-    for (i = object.children.length - 1; i >= 0; i--) pendingObjects.push(object.children[i]);
-  }
-  update(shared);
-  if ((backend.header && backend._type !== 'pmtiles') || backend._geojson) updateArea(backend);
-}
+import { radians } from '../globals/radians.js';
+import { renderers } from '../globals/renderers.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { setParent } from './setParent.js';
+import { render } from '../rendering/render.js';
+import { update } from './update.js';
+import { updateArea } from '../sources/updateArea.js';
+import { setTerrainHeight } from '../terrain/setTerrainHeight.js';
+import { noOperation } from '../utils/noOperation.js';
+import { restoreObject } from './restoreObject.js';
+import { traverse } from './traverse.js';
+import { initializeSharedRenderer } from './initializeSharedRenderer.js';
+
+/**
+ * Join/create this map's shared scene and rebuild GPU objects if its context changed.
+ * Buffer/program handles belong to one context; typed arrays and decoded images do not.
+ * @private
+ */
+export async function attach(backend, map) {
+  let shared = renderers.get(map);
+  if (sceneByLayer.get(shared)?._rendererReady) {
+    await sceneByLayer.get(shared)._rendererReady.promise;
+  }
+  if (!shared) {
+    shared = backend;
+    sceneByLayer.get(backend)._rendererReady = Promise.withResolvers();
+    sceneByLayer.get(backend)._rendererReady.promise.catch(noOperation);
+    renderers.set(map, shared);
+    await initializeSharedRenderer(backend, map);
+    sceneByLayer.get(backend)._rendererReady.resolve();
+    delete sceneByLayer.get(shared)._rendererReady;
+    render(shared);
+    renderers.set(map, shared);
+  }
+  const origin = map.options.crs.project(sceneByLayer.get(shared)._sceneOrigin);
+  const point = map.options.crs.project(sceneByLayer.get(backend).location);
+  const metres = Math.cos(sceneByLayer.get(shared)._sceneOrigin.lat * radians);
+  sceneByLayer.get(backend)._terrainBaseY ??= sceneByLayer.get(backend).root.position[1];
+  sceneByLayer.get(backend).root.position[0] = (point.x - origin.x) * metres;
+  sceneByLayer.get(backend).root.position[1] = sceneByLayer.get(backend)._terrainBaseY;
+  sceneByLayer.get(backend).root.position[2] = -(point.y - origin.y) * metres;
+  setTerrainHeight(backend);
+  // Each group's metres are measured at its own latitude, not the shared camera origin.
+  sceneByLayer.get(backend).root.scale.fill(metres / Math.cos(sceneByLayer.get(backend).location.lat * radians));
+  sceneByLayer.get(backend)._shared = shared;
+  sceneByLayer.get(backend).renderer = sceneByLayer.get(shared).renderer;
+  sceneByLayer.get(backend).scene = sceneByLayer.get(shared).scene;
+  sceneByLayer.get(backend).camera = sceneByLayer.get(shared).camera;
+  sceneByLayer.get(shared)._layers.add(backend);
+  setParent(sceneByLayer.get(backend).root, sceneByLayer.get(shared).scene);
+  traverse(sceneByLayer.get(backend).root, restoreObject, backend);
+  update(shared);
+  if ((sceneByLayer.get(backend).header && sceneByLayer.get(backend).kind !== 'raster') || sceneByLayer.get(backend)._geojson) updateArea(backend);
+}

package/src/scene/attachLayer.js

@@ -1,10 +1,13 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import * as attach from './attach.js';
 
 export async function attachLayer(backend, map) {
   try {
     await attach.attach(backend, map);
-    backend._added.resolve();
+    sceneByLayer.get(backend)._added.resolve();
   } catch (error) {
-    backend.fire('error', { error });
+    backend.fire('error', /* alloc */ { error });
   }
 }

package/src/scene/callLayer.js

@@ -0,0 +1,26 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+import { setGeoJSONData } from '../sources/setGeoJSONData.js';
+import { getHeader } from '../archives/getHeader.js';
+import { getZxy } from '../archives/getZxy.js';
+import { getRasterTileSize } from '../raster/getRasterTileSize.js';
+import { isLoading } from '../raster/isLoading.js';
+import { setPMTileOpacity } from '../raster/setPMTileOpacity.js';
+import { setPMTileZIndex } from '../raster/setPMTileZIndex.js';
+
+
+export function callLayer(method, layer, ...args) {
+  const scene = sceneByLayer.get(layer);
+  if (method === 'setData' && scene?._geojson) return setGeoJSONData(layer, ...args);
+  if (scene?.kind === 'raster') {
+    switch (method) {
+      case 'getHeader': return getHeader(layer);
+      case 'getZxy': return getZxy(layer, ...args);
+      case 'getTileSize': return getRasterTileSize();
+      case 'isLoading': return isLoading(layer);
+      case 'setOpacity': return setPMTileOpacity(layer, ...args);
+      case 'setZIndex': return setPMTileZIndex(layer, ...args);
+    }
+  }
+  return layer[method](...args);
+}

package/src/scene/cancelUpdate.js

@@ -1,9 +1,12 @@
-import { pendingUpdates } from '../constants/pendingUpdates.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { pendingUpdates } from '../globals/pendingUpdates.js';
+
+
 
 export function cancelUpdate(backend) {
-  const frame = backend._frame;
+  const frame = sceneByLayer.get(backend)._frame;
   pendingUpdates.delete(backend);
-  backend._frame = null;
+  sceneByLayer.get(backend)._frame = null;
   if (!pendingUpdates.size && frame != null) {
     cancelAnimationFrame(frame);
   }

package/src/scene/composeLocalTransform.js

@@ -0,0 +1,16 @@
+import { degrees } from '../globals/degrees.js';
+
+export function composeLocalTransform(node) {
+  const matrix = node._localTransform ||= /* alloc */ new DOMMatrix();
+  matrix.m11 = 1, matrix.m12 = 0, matrix.m13 = 0, matrix.m14 = 0;
+  matrix.m21 = 0, matrix.m22 = 1, matrix.m23 = 0, matrix.m24 = 0;
+  matrix.m31 = 0, matrix.m32 = 0, matrix.m33 = 1, matrix.m34 = 0;
+  matrix.m41 = 0, matrix.m42 = 0, matrix.m43 = 0, matrix.m44 = 1;
+  matrix.translateSelf(node.position[0], node.position[1], node.position[2]);
+  // Node rotations use YXZ, as did the previous renderer.
+  matrix.rotateAxisAngleSelf(0, 1, 0, node.rotation[1] * degrees);
+  matrix.rotateAxisAngleSelf(1, 0, 0, node.rotation[0] * degrees);
+  matrix.rotateAxisAngleSelf(0, 0, 1, node.rotation[2] * degrees);
+  matrix.scaleSelf(node.scale[0], node.scale[1], node.scale[2]);
+  return matrix;
+}

package/src/scene/createLayer.js

@@ -0,0 +1,7 @@
+import { L } from '../globals/L.js';
+import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
+
+
+export function createLayer(options = sceneEmptyOptions) {
+  return /* alloc */ new L.Layer(options);
+}

package/src/scene/createSceneCamera.js

@@ -0,0 +1,21 @@
+/** Perspective camera state: fov in degrees, near/far in scene metres. */
+export function createSceneCamera() {
+  return /* alloc */ {
+    position: /* alloc */ [0, 0, 0],
+    up: /* alloc */ [0, 1, 0],
+    target: /* alloc */ [0, 0, 0],
+    x: /* alloc */ [0, 0, 0],
+    y: /* alloc */ [0, 0, 0],
+    z: /* alloc */ [0, 0, 0],
+    viewMatrix: /* alloc */ [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    projectionMatrix: /* alloc */ [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    projectionViewMatrix: /* alloc */ [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    viewTransform: /* alloc */ new DOMMatrix(),
+    projectionTransform: /* alloc */ new DOMMatrix(),
+    projectionViewTransform: /* alloc */ new DOMMatrix(),
+    fov: 45,
+    aspect: 1,
+    near: 0.1,
+    far: 10000,
+  };
+}

package/src/scene/emptyEvents.js

@@ -1,3 +1,3 @@
 export function emptyEvents() {
-  return {};
+  return /* alloc */ {};
 }

package/src/scene/emptyNode.js

@@ -1,11 +1,12 @@
 /** A fresh, empty scene-graph node. */
 export function emptyNode() {
-  return {
-  position: [0, 0, 0],
-  rotation: [0, 0, 0],
-  scale: [1, 1, 1],
-  worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-  children: [],
-  visible: true,
+  return /* alloc */ {
+    position: /* alloc */ [0, 0, 0],
+    rotation: /* alloc */ [0, 0, 0],
+    scale: /* alloc */ [1, 1, 1],
+    worldMatrix: /* alloc */ [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    children: /* alloc */ [],
+    highlightRange: /* alloc */ [0, 0],
+    visible: true,
   };
 }

package/src/scene/endZoom.js

@@ -1,3 +1,8 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+import { mapUpdateCameraOverlays } from '../camera/mapUpdateCameraOverlays.js';
+
 import { update } from './update.js';
 
 /** Stop using the outgoing level after zoomend; the next redraw uses current tiles. */
@@ -5,12 +10,14 @@ import { update } from './update.js';
 export function endZoom() {
   const backend = this;
   let animation;
-  for (animation of backend._zoomTransitions?.keys() || []) animation.finish();
-  backend._zoomTransitions = null;
-  backend._zoomView = null;
-  delete backend._map._cameraView;
+  if (sceneByLayer.get(backend)._zoomTransitions) {
+    for (animation of sceneByLayer.get(backend)._zoomTransitions.keys()) animation.finish();
+  }
+  sceneByLayer.get(backend)._zoomTransitions = null;
+  sceneByLayer.get(backend)._zoomView = null;
+  delete cameraByMap.get(backend._map)._cameraView;
   backend._map.getContainer().classList.remove('leaflet-camera-zoom');
-  backend._map._updateCameraOverlays();
-  backend._zoomLevel = null;
+  mapUpdateCameraOverlays(backend._map);
+  sceneByLayer.get(backend)._zoomLevel = null;
   update(backend);
 }

package/src/scene/failAttachment.js

@@ -1,9 +1,12 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { renderers } from '../globals/renderers.js';
+
+
 import { showWebGPUWarning } from './showWebGPUWarning.js';
-import { cityMapper } from '../constants/cityMapper.js';
 
 export function failAttachment(error, backend, map) {
   showWebGPUWarning(map);
-  backend._rendererReady.reject(error);
-  cityMapper.renderers.delete(map);
+  sceneByLayer.get(backend)._rendererReady.reject(error);
+  renderers.delete(map);
   throw error;
 }

package/src/scene/get3DEvents.js

@@ -1,13 +1,16 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { updateArea } from '../sources/updateArea.js';
 import { onTerrainChange } from '../terrain/onTerrainChange.js';
 
-export function get3DEvents(layer) {
-  const events = {};
-  if (layer.url) {
-    events.moveend = events.zoomend = events.rotate = events.pitch = events.resize = updateArea.bind(null, layer);
-  }
-  if (layer._geojson || layer.url) {
-    events.terrainchange = onTerrainChange.bind(null, layer);
-  }
-  return events;
+export function get3DEvents(layer) {
+  const events = /* alloc */ {};
+  if (sceneByLayer.get(layer).url) {
+    events.moveend = events.zoomend = events.rotate = events.pitch = events.resize = updateArea.bind(null, layer);
+  }
+  if (sceneByLayer.get(layer)._geojson || sceneByLayer.get(layer).url) {
+    events.terrainchange = onTerrainChange.bind(null, layer);
+  }
+  return events;
 }

package/src/scene/getLocation.js

@@ -0,0 +1,7 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+
+export function getLocation(layer) {
+  return sceneByLayer.get(layer)?.location;
+}