leaflet-city-mapper 0.0.2 → 0.0.4

package/src/rendering/textureBinding.js

@@ -0,0 +1,7 @@
+export function textureBinding(bindings, name, enabled) {
+  if (!enabled) return '';
+  const current = 3 + bindings.length * 2;
+  bindings.push(/* alloc */ { name, texture: current, sampler: current + 1 });
+  return /* wgsl */ `@group(0) @binding(${current}) var ${name}: texture_2d<f32>;
+      @group(0) @binding(${current + 1}) var ${name}Sampler: sampler;`;
+}

package/src/rendering/updateMapCamera.js

@@ -0,0 +1,46 @@
+import { radians } from '../globals/radians.js';
+import { cameraFov } from '../globals/cameraFov.js';
+import { earthCirc } from '../globals/earthCirc.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { mapMethods } from '../globals/mapMethods.js';
+import { walkByMap } from '../globals/walkByMap.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+import { updateCamera } from "../scene/updateCamera.js";
+import { getElevation } from "../terrain/getElevation.js";
+
+import { animationPoint } from '../camera/animationPoint.js';
+
+export function updateMapCamera(backend, size) {
+  const map = backend._map;
+  // Match the map's perspective, including the intermediate view of an animated zoom.
+  const zoom = cameraByMap.get(map)._cameraView?.zoom ?? map.getZoom();
+  const pixelsPerMeter = map.options.crs.scale(zoom) / (earthCirc * Math.cos(sceneByLayer.get(backend)._sceneOrigin.lat * radians));
+  const origin = animationPoint(map, mapMethods.value.layerPointToContainerPoint.call(map,
+    map.project(sceneByLayer.get(backend)._sceneOrigin).subtract(map.getPixelOrigin())));
+  const distance = size.y * 1.5 / pixelsPerMeter;
+  const targetX = (size.x / 2 - origin.x) / pixelsPerMeter;
+  // CSS zoom keeps the logical view's ground plane until zoomend.
+  const walker = walkByMap.get(map)?.control?._walk;
+  const targetY = ((cameraByMap.get(map)._terrain3D ? getElevation(cameraByMap.get(map)._terrain3D, map.getCenter()): undefined) ?? 0) +
+    (walker?.saved ? walker.state.height : 0);
+  const targetZ = (size.y / 2 - origin.y) / pixelsPerMeter;
+  const pitch = mapGetPitch(map) * radians;
+  const bearing = mapGetBearing(map) * radians;
+  const camera = sceneByLayer.get(backend).camera;
+  camera.fov = cameraFov;
+  camera.aspect = size.x / size.y;
+  camera.near = Math.max(0.1, distance / 10000);
+  camera.far = Math.max(10000, distance * 10);
+  camera.position[0] = targetX + Math.sin(bearing) * Math.sin(pitch) * distance;
+  camera.position[1] = targetY + Math.cos(pitch) * distance;
+  camera.position[2] = targetZ + Math.cos(bearing) * Math.sin(pitch) * distance;
+  camera.up[0] = -Math.sin(bearing) * Math.cos(pitch);
+  camera.up[1] = Math.sin(pitch);
+  camera.up[2] = -Math.cos(bearing) * Math.cos(pitch);
+  camera.target[0] = targetX; camera.target[1] = targetY; camera.target[2] = targetZ;
+  // Refresh the camera view, projection and combined projection-view matrices.
+  updateCamera(camera);
+}

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

@@ -0,0 +1,25 @@
+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 = sceneByLayer.get(backend)._roofRasters ||= /* alloc */ [];
+  rasters.length = 0;
+  let hasRoofTexture = false;
+  let layer;
+  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 (sceneByLayer.get(layer).kind === 'raster' && sceneByLayer.get(layer)._rasterTiles && layer.options.opacity > 0) rasters.push(layer);
+    }
+    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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +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);
+    sceneByLayer.get(backend)._added.resolve();
+  } catch (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

@@ -0,0 +1,13 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { pendingUpdates } from '../globals/pendingUpdates.js';
+
+
+
+export function cancelUpdate(backend) {
+  const frame = sceneByLayer.get(backend)._frame;
+  pendingUpdates.delete(backend);
+  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

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

package/src/scene/emptyNode.js

@@ -0,0 +1,12 @@
+/** A fresh, empty scene-graph node. */
+export function emptyNode() {
+  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

@@ -0,0 +1,23 @@
+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. */
+
+export function endZoom() {
+  const backend = this;
+  let animation;
+  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');
+  mapUpdateCameraOverlays(backend._map);
+  sceneByLayer.get(backend)._zoomLevel = null;
+  update(backend);
+}

package/src/scene/failAttachment.js

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

package/src/scene/get3DEvents.js

@@ -0,0 +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 = /* 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;
+}

package/src/scene/init3D.js

@@ -0,0 +1,43 @@
+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';
+
+export function init3D(layer, options = sceneEmptyOptions) {
+  sceneByLayer.get(layer)._3d = 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();
+  if (layer.options.center) {
+    sceneByLayer.get(layer).location = /* 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) {
+    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;
+    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);
+}

package/src/scene/initializeLayer.js

@@ -0,0 +1,22 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { reportError } from './reportError.js';
+
+
+export function initializeLayer(task) {
+  const { layer, ready } = task;
+  if (task.error) {
+    reportError(layer, task.error);
+    return Promise.reject(task.error);
+  }
+  try {
+    const map = layer._map;
+    map?.removeLayer(layer);
+    delete sceneByLayer.get(layer).kind;
+    task.initialize(layer, task.settings);
+    map?.addLayer(layer);
+    return sceneByLayer.get(layer).ready === ready ? layer : sceneByLayer.get(layer).ready;
+  } catch (error) {
+    layer.fire('error', /* alloc */ { error });
+    throw error;
+  }
+}

package/src/scene/initializeRendererResources.js

@@ -0,0 +1,35 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { sceneSunlightUniforms } from '../globals/sceneSunlightUniforms.js';
+import { resizeSunlight } from '../shadows/resizeSunlight.js';
+
+export function initializeRendererResources(backend, device) {
+  const layout = device.createBindGroupLayout(/* alloc */ {
+    entries: /* alloc */ [
+      /* alloc */ { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: /* alloc */ { type: 'uniform' } },
+      /* alloc */ { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: /* alloc */ { sampleType: 'depth' } },
+      /* alloc */ { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: /* alloc */ { type: 'comparison' } },
+      /* alloc */ { binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: /* alloc */ { type: 'read-only-storage' } },
+    ]
+  });
+  const buffer = sceneByLayer.get(backend).renderer.device.createBuffer(/* alloc */ { size: 80, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+  const sampler = sceneByLayer.get(backend).renderer.device.createSampler(/* alloc */ { compare: 'less-equal', minFilter: 'linear', magFilter: 'linear' });
+  const lights = sceneByLayer.get(backend).renderer.device.createBuffer(/* alloc */ { size: 32, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+  sceneByLayer.get(backend).renderer.sunlight = /* alloc */ { layout, buffer, sampler, lights, size: 0 };
+  sceneByLayer.get(backend).renderer.device.queue.writeBuffer(buffer, 0, sceneSunlightUniforms);
+  resizeSunlight(backend, 1);
+  const emptyImage = document.createElement('canvas');
+  emptyImage.width = 1;
+  emptyImage.height = 1;
+  sceneByLayer.get(backend).renderer.roofFallbackTexture = /* alloc */ {
+    device,
+    texture: device.createTexture(/* alloc */ {
+      size: /* alloc */ [1, 1],
+      format: 'rgba8unorm',
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+    }),
+    sampler: device.createSampler(/* alloc */ {
+      addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge',
+    }),
+    image: emptyImage, format: 'rgba8unorm', srgb: false, uploaded: null,
+  };
+}

package/src/scene/initializeSharedRenderer.js

@@ -0,0 +1,45 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rendererDevices } from '../globals/rendererDevices.js';
+import { emptyNode } from './emptyNode.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 { createSceneCamera } from './createSceneCamera.js';
+import { initializeRendererResources } from './initializeRendererResources.js';
+import { mountRenderer } from './mountRenderer.js';
+
+export async function initializeSharedRenderer(backend, map) {
+  const canvas = document.createElement('canvas');
+  if (!navigator.gpu) {
+    failAttachment(/* alloc */ new Error('Layer3D requires WebGPU'), backend, map);
+  }
+  const adapter = await requestAdapter(backend, map);
+  const device = await requestDevice(adapter, backend, map);
+  rendererDevices.set(device, map);
+  device.addEventListener('uncapturederror', rendererDeviceError);
+  Promise.all(/* alloc */ [device.lost, Promise.resolve(device)]).then(rendererDeviceLost);
+  const context = canvas.getContext('webgpu');
+  if (!context) {
+    device.destroy();
+    failAttachment(/* alloc */ new Error('Unable to create a WebGPU canvas context'), backend, map);
+  }
+  const format = navigator.gpu.getPreferredCanvasFormat();
+  context.configure(/* alloc */ { device, format, alphaMode: 'premultiplied' });
+  map.getContainer().querySelector('.leaflet-webgpu-warning')?.remove();
+  sceneByLayer.get(backend)._shared = backend;
+  sceneByLayer.get(backend)._layers = /* alloc */ new Set();
+  sceneByLayer.get(backend)._sceneOrigin = sceneByLayer.get(backend).location;
+  sceneByLayer.get(backend).scene = emptyNode();
+  sceneByLayer.get(backend).camera = createSceneCamera();
+  sceneByLayer.get(backend).renderer = /* alloc */ {
+    device,
+    context,
+    format,
+    canvas,
+    dpr: Math.min(window.devicePixelRatio, 2)
+  };
+  initializeRendererResources(backend, device);
+  mountRenderer(backend, map, canvas);
+}

package/src/scene/initializerFor.js

@@ -0,0 +1,16 @@
+import { initializeGeoJSON } from '../sources/initializeGeoJSON.js';
+import { initRaster } from '../raster/initRaster.js';
+import { initTerrain } from '../terrain/initTerrain.js';
+import { initTraffic } from '../traffic/initTraffic.js';
+import { initCog } from '../cog/initCog.js';
+
+export function initializerFor(type) {
+  switch (type) {
+    case 'geojson': return initializeGeoJSON;
+    case 'pmtiles': return initRaster;
+    case 'cog': return initCog;
+    case 'terrain': return initTerrain;
+    case 'traffic': return initTraffic;
+    default: return null;
+  }
+}

package/src/scene/isNativeLayer.js

@@ -0,0 +1,12 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+export function isNativeLayer(layer) {
+  return !sceneByLayer.get(layer)._3d && (
+    layer instanceof L.GridLayer ||
+    layer instanceof L.Polyline ||
+    layer instanceof L.CircleMarker ||
+    layer instanceof L.Marker && !(layer.options.icon instanceof L.DivIcon) ||
+    layer instanceof L.ImageOverlay && !(layer instanceof L.VideoOverlay) && !(layer instanceof L.SVGOverlay)
+  );
+}

package/src/scene/layerCountTitle.js

@@ -0,0 +1,4 @@
+export function layerCountTitle(scene, formatted, pending, error) {
+  return error ? `Unable to load: ${typeof error === 'string' ? error : error.message}` :
+    `${formatted} loaded ${scene.modelUrl ? 'models' : 'elements'} in the current area${pending ? `; ${pending} blocks loading` : ''}`;
+}