leaflet-city-mapper 0.0.3 → 0.0.4

package/src/shadows/renderSunlight.js

@@ -1,3 +1,7 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { disabledShadow } from '../globals/disabledShadow.js';
+import { shadowValues } from '../globals/shadowValues.js';
+
 import { shadowCacheMatches } from './shadowCacheMatches.js';
 import { shadowMatrix } from './shadowMatrix.js';
 import { ensureShadowPipeline } from './ensureShadowPipeline.js';
@@ -7,18 +11,16 @@ 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 = backend.renderer, device = renderer.device, sun = renderer.sunlight;
+  const renderer = sceneByLayer.get(backend).renderer, device = renderer.device, sun = renderer.sunlight;
   if (!meshes.length || !sunlight || sunlight.altitude < 3) {
     if (!sun.enabled) return;
-    const values = new Float32Array(20);
-    values.set([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-    device.queue.writeBuffer(sun.buffer, 0, values);
+    device.queue.writeBuffer(sun.buffer, 0, disabledShadow);
     sun.enabled = false;
     sun.cache = null;
     return;
   }
   if (shadowCacheMatches(sun, meshes, sunlight)) return;
-  const values = new Float32Array(20);
+  const values = shadowValues;
   sun.enabled = true;
   resizeSunlight(backend, Math.min(2048, device.limits.maxTextureDimension2D));
   values.set(shadowMatrix(meshes, sunlight));
@@ -33,14 +35,14 @@ export function renderSunlight(backend, encoder, meshes, sunlight) {
     }
   }
   drawShadowMeshes(backend, encoder, meshes);
-  const snapshots = new Map();
+  const snapshots = /* alloc */ new Map();
   let mesh2;
   for (mesh2 of meshes) {
-    snapshots.set(mesh2, {
+    snapshots.set(mesh2, /* alloc */ {
       world: mesh2._worldMatrixVersion, geometry: mesh2.geometry,
       start: mesh2.geometry.drawRange.start, count: mesh2.geometry.drawRange.count,
       appearance: mesh2._appearance ?? 1,
     });
   }
-  sun.cache = { direction: [...sunlight.direction], meshes: snapshots };
+  sun.cache = /* alloc */ { direction: /* alloc */ [...sunlight.direction], meshes: snapshots };
 }

package/src/shadows/resizeSunlight.js

@@ -1,15 +1,21 @@
+import { shadowTexture } from '../globals/shadowTexture.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { bindSunlight } from './bindSunlight.js';
 import { destroyTexture } from '../rendering/destroyTexture.js';
 
-
 export function resizeSunlight(backend, size) {
-  const device = backend.renderer.device, sun = backend.renderer.sunlight;
+  const device = sceneByLayer.get(backend).renderer.device, sun = sceneByLayer.get(backend).renderer.sunlight;
   if (sun.size === size) return;
   if (sun.texture) destroyTexture(backend, sun.texture);
   sun.size = size;
-  sun.texture = device.createTexture({
-    size: [size, size], format: 'depth32float',
-    usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC,
-  });
+  sun.texture = device.createTexture((
+    shadowTexture.size[0] = size,
+    shadowTexture.size[1] = size,
+    shadowTexture.usage = GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC,
+    shadowTexture
+  ));
+
   bindSunlight(backend);
 }

package/src/shadows/shadowBounds.js

@@ -1,26 +1,17 @@
 import { computeBounds } from '../geometry/computeBounds.js';
+import { meshShadowBounds } from './meshShadowBounds.js';
 
-export function shadowBounds(meshes) {
-  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
-  let mesh, bounds, matrix, cached, i, x, y, z, w, axis, value;
+export function shadowBounds(meshes, output = /* alloc */ {
+  min: /* alloc */ [Infinity, Infinity, Infinity],
+  max: /* alloc */ [-Infinity, -Infinity, -Infinity],
+}) {
+  const { min, max } = output;
+  min.fill(Infinity); max.fill(-Infinity);
+  let mesh, bounds, matrix, cached, axis;
   for (mesh of meshes) {
     if (!mesh.geometry.bounds || mesh.geometry.attributes.position.needsUpdate) computeBounds(mesh.geometry);
     bounds = mesh.geometry.bounds, matrix = mesh.worldMatrix;
-    cached = mesh._shadowBounds;
-    if (!cached || cached.version !== mesh._worldMatrixVersion || cached.bounds !== bounds) {
-      cached = mesh._shadowBounds = { version: mesh._worldMatrixVersion, bounds,
-        min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity] };
-      for (i = 0; i < 8; i++) {
-        x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
-        z = i & 4 ? bounds.max[2] : bounds.min[2];
-        w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
-        for (axis = 0; axis < 3; axis++) {
-          value = (matrix[axis] * x + matrix[axis + 4] * y + matrix[axis + 8] * z + matrix[axis + 12]) / w;
-          cached.min[axis] = Math.min(cached.min[axis], value);
-          cached.max[axis] = Math.max(cached.max[axis], value);
-        }
-      }
-    }
+    cached = meshShadowBounds(mesh, bounds, matrix);
     for (axis = 0; axis < 3; axis++) {
       min[axis] = Math.min(min[axis], cached.min[axis]);
       max[axis] = Math.max(max[axis], cached.max[axis]);
@@ -28,5 +19,5 @@ export function shadowBounds(meshes) {
   }
   // Include ground receivers below/around the loaded buildings and trees.
   min[1] = Math.min(0, min[1]);
-  return { min, max };
+  return output;
 }

package/src/shadows/shadowCacheMatches.js

@@ -1,7 +1,7 @@
 export function shadowCacheMatches(sun, meshes, sunlight) {
   const cache = sun.cache;
   let unchanged = sun.enabled && cache?.meshes.size === meshes.length;
-  let i, mesh, previous, range, attribute;
+  let i, mesh;
   if (unchanged) {
     for (i = 0; i < sunlight.direction.length; i++) {
       if (sunlight.direction[i] !== cache.direction[i]) { unchanged = false; break; }
@@ -9,15 +9,9 @@ export function shadowCacheMatches(sun, meshes, sunlight) {
   }
   if (unchanged) {
     for (mesh of meshes) {
-      previous = cache.meshes.get(mesh), range = mesh.geometry.drawRange;
-      if (!(previous && previous.world === mesh._worldMatrixVersion && previous.geometry === mesh.geometry &&
-        previous.start === range.start && previous.count === range.count &&
-        previous.appearance === (mesh._appearance ?? 1))) { unchanged = false; break; }
-      for (attribute of Object.values(mesh.geometry.attributes)) {
-        if (attribute.needsUpdate) { unchanged = false; break; }
-      }
-      if (!unchanged) break;
+      if (!shadowMeshMatches(cache, mesh)) { unchanged = false; break; }
     }
   }
   return unchanged;
 }
+import { shadowMeshMatches } from './shadowMeshMatches.js';

package/src/shadows/shadowMatrix.js

@@ -1,39 +1,49 @@
+import { shadowBounds as sharedShadowBounds } from '../globals/shadowBounds.js';
+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';
 
 export function shadowMatrix(meshes, sunlight) {
-  const { min, max } = shadowBounds(meshes);
-  const span = [], center = [], position = [];
-  let i, corner, axis, point, coordinates, value;
+  const { min, max } = shadowBounds(meshes, sharedShadowBounds);
+  const camera = shadowCamera;
+  camera.viewTransform ||= /* alloc */ new DOMMatrix();
+  camera.projectionTransform ||= /* alloc */ new DOMMatrix();
+  camera.projectionViewTransform ||= /* alloc */ new DOMMatrix();
+  const low = shadowLow, high = shadowHigh;
+  let i, axis, x, y, z, value;
+  const radius = Math.max(100, Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]));
   for (i = 0; i < 3; i++) {
-    span[i] = max[i] - min[i];
-    center[i] = (min[i] + max[i]) / 2;
+    camera.target[i] = (min[i] + max[i]) / 2;
+    camera.position[i] = camera.target[i] + sunlight.direction[i] * radius * 2;
   }
-  const radius = Math.max(100, Math.hypot(...span));
-  for (i = 0; i < 3; i++) position[i] = center[i] + sunlight.direction[i] * radius * 2;
-  const lightCamera = {
-    position,
-    target: center, up: [0, 0, -1], fov: 45, aspect: 1, near: 1, far: radius * 5,
-    viewMatrix: [], projectionMatrix: [], projectionViewMatrix: [],
-  };
-  updateCamera(lightCamera);
-  const view = new DOMMatrix(lightCamera.viewMatrix);
-  const low = [Infinity, Infinity, Infinity], high = [-Infinity, -Infinity, -Infinity];
+  camera.far = radius * 5;
+  updateCamera(camera);
+  const view = camera.viewMatrix;
+  low.fill(Infinity); high.fill(-Infinity);
   for (i = 0; i < 8; i++) {
-    corner = [];
-    for (axis = 0; axis < 3; axis++) corner[axis] = i & (1 << axis) ? max[axis] : min[axis];
-    point = new DOMPoint(...corner, 1).matrixTransform(view);
-    coordinates = [point.x, point.y, point.z];
+    x = i & 1 ? max[0] : min[0];
+    y = i & 2 ? max[1] : min[1];
+    z = i & 4 ? max[2] : min[2];
     for (axis = 0; axis < 3; axis++) {
-      value = coordinates[axis];
+      value = view[axis] * x + view[axis + 4] * y + view[axis + 8] * z + view[axis + 12];
       low[axis] = Math.min(low[axis], value - 20);
       high[axis] = Math.max(high[axis], value + 20);
     }
   }
-  for (i = 0; i < 3; i++) span[i] = high[i] - low[i];
-  const projection = new DOMMatrix([
-    2 / span[0], 0, 0, 0, 0, 2 / span[1], 0, 0, 0, 0, -1 / span[2], 0,
-    -(high[0] + low[0]) / span[0], -(high[1] + low[1]) / span[1], high[2] / span[2], 1,
-  ]);
-  return projection.multiply(view).toFloat32Array();
+  const scaleX = 2 / (high[0] - low[0]), scaleY = 2 / (high[1] - low[1]);
+  const scaleZ = -1 / (high[2] - low[2]);
+  const matrix = /* alloc */ new Float32Array(16);
+  for (i = 0; i < 16; i += 4) {
+    matrix[i] = view[i] * scaleX;
+    matrix[i + 1] = view[i + 1] * scaleY;
+    matrix[i + 2] = view[i + 2] * scaleZ;
+    matrix[i + 3] = view[i + 3];
+  }
+  matrix[12] -= (high[0] + low[0]) / (high[0] - low[0]);
+  matrix[13] -= (high[1] + low[1]) / (high[1] - low[1]);
+  matrix[14] += high[2] / (high[2] - low[2]);
+  return matrix;
 }

package/src/shadows/shadowMeshMatches.js

@@ -0,0 +1,11 @@
+export function shadowMeshMatches(cache, mesh) {
+  const previous = cache.meshes.get(mesh), range = mesh.geometry.drawRange;
+  if (!(previous && previous.world === mesh._worldMatrixVersion && previous.geometry === mesh.geometry &&
+    previous.start === range.start && previous.count === range.count &&
+    previous.appearance === (mesh._appearance ?? 1))) return false;
+  let attribute;
+  for (attribute of Object.values(mesh.geometry.attributes)) {
+    if (attribute.needsUpdate) return false;
+  }
+  return true;
+}

package/src/sources/addGeneratedTriangle.js

@@ -1,6 +1,7 @@
+import { triangleContexts } from '../globals/triangleContexts.js';
+
 import { addTriangle } from './addTriangle.js';
-import { pumpState } from '../constants/pumpState.js';
 
 export function addGeneratedTriangle(...args) {
-  addTriangle(pumpState.triangleContexts[pumpState.triangleContexts.length - 1], ...args);
+  addTriangle(triangleContexts[triangleContexts.length - 1], ...args);
 }

package/src/sources/attachAreaMesh.js

@@ -1,6 +1,10 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { nextId } from '../globals/nextId.js';
+
+
 import { emptyNode } from '../scene/emptyNode.js';
 import { createProgram } from '../rendering/createProgram.js';
-import { cityMapper } from '../constants/cityMapper.js';
+
 import { setParent } from '../scene/setParent.js';
 import { update } from '../scene/update.js';
 import { instanceAreaGeometry } from './instanceAreaGeometry.js';
@@ -8,51 +12,53 @@ import { instanceAreaGeometry } from './instanceAreaGeometry.js';
 export function attachAreaMesh(context) {
   const { backend, area } = context;
   if (!context.positions.length) {
-    Object.assign(area, { mesh: null, buildings: 0, skipped: context.skipped, done: true });
+    area.mesh = null, area.buildings = 0, area.skipped = context.skipped, area.done = true;
     return;
   }
-  const device = backend.renderer.device;
+  const device = sceneByLayer.get(backend).renderer.device;
   const data = instanceAreaGeometry(context);
-  const attributes = {
-    position: { size: 3, data: new Float32Array(data.positions) },
-    normal: { size: 3, data: new Float32Array(data.normals) },
-    color: { size: 3, data: new Float32Array(data.colors) },
+  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) },
   };
-  if (data.instanceOffsets) attributes.instanceOffset = { size: 4, data: data.instanceOffsets };
-  if (backend.options.nightLight) attributes.uv = { size: 2, data: new Float32Array(context.uvs) };
+  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) };
   let name, attribute;
-  for ([name, attribute] of Object.entries(attributes)) {
+  for (name in attributes) {
+    attribute = attributes[name];
     attribute.count = attribute.data.length / attribute.size;
-    attribute.buffer = device.createBuffer({
+    attribute.buffer = device.createBuffer(/* alloc */ {
       size: Math.max(4, attribute.data.byteLength),
       usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
     });
     device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
   }
-  const meshGeometry = {
+  const meshGeometry = /* alloc */ {
     device,
     attributes,
-    drawRange: { start: 0, count: attributes.position.count },
+    drawRange: /* alloc */ { start: 0, count: attributes.position.count },
   };
-  Object.assign(area, {
-    mesh: {
+  area.mesh = /* alloc */ {
       ...emptyNode(),
       device,
       geometry: meshGeometry,
-      program: createProgram(backend, {
+      program: createProgram(backend, /* alloc */ {
         instanced: Boolean(data.instanceOffsets),
-        vertexColors: true, roofTexture: Boolean(backend.options.roofTexture),
-        ...(backend.options.nightLight ? { nightLight: true, alphaMode: 'BLEND', doubleSided: true } : {}),
+        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),
       }),
-      id: cityMapper.nextId++,
+      id: nextId.value++,
       renderOrder: 0,
       fadeDuration: 250,
-      extras: { featureFaces: context.featureFaces, lights: context.lights },
-    },
-    buildings: context.featureFaces.length,
-    skipped: context.skipped,
-    done: true,
-  });
-  setParent(area.mesh, backend.root);
+      extras: /* alloc */ { featureFaces: context.featureFaces, lights: context.lights },
+    };
+  area.buildings = context.featureFaces.length;
+  area.skipped = context.skipped;
+  area.done = true;
+  setParent(area.mesh, sceneByLayer.get(backend).root);
   update(backend);
 }

package/src/sources/buildArea.js

@@ -1,3 +1,7 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
 import { buildAreaFeature } from './buildAreaFeature.js';
 import { attachAreaMesh } from './attachAreaMesh.js';
 import { loadSource } from '../archives/loadSource.js';
@@ -7,23 +11,23 @@ import { pump } from './pump.js';
 export async function buildArea(backend, area, map) {
   let feature;
   try {
-    await new Promise(requestAnimationFrame);
-    await map._terrain3D?._terrainPromise;
+    await /* alloc */ new Promise(requestAnimationFrame);
+    await sceneByLayer.get(cameraByMap.get(map)._terrain3D)?._terrainPromise;
     if (area.request.signal.aborted) return;
     const data = await loadSource(backend, area);
     if (area.request.signal.aborted) return;
     if (data?.type !== 'FeatureCollection' || !Array.isArray(data.features)) {
-      throw new Error('Invalid GeoJSON response');
+      throw /* alloc */ new Error('Invalid GeoJSON response');
     }
-    if (backend._geojson && typeof backend.options.style !== 'function') {
-      throw new Error('style must be a function');
+    if (sceneByLayer.get(backend)._geojson && typeof backend.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 new Promise(requestAnimationFrame);
+        await /* alloc */ new Promise(requestAnimationFrame);
         if (area.request.signal.aborted) return;
         deadline = performance.now() + 4;
       }
@@ -33,10 +37,10 @@ export async function buildArea(backend, area, map) {
   } catch (error) {
     if (!area.request.signal.aborted) {
       area.error = error.message;
-      backend.fire('error', { error });
+      backend.fire('error', /* alloc */ { error });
     }
   } finally {
-    backend._inflight--;
+    sceneByLayer.get(backend)._inflight--;
     pump(backend, map);
   }
 }

package/src/sources/buildAreaFeature.js

@@ -1,39 +1,34 @@
+import { L } from '../globals/L.js';
 import { buildAreaPoint } from './buildAreaPoint.js';
 import { buildAreaPolygon } from './buildAreaPolygon.js';
 import { parseColor } from '../utils/parseColor.js';
+import { featureAnchor } from './featureAnchor.js';
+import { extrusionStyle } from './extrusionStyle.js';
 
 export function buildAreaFeature(context, feature) {
   const { backend, area, map } = context;
   const coords = area.coords;
-  const geometry = feature?.geometry;
-  const isTree = geometry?.type === 'Point';
-  if (backend.options.nightLight && !isTree) throw new Error('Night lights require Point geometry');
-  const polygons = geometry?.type === 'Polygon' ? [geometry.coordinates] :
-    geometry?.type === 'MultiPolygon' ? geometry.coordinates : null;
-  if (!polygons && !isTree) throw new Error('Unsupported GeoJSON geometry');
-  const [lon, lat] = (isTree ? geometry.coordinates : polygons[0]?.[0]?.[0]) ?? [];
-  if (!Number.isFinite(lon) || !Number.isFinite(lat)) throw new Error('Invalid GeoJSON coordinates');
+  const coordinates = featureAnchor(feature, backend.options.nightLight);
+  const geometry = feature.geometry, isTree = geometry.type === 'Point';
+  const lon = coordinates[0], lat = coordinates[1];
   if (coords) {
-    const anchor = map.project(new L.LatLng(lat, lon), coords.z);
+    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 = backend.options.style(feature);
+  const style = extrusionStyle(backend, feature);
   if (style === null) {
     context.skipped++;
     return;
   }
-  if (!style || typeof style !== 'object') throw new Error('style must return an extrusion style or null');
   const { top, bottom = 0, color = 0xd9b38c } = style;
-  if (!Number.isFinite(top) || !Number.isFinite(bottom) || bottom < 0 || top <= bottom) {
-    throw new Error('Invalid extrusion heights: expected top > bottom >= 0');
-  }
   const baseColor = parseColor(color);
   const vertexStart = context.positions.length / 3;
   if (isTree) buildAreaPoint(context, feature, lon, lat, style, baseColor);
-  let rings;
-  for (rings of polygons || []) buildAreaPolygon(context, rings, top, bottom, baseColor);
+  let polygon;
+  if (geometry.type === 'Polygon') buildAreaPolygon(context, geometry.coordinates, top, bottom, baseColor);
+  else if (geometry.type === 'MultiPolygon') for (polygon of geometry.coordinates) buildAreaPolygon(context, polygon, top, bottom, baseColor);
   const vertexEnd = context.positions.length / 3;
-  context.featureFaces.push({
+  context.featureFaces.push(/* alloc */ {
     id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
     properties: feature.properties, baseColor,
     faceStart: vertexStart / 3, faceEnd: vertexEnd / 3, vertexStart, vertexEnd,

package/src/sources/buildAreaPoint.js

@@ -9,16 +9,16 @@ export function buildAreaPoint(context, feature, lon, lat, style, baseColor) {
   const { top } = style;
   const projected = projectedTree(context, lon, lat);
   if (backend.options.nightLight) {
-    if (!Number.isFinite(style.lightFlux) || style.lightFlux <= 0) throw new Error('Invalid light flux');
+    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({
-      position: [projected.x, projected.ground + top, -projected.y],
-      radius: Math.hypot(top, style.lightRadius), color: [baseColor.r, baseColor.g, baseColor.b],
+    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);

package/src/sources/buildAreaPolygon.js

@@ -4,11 +4,11 @@ import { addTriangle } from './addTriangle.js';
 import { isClockWise } from '../triangulation/isClockWise.js';
 
 export function buildAreaPolygon(context, rings, top, bottom, baseColor) {
-  if (!rings.length) throw new Error('Empty GeoJSON polygon');
-  const paths = [];
+  if (!rings.length) throw /* alloc */ new Error('Empty GeoJSON polygon');
+  const paths = /* alloc */ [];
   let ring, path, point, a, b, c, index, sign, i, length, nx, nz;
   for (ring of rings) paths.push(projectRing(context, ring));
-  const points = [];
+  const points = /* alloc */ [];
   for (path of paths) for (point of path) points.push(point);
   for ([a, b, c] of triangulate(paths[0], paths.slice(1))) {
     addTriangle(context, points[a], top, points[b], top, points[c], top, 0, 1, 0, baseColor);

package/src/sources/compareAreaDistance.js

@@ -1,4 +1,3 @@
 export function compareAreaDistance(a, b) {
-  return Math.hypot(a[1].x - a[2].x, a[1].y - a[2].y) -
-    Math.hypot(b[1].x - b[2].x, b[1].y - b[2].y);
+  return a.distance - b.distance;
 }

package/src/sources/extrusionStyle.js

@@ -0,0 +1,10 @@
+export function extrusionStyle(backend, feature) {
+  const style = backend.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;
+  if (!Number.isFinite(top) || !Number.isFinite(bottom) || bottom < 0 || top <= bottom) {
+    throw /* alloc */ new Error('Invalid extrusion heights: expected top > bottom >= 0');
+  }
+  return style;
+}

package/src/sources/featureAnchor.js

@@ -0,0 +1,9 @@
+export function featureAnchor(feature, nightLight) {
+  const geometry = feature?.geometry, point = geometry?.type === 'Point';
+  if (nightLight && !point) throw /* alloc */ new Error('Night lights require Point geometry');
+  if (geometry?.type !== 'Polygon' && geometry?.type !== 'MultiPolygon' && !point) throw /* alloc */ new Error('Unsupported GeoJSON geometry');
+  const coordinates = point ? geometry.coordinates :
+    geometry.type === 'Polygon' ? geometry.coordinates[0]?.[0] : geometry.coordinates[0]?.[0]?.[0];
+  if (!Number.isFinite(coordinates?.[0]) || !Number.isFinite(coordinates?.[1])) throw /* alloc */ new Error('Invalid GeoJSON coordinates');
+  return coordinates;
+}

package/src/sources/generateTreeGeometry.js

@@ -1,11 +1,13 @@
-import { pumpState } from '../constants/pumpState.js';
+import { triangleContexts } from '../globals/triangleContexts.js';
+
+
 import { addGeneratedTriangle } from './addGeneratedTriangle.js';
 
 export function generateTreeGeometry(context, generator, point, style) {
-  pumpState.triangleContexts.push(context);
+  triangleContexts.push(context);
   try {
     generator(point, style, addGeneratedTriangle);
   } finally {
-    pumpState.triangleContexts.pop();
+    triangleContexts.pop();
   }
 }

package/src/sources/initializeGeoJSON.js

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

package/src/sources/instanceAreaGeometry.js

@@ -5,16 +5,18 @@ export function instanceAreaGeometry(context) {
   const vertices = featureFaces[0].vertexEnd;
   const length = vertices * 3;
   if (!vertices || positions.length !== length * featureFaces.length) return context;
-  const origin = [Math.trunc(positions[0]), Math.trunc(positions[1]), Math.trunc(positions[2])];
-  const template = new Float32Array(length);
-  let i, instance, axis, face, start;
-  for (i = 0; i < length; i++) template[i] = positions[i] - origin[i % 3];
-  const offsets = new Float32Array(featureFaces.length * 4);
+  const originX = Math.trunc(positions[0]), originY = Math.trunc(positions[1]), originZ = Math.trunc(positions[2]);
+  const template = /* alloc */ new Float32Array(length);
+  let i, instance, face, start;
+  for (i = 0; i < length; i++) template[i] = positions[i] - (i % 3 === 0 ? originX : i % 3 === 1 ? originY : originZ);
+  const offsets = /* alloc */ new Float32Array(featureFaces.length * 4);
   for (instance = 0; instance < featureFaces.length; instance++) {
     face = featureFaces[instance];
     start = instance * length;
     if (face.vertexStart !== instance * vertices || face.vertexEnd !== (instance + 1) * vertices) return context;
-    for (axis = 0; axis < 3; axis++) offsets[instance * 4 + axis] = origin[axis] + positions[start + axis] - positions[axis];
+    offsets[instance * 4] = originX + positions[start] - positions[0];
+    offsets[instance * 4 + 1] = originY + positions[start + 1] - positions[1];
+    offsets[instance * 4 + 2] = originZ + positions[start + 2] - positions[2];
     offsets[instance * 4 + 3] = instance * vertices;
     for (i = 0; i < length; i++) {
       if (Math.fround(template[i] + offsets[instance * 4 + i % 3]) !== Math.fround(positions[start + i]) ||
@@ -22,7 +24,7 @@ export function instanceAreaGeometry(context) {
           Math.fround(colors[i]) !== Math.fround(colors[start + i])) return context;
     }
   }
-  return {
+  return /* alloc */ {
     positions: template, normals: normals.slice(0, length), colors: colors.slice(0, length),
     instanceOffsets: offsets,
   };

package/src/sources/pendingSourceAreas.js

@@ -0,0 +1,20 @@
+import { sceneByLayer } from '../globals/sceneByLayer.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()) {
+      if (area.started || area.request.signal.aborted) continue;
+      center = area.coords && map.project(map.getCenter(), area.coords.z).divideBy(256);
+      pending.push(/* alloc */ {
+        layer, area,
+        distance: center
+          ? Math.hypot(area.coords.x + 0.5 - center.x, area.coords.y + 0.5 - center.y) / 2 ** area.coords.z : 0,
+      });
+    }
+  }
+  pending.sort(compareDistance);
+  return pending;
+}

package/src/sources/projectRing.js

@@ -1,19 +1,26 @@
+import { L } from '../globals/L.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { getElevation } from '../terrain/getElevation.js';
 
 export function projectRing(context, ring) {
   const { backend, crs, origin, metres, map } = context;
-  if (ring.length < 4) throw new Error('Invalid GeoJSON polygon ring');
-  const path = [];
-  let lng, lat, point, elevation;
-  for ([lng, lat] of ring.slice(0, -1)) {
-    if (!Number.isFinite(lng) || !Number.isFinite(lat)) throw new Error('Invalid GeoJSON coordinates');
-    point = crs.project(new L.LatLng(lat, lng));
-    elevation = map._terrain3D ? getElevation(map._terrain3D, [lat, lng]) : undefined;
-    path.push({
+  if (ring.length < 4) throw /* alloc */ new Error('Invalid GeoJSON polygon ring');
+  const path = /* alloc */ [];
+  let i, lng, lat, location, point, elevation;
+  for (i = 0; i < ring.length - 1; i++) {
+    lng = ring[i][0], lat = ring[i][1];
+    if (!Number.isFinite(lng) || !Number.isFinite(lat)) throw /* alloc */ new Error('Invalid GeoJSON coordinates');
+    location = /* alloc */ new L.LatLng(lat, lng);
+    point = crs.project(location);
+    elevation = cameraByMap.get(map)._terrain3D ? getElevation(cameraByMap.get(map)._terrain3D, location) : undefined;
+    path.push(/* alloc */ {
       x: (point.x - origin.x) * metres,
       y: (point.y - origin.y) * metres,
-      ground: Number.isFinite(elevation) && Number.isFinite(backend.root.position[1])
-        ? elevation - backend.root.position[1] : 0,
+      ground: Number.isFinite(elevation) && Number.isFinite(sceneByLayer.get(backend).root.position[1])
+        ? elevation - sceneByLayer.get(backend).root.position[1] : 0,
     });
   }
   return path;