leaflet-city-mapper 0.0.4 → 0.0.6

package/src/gpu/mountRenderer.js

@@ -0,0 +1,26 @@
+import { sizeByLayer } from '../weakmaps/sizeByLayer.js';
+
+import { onMapChange } from '../scene/onMapChange.js';
+import { startZoom } from '../animations/startZoom.js';
+import { onZoomAnim } from '../animations/onZoomAnim.js';
+import { endZoom } from '../animations/endZoom.js';
+
+export function mountRenderer(layer, map, canvas) {
+  sizeByLayer.set(layer, 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', layer.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, layer);
+  map.on('zoomstart', startZoom, layer);
+  map.on('zoomanim', onZoomAnim, layer);
+  map.on('zoomend', endZoom, layer);
+}

package/src/{scene → gpu}/releaseRenderer.js

@@ -1,4 +1,4 @@
-export async function releaseRenderer(renderer, backend) {
+export async function releaseRenderer(renderer, layer) {
   try {
     await renderer.device.queue.onSubmittedWorkDone();
     renderer.depthTexture?.destroy();
@@ -8,7 +8,7 @@ export async function releaseRenderer(renderer, backend) {
     renderer.sunlight?.buffer?.destroy();
     renderer.sunlight?.lights?.destroy();
   } catch (error) {
-    backend.fire('error', /* alloc */ { error });
+    layer.fire('error', /* alloc */ { error });
   }
   renderer.device.destroy();
 }

package/src/gpu/rendererDeviceError.js

@@ -0,0 +1,16 @@
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
+import { rendererDevices } from '../weakmaps/rendererDevices.js';
+import { renderers } from '../weakmaps/renderers.js';
+
+
+
+export function rendererDeviceError(event) {
+  const map = rendererDevices.get(event.currentTarget);
+  const owner = renderers.get(map);
+  if (rendererByLayer.get(owner)?.device !== event.currentTarget) return;
+  if (!layersByLayer.get(owner)) return;
+  let layer;
+  for (layer of layersByLayer.get(owner)) layer.fire('error', /* alloc */ { error: event.error });
+}

package/src/gpu/rendererDeviceLost.js

@@ -0,0 +1,16 @@
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
+import { rendererDevices } from '../weakmaps/rendererDevices.js';
+import { renderers } from '../weakmaps/renderers.js';
+
+
+
+export function rendererDeviceLost([info, device]) {
+  const map = rendererDevices.get(device);
+  const owner = renderers.get(map);
+  if (!owner || rendererByLayer.get(owner)?.device !== device) return;
+  const error = /* alloc */ new Error(`WebGPU device lost: ${info.message || info.reason}`);
+  let layer;
+  for (layer of layersByLayer.get(owner)) layer.fire('error', /* alloc */ { error });
+}

package/src/{rendering/reportCompilation.js → gpu/reportShaderCompilation.js}

@@ -1,4 +1,4 @@
-export async function reportCompilation(backend, pending) {
+export async function reportCompilation(layer, pending) {
   let info, message;
   try {
     const infos = await Promise.all(pending);
@@ -7,11 +7,11 @@ export async function reportCompilation(backend, pending) {
       for (message of info.messages) if (message.type === 'error') errors += `${errorCount++ ? '\n' : ''}${message.message}`;
     }
     if (errorCount) {
-      backend.fire('error', /* alloc */ {
+      layer.fire('error', /* alloc */ {
         error: /* alloc */ new Error(`Unable to compile Layer3D WGSL: ${errors}`),
       });
     }
   } catch (error) {
-    backend.fire('error', /* alloc */ { error });
+    layer.fire('error', /* alloc */ { error });
   }
 }

package/src/gpu/requestAdapter.js

@@ -0,0 +1,12 @@
+import { failAttachment } from '../scene/failAttachment.js';
+
+export async function requestAdapter(layer, map) {
+  let adapter;
+  try {
+    adapter = await navigator.gpu.requestAdapter();
+  } catch (error) {
+    failAttachment(error, layer, map);
+  }
+  if (!adapter) failAttachment(/* alloc */ new Error('Unable to acquire a WebGPU adapter'), layer, map);
+  return adapter;
+}

package/src/gpu/requestDevice.js

@@ -0,0 +1,9 @@
+import { failAttachment } from '../scene/failAttachment.js';
+
+export async function requestDevice(adapter, layer, map) {
+  try {
+    return await adapter.requestDevice();
+  } catch (error) {
+    failAttachment(error, layer, map);
+  }
+}

package/src/index.js

@@ -5,7 +5,7 @@ import { removeLayer as sharedRemoveLayer } from './globals/removeLayer.js';
 
 import './camera/mapCamera.js';
 import { init3D } from './scene/init3D.js';
-import { initNativeGPU } from './core/initNativeGPU.js';
+import { initNativeGPU } from './native/initNativeGPU.js';
 import { initRaster } from './raster/initRaster.js';
 import { setGeoJSONData } from './sources/setGeoJSONData.js';
 import { initTerrain } from './terrain/initTerrain.js';
@@ -14,7 +14,7 @@ import { initTraffic } from './traffic/initTraffic.js';
 import './walk/initWalk.js';
 
 import { initializeNativeLayer } from './core/initializeNativeLayer.js';
-import { layerLayerAdd } from './scene/layerLayerAdd.js';
+import { layerLayerAdd } from './scene/addRegisteredLayer.js';
 import { layerInitialize } from './scene/layerInitialize.js';
 import { removeLayer } from './core/removeLayer.js';
 import { getPitch } from './camera/getPitch.js';
@@ -32,16 +32,11 @@ import { layerCallInitHooks } from './core/layerCallInitHooks.js';
  * It initializes a native instance from the bundled source modules;
  * types receive flat options (`{ ...source, pane, attribution }`); plugin state remains external.
  *
- * Folder layout:
- * - scene/: source routing, lifecycle and graph; initializers live in their domain folders.
- * - core/: Leaflet layer integration; camera/ and controls/: camera and interaction.
- * - sources/ and picking/: source geometry and feature interaction.
- * - rendering/, shaders/, shadows/ and lighting/: WebGPU drawing and illumination.
- * - geometry/, triangulation/ and collision/: mesh operations and spatial queries.
- * - models/, archives/ and raster/: glTF loading, archive access and raster tiles.
- * - globals/: one shared value per module, imported directly by its consumers.
- * - terrain/, sunlight/, traffic/ and walk/: feature-specific operations.
- *   Operations receive the layer explicitly, without subclasses or prototype replacement.
+ * Source folders are flat and grouped by responsibility; see README's source layout.
+ * Initializers and orchestration stay in their domain folders; shared geometry,
+ * projections, transforms, textures and animations have dedicated folders.
+ * Shared values live in globals/, private WeakMaps in weakmaps/.
+ * Operations receive the layer explicitly, without subclasses or prototype replacement.
  * Dataset-specific code and data (routes, timetables, API loaders) belong to the application, e.g. misc/.
  *
  * When `type` is omitted, inline FeatureCollections use 'geojson'; *.pmtiles URLs use
@@ -102,7 +97,7 @@ sharedLayerCallInitHooks.value = L.Layer.prototype.callInitHooks;
  * @property {number} [skipped] Features skipped by style.
  * @property {string} [error] Failed load/build message.
  *
- * @param {L.Layer} backend
+ * @param {L.Layer} layer
  * @param {Layer3DOptions} [options] World origin comes from center or the first map centre.
  */
 

package/src/layer-controls/layerCountTitle.js

@@ -0,0 +1,6 @@
+import { modelUrlByLayer } from '../weakmaps/modelUrlByLayer.js';
+
+export function layerCountTitle(layer, formatted, pending, error) {
+  return error ? `Unable to load: ${typeof error === 'string' ? error : error.message}` :
+    `${formatted} loaded ${modelUrlByLayer.get(layer) ? 'models' : 'elements'} in the current area${pending ? `; ${pending} blocks loading` : ''}`;
+}

package/src/layer-controls/renderLayerCount.js

@@ -0,0 +1,20 @@
+import { countStatusByLayer } from '../weakmaps/countStatusByLayer.js';
+import { modelUrlByLayer } from '../weakmaps/modelUrlByLayer.js';
+import { modelByLayer } from '../weakmaps/modelByLayer.js';
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+
+export function renderLayerCount(layer, count, pending, error) {
+  const status = countStatusByLayer.get(layer);
+  const modelUrl = modelUrlByLayer.get(layer), model = modelByLayer.get(layer);
+  if (modelUrl) count = model ? 1 : 0;
+  const loading = pending || (modelUrl ? !model : !headerByLayer.get(layer) && !geojsonByLayer.get(layer));
+  const formatted = count.toLocaleString('en-US');
+  const text = error ? 'Error' : `${formatted}${loading ? '…' : ''}`;
+  const title = layerCountTitle(layer, formatted, pending, error);
+  if (status.textContent !== text) status.textContent = text;
+  if (status.title !== title) status.title = title;
+  if (error && status.getAttribute('role') !== 'alert') status.setAttribute('role', 'alert');
+  else if (!error && status.hasAttribute('role')) status.removeAttribute('role');
+}
+import { layerCountTitle } from './layerCountTitle.js';

package/src/{scene → layer-controls}/updateLayerCount.js

@@ -1,22 +1,24 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { underEntry } from './underEntry.js';
-import { renderLayerCount } from './renderLayerCount.js';
-
-export function updateLayerCount(event) {
-  const layer = event.target, scene = sceneByLayer.get(layer), status = scene._countStatus;
-  if (!layer._map) return;
-  if (event.type === 'add') underEntry(layer, status);
-  let count = 0, pending = 0, error = event.error, area;
-  if (Number.isFinite(event.loaded)) {
-    count = event.loaded;
-    pending = event.pending ?? 0;
-    error ||= event.errors?.[0];
-  } else {
-    for (area of scene._areas.values()) {
-      count += area.buildings ?? 0;
-      if (!area.done && !area.error) pending++;
-      error ||= area.error;
-    }
-  }
-  renderLayerCount(scene, count, pending, error);
-}
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+import { countStatusByLayer } from '../weakmaps/countStatusByLayer.js';
+
+import { underEntry } from './underEntry.js';
+import { renderLayerCount } from './renderLayerCount.js';
+
+export function updateLayerCount(event) {
+  const layer = event.target, status = countStatusByLayer.get(layer)
+  if (!layer._map) return;
+  if (event.type === 'add') underEntry(layer, status);
+  let count = 0, pending = 0, error = event.error, area;
+  if (Number.isFinite(event.loaded)) {
+    count = event.loaded;
+    pending = event.pending ?? 0;
+    error ||= event.errors?.[0];
+  } else {
+    for (area of areasByLayer.get(layer).values()) {
+      count += area.buildings ?? 0;
+      if (!area.done && !area.error) pending++;
+      error ||= area.error;
+    }
+  }
+  renderLayerCount(layer, count, pending, error);
+}

package/src/lighting/lightGrid.js

@@ -1,4 +1,4 @@
-import { visitCells } from './visitCells.js';
+import { visitCells } from './visitLightGridCells.js';
 
 /** Pack world-space point lights into the shader's spatial grid. */
 export function lightGrid(packed, maxBytes) {

package/src/lighting/updatePointLights.js

@@ -1,19 +1,22 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
 
 
-import { destroyTexture } from '../rendering/destroyTexture.js';
+
+import { destroyTexture } from '../textures/destroyTexture.js';
 import { bindSunlight } from '../shadows/bindSunlight.js';
 import { cacheLightGrid } from './cacheLightGrid.js';
 import { collectLightMeshes } from './collectLightMeshes.js';
 
-export function updatePointLights(backend) {
-  const { device, sunlight: sun } = sceneByLayer.get(backend).renderer;
+export function updatePointLights(layer) {
+  const { device, sunlight: sun } = rendererByLayer.get(layer);
   const fixed = /* alloc */ [];
   const moving = /* alloc */ [];
-  let layer;
-  for (layer of sceneByLayer.get(backend)._layers) {
-    if (!layer.options.nightLight || !sceneByLayer.get(layer).root.visible) continue;
-    collectLightMeshes(sceneByLayer.get(layer).root, fixed, moving);
+  let sceneLayer;
+  for (sceneLayer of layersByLayer.get(layer)) {
+    if (!sceneLayer.options.nightLight || !rootByLayer.get(sceneLayer).visible) continue;
+    collectLightMeshes(rootByLayer.get(sceneLayer), fixed, moving);
   }
   const maxBytes = device.limits.maxStorageBufferBindingSize;
   const staticGrid = cacheLightGrid(fixed, sun.staticLightGrid, maxBytes);
@@ -23,9 +26,9 @@ export function updatePointLights(backend) {
   if (size > maxBytes) throw /* alloc */ new Error('Streetlight grid exceeds GPU storage limit');
   let uploadStatic = staticGrid !== sun.staticLightGrid;
   if (sun.lights.size < size) {
-    destroyTexture(backend, sun.lights);
+    destroyTexture(layer, sun.lights);
     sun.lights = device.createBuffer(/* alloc */ { size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
-    bindSunlight(backend);
+    bindSunlight(layer);
     uploadStatic = true;
   }
   // The spare header component points to a second grid in the same storage binding.

package/src/{rendering → materials}/createProgram.js

@@ -1,9 +1,10 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
 import { defaultMaterial } from '../globals/defaultMaterial.js';
 import { vertexShader } from '../globals/vertexShader.js';
 import { fragmentShader } from '../globals/fragmentShader.js';
 import { pipelineLayout as sharedPipelineLayout } from '../globals/pipelineLayout.js';
 import { elevationWGSL } from '../globals/elevationWGSL.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { positionLayout } from '../globals/positionLayout.js';
 import { normalLayout } from '../globals/normalLayout.js';
 import { colorLayout } from '../globals/colorLayout.js';
@@ -15,25 +16,25 @@ import { createProgramUniforms } from './createProgramUniforms.js';
 
 import { materialShaders } from '../shaders/materialShaders.js';
 
-import { reportCompilation } from './reportCompilation.js';
+import { reportCompilation } from '../gpu/reportShaderCompilation.js';
 
-export function createProgram(backend, material = defaultMaterial) {
+export function createProgram(layer, material = defaultMaterial) {
   const shaders = materialShaders(
     material,
-    !!backend.options.nightSparkle,
+    !!layer.options.nightSparkle,
     material.terrain ? elevationWGSL : ''
   );
-  const vertex = sceneByLayer.get(backend).renderer.device.createShaderModule((
+  const vertex = rendererByLayer.get(layer).device.createShaderModule((
     vertexShader.code = shaders.vertex,
     vertexShader
   ));
   vertexShader.code = null;
-  const fragment = sceneByLayer.get(backend).renderer.device.createShaderModule((
+  const fragment = rendererByLayer.get(layer).device.createShaderModule((
     fragmentShader.code = shaders.fragment,
     fragmentShader
   ));
   fragmentShader.code = null;
-  reportCompilation(backend, /* alloc */ [
+  reportCompilation(layer, /* alloc */ [
     vertex.getCompilationInfo(),
     fragment.getCompilationInfo()
   ]);
@@ -44,17 +45,17 @@ export function createProgram(backend, material = defaultMaterial) {
     shaders.textured ? uVLayout : null,
   ];
   if (material.instanced) vertexBuffers.push(instanceLayout);
-  const bindGroupLayout = createProgramLayout(sceneByLayer.get(backend).renderer.device, shaders);
-  const pipelineLayout = sceneByLayer.get(backend).renderer.device.createPipelineLayout((
+  const bindGroupLayout = createProgramLayout(rendererByLayer.get(layer).device, shaders);
+  const pipelineLayout = rendererByLayer.get(layer).device.createPipelineLayout((
     sharedPipelineLayout.bindGroupLayouts[0] = bindGroupLayout,
-    sharedPipelineLayout.bindGroupLayouts[1] = sceneByLayer.get(backend).renderer.sunlight.layout,
+    sharedPipelineLayout.bindGroupLayouts[1] = rendererByLayer.get(layer).sunlight.layout,
     sharedPipelineLayout
   ));
   sharedPipelineLayout.bindGroupLayouts[0] = null;
   sharedPipelineLayout.bindGroupLayouts[1] = null;
   const uniforms = createProgramUniforms(material);
   return /* alloc */ {
-    device: sceneByLayer.get(backend).renderer.device,
+    device: rendererByLayer.get(layer).device,
     vertex,
     fragment,
     bindings: shaders.bindings,
@@ -68,7 +69,7 @@ export function createProgram(backend, material = defaultMaterial) {
     depthTest: material.depthTest !== false,
     terrain: material.terrain,
     nightLight: Boolean(material.nightLight),
-    nightSparkle: !!backend.options.nightSparkle,
+    nightSparkle: !!layer.options.nightSparkle,
     uniforms,
     _layerMaterial: material,
   };

package/src/{models/materialFor.js → materials/modelMaterialFor.js}

@@ -1,7 +1,7 @@
-import { textureFor } from './textureFor.js';
+import { textureFor } from '../textures/modelTextureFor.js';
 
 export function materialFor(context, material) {
-  const { backend } = context;
+  const { backend: layer } = context;
   const pbr = material.pbrMetallicRoughness;
   return /* alloc */ {
     color: pbr?.baseColorFactor ? pbr.baseColorFactor.slice(0, 3) : /* alloc */ [1, 1, 1],
@@ -14,7 +14,7 @@ export function materialFor(context, material) {
     occlusionTexture: textureFor(context, material.occlusionTexture),
     emissive: material.emissiveFactor || /* alloc */ [0, 0, 0],
     occlusionStrength: material.occlusionTexture?.strength ?? 1,
-    alphaMode: backend.options.alphaMode || material.alphaMode || 'OPAQUE',
+    alphaMode: layer.options.alphaMode || material.alphaMode || 'OPAQUE',
     alphaCutoff: material.alphaCutoff ?? 0.5,
     doubleSided: material.doubleSided,
   };

package/src/materials/terrainRasterProgram.js

@@ -0,0 +1,58 @@
+import { demByLayer } from '../weakmaps/demByLayer.js';
+import { rasterProgramByLayer } from '../weakmaps/rasterProgramByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { terrainBoundsByLayer } from '../weakmaps/terrainBoundsByLayer.js';
+import { terrainGridsByLayer } from '../weakmaps/terrainGridsByLayer.js';
+import { terrainOriginElevationByLayer } from '../weakmaps/terrainOriginElevationByLayer.js';
+import { terrainTilesByLayer } from '../weakmaps/terrainTilesByLayer.js';
+
+import { demTexture } from '../globals/demTexture.js';
+import { demTarget } from '../globals/demTarget.js';
+import { demLayout } from '../globals/demLayout.js';
+import { demSize } from '../globals/demSize.js';
+import { createProgram } from './createProgram.js';
+import { destroyTexture } from '../textures/destroyTexture.js';
+import { terrainAtlas } from '../terrain/terrainAtlas.js';
+
+export function rasterProgram(layer, texture) {
+  const device = rendererByLayer.get(layer).device
+  if (rasterProgramByLayer.get(layer)?.device === device) return rasterProgramByLayer.get(layer);
+  // DEM atlas over the archive's tile grid; invalid or missing samples become -1e9 (the shader's no-data).
+  // ponytail: one texture, capped by maxTextureDimension2D (32x32 DEM tiles at 8192 px); split it for larger archives.
+  const bounds = terrainBoundsByLayer.get(layer), columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
+  const { elevations, low, high } = terrainAtlas(terrainTilesByLayer.get(layer), bounds);
+  if (demByLayer.get(layer)) destroyTexture(layer, demByLayer.get(layer).texture);
+  demByLayer.set(layer, /* alloc */ {
+    texture: device.createTexture((
+      demTexture.size[0] = columns * 256,
+      demTexture.size[1] = rows * 256,
+      demTexture.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+      demTexture
+    )),
+    low: Number.isFinite(low) ? low : terrainOriginElevationByLayer.get(layer),
+    high: Number.isFinite(high) ? high : terrainOriginElevationByLayer.get(layer),
+  });
+  device.queue.writeTexture((
+    demTarget.texture = demByLayer.get(layer).texture,
+    demTarget
+  ), elevations,
+    (
+      demLayout.bytesPerRow = columns * 1024,
+      demLayout
+    ), (
+      demSize[0] = columns * 256,
+      demSize[1] = rows * 256,
+      demSize
+    ));
+  demTarget.texture = null;
+  terrainGridsByLayer.set(layer, /* alloc */ new Map());
+  rasterProgramByLayer.set(layer, createProgram(layer, /* alloc */ {
+    baseTexture: texture,
+    unlit: true,
+    terrain: demByLayer.get(layer),
+    alphaMode: 'BLEND',
+    depthWrite: true,
+    doubleSided: layer.options.doubleSided,
+  }));
+  return rasterProgramByLayer.get(layer);
+}

package/src/models/applyModelTransform.js

@@ -1,13 +1,14 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { modelByLayer } from '../weakmaps/modelByLayer.js';
+
 
-export function applyModelTransform(backend) {
-  const model = sceneByLayer.get(backend).model;
-  if (backend.options.rotation) {
-    const [x, y = x, z = x] = backend.options.rotation;
+export function applyModelTransform(layer) {
+  const model = modelByLayer.get(layer);
+  if (layer.options.rotation) {
+    const [x, y = x, z = x] = layer.options.rotation;
     model.rotation[0] = x; model.rotation[1] = y; model.rotation[2] = z;
   }
-  if (backend.options.scale) {
-    const [x, y = x, z = x] = backend.options.scale;
+  if (layer.options.scale) {
+    const [x, y = x, z = x] = layer.options.scale;
     model.scale[0] = x; model.scale[1] = y; model.scale[2] = z;
   }
 }

package/src/models/createModelContext.js

@@ -1,9 +1,9 @@
 import { geometryEmpty } from '../globals/geometryEmpty.js';
-import { materialFor } from './materialFor.js';
+import { materialFor } from '../materials/modelMaterialFor.js';
 
-export function createModelContext(backend, description, images) {
+export function createModelContext(layer, description, images) {
   const context = /* alloc */ {
-    backend, description, images,
+    backend: layer, description, images,
     textures: /* alloc */ new Map(),
     materials: /* alloc */ [],
     active: /* alloc */ new Set(),

package/src/models/loadModel.js

@@ -1,9 +1,14 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { modelByLayer } from '../weakmaps/modelByLayer.js';
+import { modelUrlByLayer } from '../weakmaps/modelUrlByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+
+
 
 import { decodeModel } from './decodeModel.js';
 import { setParent } from '../scene/setParent.js';
-import { emptyNode } from '../scene/emptyNode.js';
+import { emptyNode } from '../scene/createSceneNode.js';
 import { conformModelToTerrain } from '../geometry/conformModelToTerrain.js';
 import { loadModelResources } from './loadModelResources.js';
 import { createModelContext } from './createModelContext.js';
@@ -14,9 +19,9 @@ import { applyModelTransform } from './applyModelTransform.js';
 /** glTF/GLB model loading. */
 /** Load the configured GLB/glTF (static triangles) under `root`; GPU resources need attachment. */
 
-export async function loadModel(backend) {
-  await sceneByLayer.get(backend)._added.promise;
-  const url = /* alloc */ new URL(sceneByLayer.get(backend).modelUrl, document.baseURI).href;
+export async function loadModel(layer) {
+  await addedByLayer.get(layer).promise;
+  const url = /* alloc */ new URL(modelUrlByLayer.get(layer), document.baseURI).href;
   const response = await fetch(url);
   if (!response.ok) {
     throw /* alloc */ new Error(`Unable to load model: HTTP ${response.status}`);
@@ -24,8 +29,8 @@ export async function loadModel(backend) {
   const data = await response.arrayBuffer();
   const description = decodeModel(data);
   const directory = /* alloc */ new URL('.', url).href;
-  const images = await loadModelResources(backend, description, directory);
-  const context = createModelContext(backend, description, images);
+  const images = await loadModelResources(layer, description, directory);
+  const context = createModelContext(layer, description, images);
   const scene = description.scenes?.[description.scene || 0];
   if (!scene) throw /* alloc */ new Error('Missing glTF scene');
   const nodes = buildModelNodes(context, scene);
@@ -37,8 +42,8 @@ export async function loadModel(backend) {
   if (!nodes.length) throw /* alloc */ new Error('Expected a glTF model with a non-empty scene');
   let node;
   for (node of nodes) setParent(node, model);
-  sceneByLayer.get(backend).model = model;
-  applyModelTransform(backend);
-  setParent(sceneByLayer.get(backend).model, sceneByLayer.get(backend).root);
-  conformModelToTerrain(backend, cameraByMap.get(backend._map)?._terrain3D);
+  modelByLayer.set(layer, model);
+  applyModelTransform(layer);
+  setParent(modelByLayer.get(layer), rootByLayer.get(layer));
+  conformModelToTerrain(layer, terrain3DByMap.get(layer._map));
 }

package/src/models/loadModelResources.js

@@ -1,19 +1,20 @@
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+
 import { geometryEmpty } from '../globals/geometryEmpty.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { loadBuffer } from './loadBuffer.js';
-import { loadImage } from './loadImage.js';
+import { loadImage } from '../textures/loadModelImage.js';
 
-export async function loadModelResources(backend, description, directory) {
+export async function loadModelResources(layer, description, directory) {
   const bufferRequests = /* alloc */ [];
   let buffer;
   for (buffer of description.buffers || geometryEmpty) bufferRequests.push(loadBuffer(buffer, directory));
   await Promise.all(bufferRequests);
-  await sceneByLayer.get(backend)._added.promise;
+  await addedByLayer.get(layer).promise;
   const imageRequests = /* alloc */ [];
   let image;
   for (image of description.images || geometryEmpty) imageRequests.push(loadImage(description, directory, image));
   const images = await Promise.all(imageRequests);
-  await sceneByLayer.get(cameraByMap.get(backend._map)?._terrain3D)?._terrainPromise;
+  await cameraViewByMap.get(layer._map);
   return images;
 }

package/src/models/modelNode.js

@@ -1,16 +1,15 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { nextId } from '../globals/nextId.js';
 import { geometryEmpty } from '../globals/geometryEmpty.js';
 
-import { emptyNode } from '../scene/emptyNode.js';
-import { nodeMatrix } from './nodeMatrix.js';
+import { emptyNode } from '../scene/createSceneNode.js';
+import { nodeMatrix } from '../transforms/modelNodeMatrix.js';
 import { setParent } from '../scene/setParent.js';
 import { readModelAttributes } from './readModelAttributes.js';
 import { readModelIndices } from './readModelIndices.js';
-import { createModelGeometry } from './createModelGeometry.js';
+import { createModelGeometry } from '../geometry/createModelGeometry.js';
 
 export function modelNode(context, index) {
-  const { backend, description, active } = context;
+  const { backend: layer, description, active } = context;
   // Track only the recursion path: shared mesh references are valid, cycles are not.
   if (active.has(index)) throw /* alloc */ new Error('Cyclic glTF nodes');
   const spec = description.nodes[index];