leaflet-city-mapper 0.0.1 → 0.0.3

package/src/shadows/ensureShadowPipeline.js

@@ -0,0 +1,53 @@
+export function ensureShadowPipeline(device, sun, instanced = false) {
+  const key = instanced ? 'instancePipeline' : 'pipeline';
+  if (!sun[key]) {
+    if (!sun.meshLayout) {
+      sun.meshLayout = device.createBindGroupLayout({
+        entries: [
+          { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: true } },
+        ]
+      });
+      // Do not bind the sampled depth texture while it is a render attachment.
+      sun.depthLayout = device.createBindGroupLayout({
+        entries: [
+          { binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform' } },
+        ]
+      });
+      sun.depthBindGroup = device.createBindGroup({
+        layout: sun.depthLayout, entries: [{ binding: 0, resource: { buffer: sun.buffer } }],
+      });
+    }
+    const shader = device.createShaderModule({
+      code: /* wgsl */ `
+      struct Mesh { world: mat4x4<f32>, padding: array<vec4<f32>, 4>, highlight: vec4<f32> };
+      @group(0) @binding(0) var<uniform> mesh: Mesh;
+      @group(1) @binding(0) var<uniform> matrix: mat4x4<f32>;
+      @vertex fn main(@location(0) position: vec3<f32>${instanced ? ', @location(4) offset: vec4<f32>' : ''}) -> @builtin(position) vec4<f32> {
+        return matrix * mesh.world * vec4<f32>(position${instanced ? ' + offset.xyz' : ''}, 1.0);
+      }
+      @fragment fn fragmentMain(@builtin(position) position: vec4<f32>) {
+        let noise = fract(52.9829189 * fract(dot(floor(position.xy), vec2<f32>(0.06711056, 0.00583715))));
+        if (mesh.highlight.w < 1.0 && noise >= mesh.highlight.w) { discard; }
+      }
+    ` });
+    const buffers = [
+      { arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }] },
+    ];
+    if (instanced) buffers.push({
+      arrayStride: 16, stepMode: 'instance',
+      attributes: [{ shaderLocation: 4, offset: 0, format: 'float32x4' }],
+    });
+    sun[key] = device.createRenderPipeline({
+      layout: device.createPipelineLayout({ bindGroupLayouts: [sun.meshLayout, sun.depthLayout] }),
+      vertex: {
+        module: shader, entryPoint: 'main', buffers
+      },
+      fragment: { module: shader, entryPoint: 'fragmentMain', targets: [] },
+      primitive: { topology: 'triangle-list', cullMode: 'none' },
+      depthStencil: {
+        format: 'depth32float', depthWriteEnabled: true, depthCompare: 'less',
+        depthBias: 2, depthBiasSlopeScale: 2
+      },
+    });
+  }
+}

package/src/shadows/renderSunlight.js

@@ -0,0 +1,46 @@
+import { shadowCacheMatches } from './shadowCacheMatches.js';
+import { shadowMatrix } from './shadowMatrix.js';
+import { ensureShadowPipeline } from './ensureShadowPipeline.js';
+import { drawShadowMeshes } from './drawShadowMeshes.js';
+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;
+  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);
+    sun.enabled = false;
+    sun.cache = null;
+    return;
+  }
+  if (shadowCacheMatches(sun, meshes, sunlight)) return;
+  const values = new Float32Array(20);
+  sun.enabled = true;
+  resizeSunlight(backend, Math.min(2048, device.limits.maxTextureDimension2D));
+  values.set(shadowMatrix(meshes, sunlight));
+  values[16] = 1;
+  device.queue.writeBuffer(sun.buffer, 0, values);
+  ensureShadowPipeline(device, sun);
+  let mesh;
+  for (mesh of meshes) {
+    if (mesh.geometry.attributes.instanceOffset) {
+      ensureShadowPipeline(device, sun, true);
+      break;
+    }
+  }
+  drawShadowMeshes(backend, encoder, meshes);
+  const snapshots = new Map();
+  let mesh2;
+  for (mesh2 of meshes) {
+    snapshots.set(mesh2, {
+      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 };
+}

package/src/shadows/resizeSunlight.js

@@ -0,0 +1,15 @@
+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;
+  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,
+  });
+  bindSunlight(backend);
+}

package/src/shadows/shadowBounds.js

@@ -0,0 +1,32 @@
+import { computeBounds } from '../geometry/computeBounds.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;
+  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);
+        }
+      }
+    }
+    for (axis = 0; axis < 3; axis++) {
+      min[axis] = Math.min(min[axis], cached.min[axis]);
+      max[axis] = Math.max(max[axis], cached.max[axis]);
+    }
+  }
+  // Include ground receivers below/around the loaded buildings and trees.
+  min[1] = Math.min(0, min[1]);
+  return { min, max };
+}

package/src/shadows/shadowCacheMatches.js

@@ -0,0 +1,23 @@
+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;
+  if (unchanged) {
+    for (i = 0; i < sunlight.direction.length; i++) {
+      if (sunlight.direction[i] !== cache.direction[i]) { unchanged = false; break; }
+    }
+  }
+  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;
+    }
+  }
+  return unchanged;
+}

package/src/shadows/shadowMatrix.js

@@ -0,0 +1,39 @@
+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;
+  for (i = 0; i < 3; i++) {
+    span[i] = max[i] - min[i];
+    center[i] = (min[i] + max[i]) / 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];
+  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];
+    for (axis = 0; axis < 3; axis++) {
+      value = coordinates[axis];
+      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();
+}

package/src/sources/addGeneratedTriangle.js

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

package/src/sources/addTriangle.js

@@ -0,0 +1,17 @@
+import { groundOffset } from './groundOffset.js';
+
+export function addTriangle(context, a, ah, b, bh, c, ch, nx, ny, nz, color) {
+  const { backend, positions, normals, colors, uvs } = context;
+  const ux = b.x - a.x, uy = bh - ah, uz = a.y - b.y;
+  const vx = c.x - a.x, vy = ch - ah, vz = a.y - c.y;
+  if ((uy * vz - uz * vy) * nx + (uz * vx - ux * vz) * ny + (ux * vy - uy * vx) * nz < 0) {
+    const point = b, height = bh;
+    b = c; bh = ch; c = point; ch = height;
+  }
+  positions.push(a.x, ah + groundOffset(a), -a.y,
+    b.x, bh + groundOffset(b), -b.y,
+    c.x, ch + groundOffset(c), -c.y);
+  normals.push(nx, ny, nz, nx, ny, nz, nx, ny, nz);
+  colors.push(color.r, color.g, color.b, color.r, color.g, color.b, color.r, color.g, color.b);
+  if (backend.options.nightLight) uvs.push(...a.uv, ...b.uv, ...c.uv);
+}

package/src/sources/attachAreaMesh.js

@@ -0,0 +1,58 @@
+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';
+
+export function attachAreaMesh(context) {
+  const { backend, area } = context;
+  if (!context.positions.length) {
+    Object.assign(area, { mesh: null, buildings: 0, skipped: context.skipped, done: true });
+    return;
+  }
+  const device = 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) },
+  };
+  if (data.instanceOffsets) attributes.instanceOffset = { size: 4, data: data.instanceOffsets };
+  if (backend.options.nightLight) attributes.uv = { size: 2, data: new Float32Array(context.uvs) };
+  let name, attribute;
+  for ([name, attribute] of Object.entries(attributes)) {
+    attribute.count = attribute.data.length / attribute.size;
+    attribute.buffer = device.createBuffer({
+      size: Math.max(4, attribute.data.byteLength),
+      usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+  }
+  const meshGeometry = {
+    device,
+    attributes,
+    drawRange: { start: 0, count: attributes.position.count },
+  };
+  Object.assign(area, {
+    mesh: {
+      ...emptyNode(),
+      device,
+      geometry: meshGeometry,
+      program: createProgram(backend, {
+        instanced: Boolean(data.instanceOffsets),
+        vertexColors: true, roofTexture: Boolean(backend.options.roofTexture),
+        ...(backend.options.nightLight ? { nightLight: true, alphaMode: 'BLEND', doubleSided: true } : {}),
+      }),
+      id: cityMapper.nextId++,
+      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);
+  update(backend);
+}

package/src/sources/buildArea.js

@@ -0,0 +1,42 @@
+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';
+
+export async function buildArea(backend, area, map) {
+  let feature;
+  try {
+    await new Promise(requestAnimationFrame);
+    await 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');
+    }
+    if (backend._geojson && typeof backend.options.style !== 'function') {
+      throw 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);
+        if (area.request.signal.aborted) return;
+        deadline = performance.now() + 4;
+      }
+      buildAreaFeature(context, feature);
+    }
+    attachAreaMesh(context);
+  } catch (error) {
+    if (!area.request.signal.aborted) {
+      area.error = error.message;
+      backend.fire('error', { error });
+    }
+  } finally {
+    backend._inflight--;
+    pump(backend, map);
+  }
+}

package/src/sources/buildAreaFeature.js

@@ -0,0 +1,41 @@
+import { buildAreaPoint } from './buildAreaPoint.js';
+import { buildAreaPolygon } from './buildAreaPolygon.js';
+import { parseColor } from '../utils/parseColor.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');
+  if (coords) {
+    const anchor = map.project(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);
+  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);
+  const vertexEnd = context.positions.length / 3;
+  context.featureFaces.push({
+    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

@@ -0,0 +1,25 @@
+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';
+
+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 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],
+      flux: style.lightFlux,
+    });
+  } else generateTreeGeometry(context, treeGeometry, projected, style);
+}

package/src/sources/buildAreaPolygon.js

@@ -0,0 +1,29 @@
+import { projectRing } from './projectRing.js';
+import { triangulate } from '../triangulation/triangulate.js';
+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 = [];
+  let ring, path, point, a, b, c, index, sign, i, length, nx, nz;
+  for (ring of rings) paths.push(projectRing(context, ring));
+  const points = [];
+  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);
+    if (bottom > 0) addTriangle(context, points[a], bottom, points[b], bottom, points[c], bottom, 0, -1, 0, baseColor);
+  }
+  for (index = 0; index < paths.length; index++) {
+    path = paths[index];
+    sign = isClockWise(path) === (index === 0) ? -1 : 1;
+    for (i = 0; i < path.length; i++) {
+      a = path[i], b = path[(i + 1) % path.length];
+      length = Math.hypot(b.x - a.x, b.y - a.y);
+      if (!length) continue;
+      nx = sign * (b.y - a.y) / length, nz = sign * (b.x - a.x) / length;
+      addTriangle(context, a, bottom, b, bottom, b, top, nx, 0, nz, baseColor);
+      addTriangle(context, a, bottom, b, top, a, top, nx, 0, nz, baseColor);
+    }
+  }
+}

package/src/sources/compareAreaDistance.js

@@ -0,0 +1,4 @@
+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);
+}

package/src/sources/generateTreeGeometry.js

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

package/src/sources/groundOffset.js

@@ -0,0 +1,3 @@
+export function groundOffset(point) {
+  return point.ground || 0;
+}

package/src/sources/initializeGeoJSON.js

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

package/src/sources/instanceAreaGeometry.js

@@ -0,0 +1,29 @@
+/** Compact repeated features only when reconstructed float32 positions compare equal. */
+export function instanceAreaGeometry(context) {
+  const { positions, normals, colors, featureFaces } = context;
+  if (context.backend.options.nightLight || featureFaces.length < 2) return 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);
+  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 + 3] = instance * vertices;
+    for (i = 0; i < length; i++) {
+      if (Math.fround(template[i] + offsets[instance * 4 + i % 3]) !== Math.fround(positions[start + i]) ||
+          Math.fround(normals[i]) !== Math.fround(normals[start + i]) ||
+          Math.fround(colors[i]) !== Math.fround(colors[start + i])) return context;
+    }
+  }
+  return {
+    positions: template, normals: normals.slice(0, length), colors: colors.slice(0, length),
+    instanceOffsets: offsets,
+  };
+}

package/src/sources/projectRing.js

@@ -0,0 +1,20 @@
+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({
+      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,
+    });
+  }
+  return path;
+}

package/src/sources/projectedTree.js

@@ -0,0 +1,13 @@
+import { getElevation } from '../terrain/getElevation.js';
+
+export function projectedTree(context, lon, lat) {
+  const { backend, crs, origin, metres, map } = context;
+  const point = crs.project(new L.LatLng(lat, lon));
+  const elevation = map._terrain3D ? getElevation(map._terrain3D, [lat, lon]) : undefined;
+  return {
+    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,
+  };
+}

package/src/sources/pump.js

@@ -0,0 +1,54 @@
+import { cityMapper } from '../constants/cityMapper.js';
+import { emptyNode } from "../scene/emptyNode.js";
+import { isClockWise } from "../triangulation/isClockWise.js";
+import { lampPostGeometry } from "../geometry/lampPostGeometry.js";
+import { lightGeometry } from "../geometry/lightGeometry.js";
+import { parseColor } from "../utils/parseColor.js";
+import { treeGeometry } from "../geometry/treeGeometry.js";
+import { triangulate } from "../triangulation/triangulate.js";
+import { createProgram } from '../rendering/createProgram.js';
+import { updateStatus } from './updateStatus.js';
+import { loadSource } from '../archives/loadSource.js';
+import { setParent } from '../scene/setParent.js';
+import { update } from '../scene/update.js';
+import { getElevation } from "../terrain/getElevation.js";
+import { pumpState } from '../constants/pumpState.js';
+import { compareDistance } from '../utils/compareDistance.js';
+import { buildArea } from './buildArea.js';
+
+pumpState.triangleContexts = [];
+
+/** Share four load/build slots across source layers, nearest ground blocks first. */
+export function pump(backend, map = backend._map) {
+  const shared = map && cityMapper.renderers.get(map);
+  if (!shared) return;
+  const layers = [];
+  let layer, area, center, areaBackend;
+  for (layer of shared._layers) {
+    if (Number.isFinite(layer._inflight) && layer._areas && (layer.url || layer._geojson)) layers.push(layer);
+  }
+  const pending = [];
+  for (layer of layers) {
+    for (area of 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({
+        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);
+  let inflight = 0;
+  for (layer of layers) inflight += layer._inflight;
+  for ({ layer: areaBackend, area } of pending) {
+    if (inflight >= 4) break;
+    if (areaBackend._inflight >= 2) continue;
+    area.started = true;
+    areaBackend._inflight++;
+    inflight++;
+    buildArea(areaBackend, area, map);
+  }
+  for (layer of layers) updateStatus(layer);
+}

package/src/sources/releaseArea.js

@@ -0,0 +1,22 @@
+import { setHighlight } from '../picking/setHighlight.js';
+import { showFeature } from '../picking/showFeature.js';
+import { setParent } from '../scene/setParent.js';
+import { update } from '../scene/update.js';
+
+/** Cancel pending work and dispose this block's GPU data, including any hover highlight. */
+export function releaseArea(backend, area) {
+  area.request.abort();
+  let attribute;
+  if (area.mesh) {
+    if (backend.highlightedFeature?.mesh === area.mesh) {
+      setHighlight(backend, null);
+      backend.hoveredFeature = null;
+      showFeature(backend, null);
+    }
+    setParent(area.mesh, null);
+    update(backend);
+    const geometry = area.mesh.geometry;
+    for (attribute of Object.values(geometry.attributes)) attribute.buffer.destroy();
+    area.mesh.program.pipelineCache.clear();
+  }
+}

package/src/sources/setGeoJSONData.js

@@ -0,0 +1,12 @@
+import { releaseArea } from './releaseArea.js';
+import { updateArea } from './updateArea.js';
+
+export function setGeoJSONData(layer, data) {
+  layer.options.data = data;
+  delete layer.options.url;
+  let area;
+  for (area of layer._areas.values()) releaseArea(layer, area);
+  layer._areas.clear();
+  updateArea(layer);
+  return layer;
+}

package/src/sources/setGeoJSONLayerData.js

@@ -0,0 +1,5 @@
+import { setGeoJSONData } from './setGeoJSONData.js';
+
+export function setGeoJSONLayerData(data) {
+  return setGeoJSONData(this, data);
+}

package/src/sources/sourceAreaContext.js

@@ -0,0 +1,9 @@
+export function sourceAreaContext(backend, area, map) {
+  const crs = map.options.crs, origin = crs.project(backend.location);
+  return {
+    backend, area, map, crs, origin,
+    metres: Math.cos(backend.location.lat * Math.PI / 180),
+    positions: [], normals: [], colors: [], uvs: [], featureFaces: [], lights: [],
+    supports: new Set(), skipped: 0,
+  };
+}