leaflet-city-mapper 0.0.4 → 0.0.6

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

package/src/scene/scheduleSceneUpdate.js

@@ -0,0 +1,25 @@
+import { frameByLayer } from '../weakmaps/frameByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
+import { pendingUpdates } from '../globals/pendingUpdates.js';
+
+
+import { render } from "../rendering/render.js";
+
+import { renderPendingUpdates } from './renderPendingUpdates.js';
+
+/** Scene graph, shared camera and frame rendering. */
+/** Content changes: render once on the next animation frame. */
+export function update(layer) {
+  const shared = sharedByLayer.get(layer);
+  if (!shared) return layer;
+  if (shared !== layer) {
+    update(shared);
+    return layer;
+  }
+  if (frameByLayer.get(layer) != null) return layer;
+  const first = pendingUpdates.values().next().value;
+  pendingUpdates.add(layer);
+  frameByLayer.set(layer, first ? frameByLayer.get(first) : requestAnimationFrame(renderPendingUpdates));
+  return layer;
+}

package/src/shaders/materialShaders.js

@@ -1,6 +1,6 @@
 import { defaultMaterial } from '../globals/defaultMaterial.js';
-import { textureBinding } from '../rendering/textureBinding.js';
-import { validateRoofMaterial } from './validateRoofMaterial.js';
+import { textureBinding } from '../textures/textureBinding.js';
+import { validateRoofMaterial } from '../materials/validateRoofMaterial.js';
 import { materialVertexShader } from './materialVertexShader.js';
 import { materialSurfaceShader } from './materialSurfaceShader.js';
 

package/src/shadows/bindSunlight.js

@@ -1,11 +1,12 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
 import { sunBindGroup } from '../globals/sunBindGroup.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 
 export function bindSunlight(layer) {
-  const sun = sceneByLayer.get(layer).renderer.sunlight;
-  sun.bindGroup = sceneByLayer.get(layer).renderer.device.createBindGroup((
+  const sun = rendererByLayer.get(layer).sunlight;
+  sun.bindGroup = rendererByLayer.get(layer).device.createBindGroup((
     sunBindGroup.layout = sun.layout,
     sunBindGroup.entries[0].resource.buffer = sun.buffer,
     sunBindGroup.entries[1].resource = sun.texture.createView(),

package/src/shadows/drawShadowMeshes.js

@@ -1,11 +1,12 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
 import { shadowPass } from '../globals/shadowPass.js';
 import { shadowBindGroup } from '../globals/shadowBindGroup.js';
 import { shadowOffsets } from '../globals/shadowOffsets.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
-export function drawShadowMeshes(backend, encoder, meshes) {
-  const renderer = sceneByLayer.get(backend).renderer, device = renderer.device, sun = renderer.sunlight;
+export function drawShadowMeshes(layer, encoder, meshes) {
+  const renderer = rendererByLayer.get(layer), device = renderer.device, sun = renderer.sunlight;
   const pass = encoder.beginRenderPass((
     shadowPass.depthStencilAttachment.view = sun.texture.createView(),
     shadowPass

package/src/shadows/renderSunlight.js

@@ -1,4 +1,5 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
 import { disabledShadow } from '../globals/disabledShadow.js';
 import { shadowValues } from '../globals/shadowValues.js';
 
@@ -10,8 +11,8 @@ import { resizeSunlight } from './resizeSunlight.js';
 
 /** One shared directional depth map. Off-screen but loaded geometry can cast shadows. */
 
-export function renderSunlight(backend, encoder, meshes, sunlight) {
-  const renderer = sceneByLayer.get(backend).renderer, device = renderer.device, sun = renderer.sunlight;
+export function renderSunlight(layer, encoder, meshes, sunlight) {
+  const renderer = rendererByLayer.get(layer), device = renderer.device, sun = renderer.sunlight;
   if (!meshes.length || !sunlight || sunlight.altitude < 3) {
     if (!sun.enabled) return;
     device.queue.writeBuffer(sun.buffer, 0, disabledShadow);
@@ -22,7 +23,7 @@ export function renderSunlight(backend, encoder, meshes, sunlight) {
   if (shadowCacheMatches(sun, meshes, sunlight)) return;
   const values = shadowValues;
   sun.enabled = true;
-  resizeSunlight(backend, Math.min(2048, device.limits.maxTextureDimension2D));
+  resizeSunlight(layer, Math.min(2048, device.limits.maxTextureDimension2D));
   values.set(shadowMatrix(meshes, sunlight));
   values[16] = 1;
   device.queue.writeBuffer(sun.buffer, 0, values);
@@ -34,7 +35,7 @@ export function renderSunlight(backend, encoder, meshes, sunlight) {
       break;
     }
   }
-  drawShadowMeshes(backend, encoder, meshes);
+  drawShadowMeshes(layer, encoder, meshes);
   const snapshots = /* alloc */ new Map();
   let mesh2;
   for (mesh2 of meshes) {

package/src/shadows/resizeSunlight.js

@@ -1,14 +1,15 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
 import { shadowTexture } from '../globals/shadowTexture.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 import { bindSunlight } from './bindSunlight.js';
-import { destroyTexture } from '../rendering/destroyTexture.js';
+import { destroyTexture } from '../textures/destroyTexture.js';
 
-export function resizeSunlight(backend, size) {
-  const device = sceneByLayer.get(backend).renderer.device, sun = sceneByLayer.get(backend).renderer.sunlight;
+export function resizeSunlight(layer, size) {
+  const device = rendererByLayer.get(layer).device, sun = rendererByLayer.get(layer).sunlight;
   if (sun.size === size) return;
-  if (sun.texture) destroyTexture(backend, sun.texture);
+  if (sun.texture) destroyTexture(layer, sun.texture);
   sun.size = size;
   sun.texture = device.createTexture((
     shadowTexture.size[0] = size,
@@ -17,5 +18,5 @@ export function resizeSunlight(backend, size) {
     shadowTexture
   ));
 
-  bindSunlight(backend);
+  bindSunlight(layer);
 }

package/src/shadows/shadowMatrix.js

@@ -3,8 +3,8 @@ import { shadowCamera } from '../globals/shadowCamera.js';
 import { shadowLow } from '../globals/shadowLow.js';
 import { shadowHigh } from '../globals/shadowHigh.js';
 
-import { shadowBounds } from './shadowBounds.js';
-import { updateCamera } from '../scene/updateCamera.js';
+import { shadowBounds } from '../geometry/shadowBounds.js';
+import { updateCamera } from '../camera/updateSceneCamera.js';
 
 export function shadowMatrix(meshes, sunlight) {
   const { min, max } = shadowBounds(meshes, sharedShadowBounds);

package/src/sources/attachAreaMesh.js

@@ -1,29 +1,33 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
 import { nextId } from '../globals/nextId.js';
 
 
-import { emptyNode } from '../scene/emptyNode.js';
-import { createProgram } from '../rendering/createProgram.js';
+import { emptyNode } from '../scene/createSceneNode.js';
+import { createProgram } from '../materials/createProgram.js';
 
 import { setParent } from '../scene/setParent.js';
-import { update } from '../scene/update.js';
-import { instanceAreaGeometry } from './instanceAreaGeometry.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
+import { instanceAreaGeometry } from '../geometry/instanceAreaGeometry.js';
 
 export function attachAreaMesh(context) {
-  const { backend, area } = context;
+  const { backend: layer, area } = context;
   if (!context.positions.length) {
     area.mesh = null, area.buildings = 0, area.skipped = context.skipped, area.done = true;
     return;
   }
-  const device = sceneByLayer.get(backend).renderer.device;
-  const data = instanceAreaGeometry(context);
+  const device = rendererByLayer.get(layer).device;
+  const data = context.preparedGeometry || instanceAreaGeometry(context);
   const attributes = /* alloc */ {
-    position: /* alloc */ { size: 3, data: /* alloc */ new Float32Array(data.positions) },
-    normal: /* alloc */ { size: 3, data: /* alloc */ new Float32Array(data.normals) },
-    color: /* alloc */ { size: 3, data: /* alloc */ new Float32Array(data.colors) },
+    position: /* alloc */ { size: 3, data: data.positions instanceof Float32Array ? data.positions : /* alloc */ new Float32Array(data.positions) },
+    normal: /* alloc */ { size: 3, data: data.normals instanceof Float32Array ? data.normals : /* alloc */ new Float32Array(data.normals) },
+    color: /* alloc */ { size: 3, data: data.colors instanceof Float32Array ? data.colors : /* alloc */ new Float32Array(data.colors) },
   };
   if (data.instanceOffsets) attributes.instanceOffset = /* alloc */ { size: 4, data: data.instanceOffsets };
-  if (backend.options.nightLight) attributes.uv = /* alloc */ { size: 2, data: /* alloc */ new Float32Array(context.uvs) };
+  if (layer.options.nightLight) attributes.uv = /* alloc */ {
+    size: 2, data: context.uvs instanceof Float32Array ? context.uvs : /* alloc */ new Float32Array(context.uvs),
+  };
   let name, attribute;
   for (name in attributes) {
     attribute = attributes[name];
@@ -36,6 +40,7 @@ export function attachAreaMesh(context) {
   }
   const meshGeometry = /* alloc */ {
     device,
+    bounds: data.bounds,
     attributes,
     drawRange: /* alloc */ { start: 0, count: attributes.position.count },
   };
@@ -43,13 +48,13 @@ export function attachAreaMesh(context) {
       ...emptyNode(),
       device,
       geometry: meshGeometry,
-      program: createProgram(backend, /* alloc */ {
+      program: createProgram(layer, /* alloc */ {
         instanced: Boolean(data.instanceOffsets),
-        vertexColors: true, roofTexture: backend.options.roofTexture,
-        wallTexture: backend.options.wallTexture,
-        nightLight: Boolean(backend.options.nightLight),
-        alphaMode: backend.options.nightLight ? 'BLEND' : undefined,
-        doubleSided: Boolean(backend.options.nightLight),
+        vertexColors: true, roofTexture: layer.options.roofTexture,
+        wallTexture: layer.options.wallTexture,
+        nightLight: Boolean(layer.options.nightLight),
+        alphaMode: layer.options.nightLight ? 'BLEND' : undefined,
+        doubleSided: Boolean(layer.options.nightLight),
       }),
       id: nextId.value++,
       renderOrder: 0,
@@ -59,6 +64,6 @@ export function attachAreaMesh(context) {
   area.buildings = context.featureFaces.length;
   area.skipped = context.skipped;
   area.done = true;
-  setParent(area.mesh, sceneByLayer.get(backend).root);
-  update(backend);
+  setParent(area.mesh, rootByLayer.get(layer));
+  update(layer);
 }

package/src/sources/buildArea.js

@@ -1,46 +1,45 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { inflightByLayer } from '../weakmaps/inflightByLayer.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
 
 
-import { buildAreaFeature } from './buildAreaFeature.js';
 import { attachAreaMesh } from './attachAreaMesh.js';
 import { loadSource } from '../archives/loadSource.js';
 import { sourceAreaContext } from './sourceAreaContext.js';
-import { pump } from './pump.js';
+import { pump } from './pumpSourceAreas.js';
+import { buildAreaInWorker } from '../workers/buildAreaInWorker.js';
+import { buildAreaFeatures } from './buildAreaFeatures.js';
 
-export async function buildArea(backend, area, map) {
-  let feature;
+export async function buildArea(layer, area, map) {
   try {
     await /* alloc */ new Promise(requestAnimationFrame);
-    await sceneByLayer.get(cameraByMap.get(map)._terrain3D)?._terrainPromise;
+    await cameraViewByMap.get(map);
     if (area.request.signal.aborted) return;
-    const data = await loadSource(backend, area);
+    const data = await loadSource(layer, area);
     if (area.request.signal.aborted) return;
     if (data?.type !== 'FeatureCollection' || !Array.isArray(data.features)) {
       throw /* alloc */ new Error('Invalid GeoJSON response');
     }
-    if (sceneByLayer.get(backend)._geojson && typeof backend.options.style !== 'function') {
+    if (geojsonByLayer.get(layer) && typeof layer.options.style !== 'function') {
       throw /* alloc */ new Error('style must be a function');
     }
-    const context = sourceAreaContext(backend, area, map);
-    let deadline = performance.now() + 4;
-    for (feature of data.features) {
-      if (area.request.signal.aborted) return;
-      if (performance.now() >= deadline) {
-        await /* alloc */ new Promise(requestAnimationFrame);
-        if (area.request.signal.aborted) return;
-        deadline = performance.now() + 4;
-      }
-      buildAreaFeature(context, feature);
+    const context = sourceAreaContext(layer, area, map);
+    // ponytail: feature-count cutoff avoids startup overhead; count vertices if giant single polygons matter.
+    if (layer.options.worker !== false && typeof Worker !== 'undefined' && data.features.length >= 64) {
+      context.jobs = /* alloc */ [];
     }
+    await buildAreaFeatures(context, area, data.features);
+    if (area.request.signal.aborted) return;
+    if (context.jobs) await buildAreaInWorker(context, area.request.signal);
+    if (area.request.signal.aborted) return;
     attachAreaMesh(context);
   } catch (error) {
     if (!area.request.signal.aborted) {
       area.error = error.message;
-      backend.fire('error', /* alloc */ { error });
+      layer.fire('error', /* alloc */ { error });
     }
   } finally {
-    sceneByLayer.get(backend)._inflight--;
-    pump(backend, map);
+    inflightByLayer.set(layer, inflightByLayer.get(layer) - 1);
+    pump(layer, map);
   }
 }

package/src/sources/buildAreaFeature.js

@@ -1,27 +1,33 @@
-import { L } from '../globals/L.js';
 import { buildAreaPoint } from './buildAreaPoint.js';
-import { buildAreaPolygon } from './buildAreaPolygon.js';
-import { parseColor } from '../utils/parseColor.js';
+import { buildAreaPolygon } from '../geometry/buildExtrudedPolygon.js';
+import { parseColor } from '../colors/parseColor.js';
 import { featureAnchor } from './featureAnchor.js';
 import { extrusionStyle } from './extrusionStyle.js';
+import { prepareAreaGeometryJob } from './prepareAreaGeometryJob.js';
+import { matchesAreaTile } from './matchesAreaTile.js';
 
 export function buildAreaFeature(context, feature) {
-  const { backend, area, map } = context;
+  const { backend: layer, area, map } = context;
   const coords = area.coords;
-  const coordinates = featureAnchor(feature, backend.options.nightLight);
+  const coordinates = featureAnchor(feature, layer.options.nightLight);
   const geometry = feature.geometry, isTree = geometry.type === 'Point';
   const lon = coordinates[0], lat = coordinates[1];
-  if (coords) {
-    const anchor = map.project(/* alloc */ new L.LatLng(lat, lon), coords.z);
-    if (Math.floor(anchor.x / 256) !== coords.x || Math.floor(anchor.y / 256) !== coords.y) return;
-  }
-  const style = extrusionStyle(backend, feature);
+  if (!matchesAreaTile(map, coords, lon, lat)) return;
+  const style = extrusionStyle(layer, feature);
   if (style === null) {
     context.skipped++;
     return;
   }
   const { top, bottom = 0, color = 0xd9b38c } = style;
   const baseColor = parseColor(color);
+  if (context.jobs) {
+    prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor);
+    context.featureFaces.push(/* alloc */ {
+      id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
+      properties: feature.properties, baseColor,
+    });
+    return;
+  }
   const vertexStart = context.positions.length / 3;
   if (isTree) buildAreaPoint(context, feature, lon, lat, style, baseColor);
   let polygon;

package/src/sources/buildAreaFeatures.js

@@ -0,0 +1,14 @@
+import { buildAreaFeature } from './buildAreaFeature.js';
+
+export async function buildAreaFeatures(context, area, features) {
+  let deadline = performance.now() + 4, feature;
+  for (feature of features) {
+    if (area.request.signal.aborted) return;
+    if (performance.now() >= deadline) {
+      await /* alloc */ new Promise(requestAnimationFrame);
+      if (area.request.signal.aborted) return;
+      deadline = performance.now() + 4;
+    }
+    buildAreaFeature(context, feature);
+  }
+}

package/src/sources/buildAreaPoint.js

@@ -1,25 +1,7 @@
-import { projectedTree } from './projectedTree.js';
-import { generateTreeGeometry } from './generateTreeGeometry.js';
-import { lampPostGeometry } from '../geometry/lampPostGeometry.js';
-import { lightGeometry } from '../geometry/lightGeometry.js';
-import { treeGeometry } from '../geometry/treeGeometry.js';
+import { projectedTree } from '../projections/projectTreePoint.js';
+import { buildProjectedPoint } from '../geometry/buildProjectedPoint.js';
 
 export function buildAreaPoint(context, feature, lon, lat, style, baseColor) {
-  const { backend } = context;
-  const { top } = style;
   const projected = projectedTree(context, lon, lat);
-  if (backend.options.nightLight) {
-    if (!Number.isFinite(style.lightFlux) || style.lightFlux <= 0) throw /* alloc */ new Error('Invalid light flux');
-    const support = feature.properties?.cod_ouvrag || `${lon},${lat}`;
-    if (style.poleRadius > 0 && !context.supports.has(support)) {
-      generateTreeGeometry(context, lampPostGeometry, projected, style);
-      context.supports.add(support);
-    }
-    generateTreeGeometry(context, lightGeometry, projected, style);
-    context.lights.push(/* alloc */ {
-      position: /* alloc */ [projected.x, projected.ground + top, -projected.y],
-      radius: Math.hypot(top, style.lightRadius), color: /* alloc */ [baseColor.r, baseColor.g, baseColor.b],
-      flux: style.lightFlux,
-    });
-  } else generateTreeGeometry(context, treeGeometry, projected, style);
+  buildProjectedPoint(context, projected, style, baseColor, feature.properties?.cod_ouvrag || `${lon},${lat}`);
 }

package/src/sources/extrusionStyle.js

@@ -1,5 +1,5 @@
-export function extrusionStyle(backend, feature) {
-  const style = backend.options.style(feature);
+export function extrusionStyle(layer, feature) {
+  const style = layer.options.style(feature);
   if (style === null) return null;
   if (!style || typeof style !== 'object') throw /* alloc */ new Error('style must return an extrusion style or null');
   const { top, bottom = 0 } = style;

package/src/sources/initializeGeoJSON.js

@@ -1,10 +1,11 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+
 
 
 import { setGeoJSONLayerData } from './setGeoJSONLayerData.js';
 import { init3D } from '../scene/init3D.js';
 
 export function initializeGeoJSON(layer, options) {
-  sceneByLayer.get(layer)._geojson = true;
+  geojsonByLayer.set(layer, true);
   init3D(layer, options);
 }

package/src/sources/matchesAreaTile.js

@@ -0,0 +1,7 @@
+import { L } from '../globals/L.js';
+
+export function matchesAreaTile(map, coords, lon, lat) {
+  if (!coords) return true;
+  const anchor = map.project(/* alloc */ new L.LatLng(lat, lon), coords.z);
+  return Math.floor(anchor.x / 256) === coords.x && Math.floor(anchor.y / 256) === coords.y;
+}

package/src/sources/pendingSourceAreas.js

@@ -1,11 +1,12 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+
 import { compareDistance } from '../utils/compareDistance.js';
 
 export function pendingSourceAreas(layers, map) {
   const pending = /* alloc */ [];
   let layer, area, center;
   for (layer of layers) {
-    for (area of sceneByLayer.get(layer)._areas.values()) {
+    for (area of areasByLayer.get(layer).values()) {
       if (area.started || area.request.signal.aborted) continue;
       center = area.coords && map.project(map.getCenter(), area.coords.z).divideBy(256);
       pending.push(/* alloc */ {

package/src/sources/prepareAreaGeometryJob.js

@@ -0,0 +1,24 @@
+import { projectedTree } from '../projections/projectTreePoint.js';
+import { parseColor } from '../colors/parseColor.js';
+import { projectAreaPolygons } from './projectAreaPolygons.js';
+
+export function prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor) {
+  const geometry = feature.geometry;
+  const polygons = projectAreaPolygons(context, geometry);
+  const point = geometry.type === 'Point' ? projectedTree(context, lon, lat) : null;
+  const nightLight = context.backend.options.nightLight;
+  const crownColor = point ? parseColor(style.color ?? (nightLight ? undefined : 0x4f823b)) : baseColor;
+  const trunkColor = point && !nightLight ? parseColor(style.trunkColor ?? 0x72513a) : null;
+  context.jobs.push(/* alloc */ {
+    point, polygons, baseColor: /* alloc */ { r: baseColor.r, g: baseColor.g, b: baseColor.b },
+    support: feature.properties?.cod_ouvrag || `${lon},${lat}`,
+    style: /* alloc */ {
+      top: style.top, bottom: style.bottom ?? 0,
+      color: /* alloc */ { r: crownColor.r, g: crownColor.g, b: crownColor.b },
+      trunkColor: trunkColor ? /* alloc */ { r: trunkColor.r, g: trunkColor.g, b: trunkColor.b } : undefined,
+      trunkRadius: style.trunkRadius, crownRadius: style.crownRadius,
+      crownBottom: style.crownBottom, crownShape: style.crownShape,
+      poleRadius: style.poleRadius, lightRadius: style.lightRadius, lightFlux: style.lightFlux,
+    },
+  });
+}

package/src/sources/projectAreaPolygons.js

@@ -0,0 +1,15 @@
+import { projectRing } from '../projections/projectRing.js';
+
+export function projectAreaPolygons(context, geometry) {
+  const rings = geometry.type === 'Polygon' ? /* alloc */ [geometry.coordinates]
+    : geometry.type === 'MultiPolygon' ? geometry.coordinates : /* alloc */ [];
+  const polygons = /* alloc */ [];
+  let polygon, ring, paths;
+  for (polygon of rings) {
+    if (!polygon.length) throw /* alloc */ new Error('Empty GeoJSON polygon');
+    paths = /* alloc */ [];
+    for (ring of polygon) paths.push(projectRing(context, ring));
+    polygons.push(paths);
+  }
+  return polygons;
+}

package/src/sources/pumpSourceAreas.js

@@ -0,0 +1,37 @@
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { inflightByLayer } from '../weakmaps/inflightByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { urlByLayer } from '../weakmaps/urlByLayer.js';
+
+import { renderers } from '../weakmaps/renderers.js';
+
+
+
+import { updateStatus } from './updateSourceStatus.js';
+
+import { buildArea } from './buildArea.js';
+import { pendingSourceAreas } from './pendingSourceAreas.js';
+
+/** Share four load/build slots across source layers, nearest ground blocks first. */
+export function pump(layer, map = layer._map) {
+  const shared = map && renderers.get(map);
+  if (!shared) return;
+  const layers = /* alloc */ [];
+  let sourceLayer, area, areaBackend;
+  for (sourceLayer of layersByLayer.get(shared)) {
+    if (Number.isFinite(inflightByLayer.get(sourceLayer)) && areasByLayer.get(sourceLayer) && (urlByLayer.get(sourceLayer) || geojsonByLayer.get(sourceLayer))) layers.push(sourceLayer);
+  }
+  const pending = pendingSourceAreas(layers, map);
+  let inflight = 0;
+  for (sourceLayer of layers) inflight += inflightByLayer.get(sourceLayer);
+  for ({ layer: areaBackend, area } of pending) {
+    if (inflight >= 4) break;
+    if (inflightByLayer.get(areaBackend) >= 2) continue;
+    area.started = true;
+    inflightByLayer.set(areaBackend, inflightByLayer.get(areaBackend) + 1);
+    inflight++;
+    buildArea(areaBackend, area, map);
+  }
+  for (sourceLayer of layers) updateStatus(sourceLayer);
+}