leaflet-city-mapper 0.0.2 → 0.0.4

package/src/shadows/ensureShadowPipeline.js

@@ -0,0 +1,64 @@
+import { shadowMeshLayout } from '../globals/shadowMeshLayout.js';
+import { shadowDepthLayout } from '../globals/shadowDepthLayout.js';
+import { depthBindGroup as sharedDepthBindGroup } from '../globals/depthBindGroup.js';
+import { shadowShader } from '../globals/shadowShader.js';
+import { shadowPipeline } from '../globals/shadowPipeline.js';
+import { shadowPipelineLayout } from '../globals/shadowPipelineLayout.js';
+import { shadowInstanceLayouts } from '../globals/shadowInstanceLayouts.js';
+import { shadowLayouts } from '../globals/shadowLayouts.js';
+
+export function ensureShadowPipeline(device, sun, instanced = false) {
+  const key = instanced ? 'instancePipeline' : 'pipeline';
+  if (!sun[key]) {
+    if (!sun.meshLayout) {
+      sun.meshLayout = device.createBindGroupLayout((
+        shadowMeshLayout.entries[0].visibility = GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+        shadowMeshLayout
+      ));
+
+      // Do not bind the sampled depth texture while it is a render attachment.
+      sun.depthLayout = device.createBindGroupLayout((
+        shadowDepthLayout.entries[0].visibility = GPUShaderStage.VERTEX,
+        shadowDepthLayout
+      ));
+
+      sun.depthBindGroup = device.createBindGroup((
+        sharedDepthBindGroup.layout = sun.depthLayout,
+        sharedDepthBindGroup.entries[0].resource.buffer = sun.buffer,
+        sharedDepthBindGroup
+      ));
+      sharedDepthBindGroup.layout = null;
+      sharedDepthBindGroup.entries[0].resource.buffer = null;
+    }
+    const shader = device.createShaderModule((
+      shadowShader.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; }
+      }
+    `,
+      shadowShader
+    ));
+    shadowShader.code = null;
+    const buffers = instanced ? shadowInstanceLayouts : shadowLayouts;
+    sun[key] = device.createRenderPipeline((
+      shadowPipeline.layout = device.createPipelineLayout((shadowPipelineLayout.bindGroupLayouts[0] = sun.meshLayout, shadowPipelineLayout.bindGroupLayouts[1] = sun.depthLayout, shadowPipelineLayout)),
+      shadowPipeline.vertex.module = shader,
+      shadowPipeline.vertex.buffers = buffers,
+      shadowPipeline.fragment.module = shader,
+      shadowPipeline
+    ));
+    shadowPipelineLayout.bindGroupLayouts[0] = null;
+    shadowPipelineLayout.bindGroupLayouts[1] = null;
+    shadowPipeline.layout = null;
+    shadowPipeline.vertex.module = null;
+    shadowPipeline.vertex.buffers = null;
+    shadowPipeline.fragment.module = null;
+  }
+}

package/src/shadows/meshShadowBounds.js

@@ -0,0 +1,24 @@
+export function meshShadowBounds(mesh, bounds, matrix) {
+  let cached = mesh._shadowBounds;
+  if (!cached || cached.version !== mesh._worldMatrixVersion || cached.bounds !== bounds) {
+    cached ||= mesh._shadowBounds = /* alloc */ {
+      min: /* alloc */ [Infinity, Infinity, Infinity],
+      max: /* alloc */ [-Infinity, -Infinity, -Infinity],
+    };
+    cached.version = mesh._worldMatrixVersion;
+    cached.bounds = bounds;
+    cached.min.fill(Infinity); cached.max.fill(-Infinity);
+    let i, x, y, z, w, axis, value;
+    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);
+      }
+    }
+  }
+  return cached;
+}

package/src/shadows/renderSunlight.js

@@ -0,0 +1,48 @@
+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';
+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 = sceneByLayer.get(backend).renderer, device = renderer.device, sun = renderer.sunlight;
+  if (!meshes.length || !sunlight || sunlight.altitude < 3) {
+    if (!sun.enabled) return;
+    device.queue.writeBuffer(sun.buffer, 0, disabledShadow);
+    sun.enabled = false;
+    sun.cache = null;
+    return;
+  }
+  if (shadowCacheMatches(sun, meshes, sunlight)) return;
+  const values = shadowValues;
+  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 = /* alloc */ new Map();
+  let mesh2;
+  for (mesh2 of meshes) {
+    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 = /* alloc */ { direction: /* alloc */ [...sunlight.direction], meshes: snapshots };
+}

package/src/shadows/resizeSunlight.js

@@ -0,0 +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 = 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((
+    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

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

package/src/shadows/shadowCacheMatches.js

@@ -0,0 +1,17 @@
+export function shadowCacheMatches(sun, meshes, sunlight) {
+  const cache = sun.cache;
+  let unchanged = sun.enabled && cache?.meshes.size === meshes.length;
+  let i, mesh;
+  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) {
+      if (!shadowMeshMatches(cache, mesh)) { unchanged = false; break; }
+    }
+  }
+  return unchanged;
+}
+import { shadowMeshMatches } from './shadowMeshMatches.js';

package/src/shadows/shadowMatrix.js

@@ -0,0 +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, 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++) {
+    camera.target[i] = (min[i] + max[i]) / 2;
+    camera.position[i] = camera.target[i] + sunlight.direction[i] * radius * 2;
+  }
+  camera.far = radius * 5;
+  updateCamera(camera);
+  const view = camera.viewMatrix;
+  low.fill(Infinity); high.fill(-Infinity);
+  for (i = 0; i < 8; i++) {
+    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 = 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);
+    }
+  }
+  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

@@ -0,0 +1,7 @@
+import { triangleContexts } from '../globals/triangleContexts.js';
+
+import { addTriangle } from './addTriangle.js';
+
+export function addGeneratedTriangle(...args) {
+  addTriangle(triangleContexts[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,64 @@
+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 { 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) {
+    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 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 = /* 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 in attributes) {
+    attribute = attributes[name];
+    attribute.count = attribute.data.length / attribute.size;
+    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 = /* alloc */ {
+    device,
+    attributes,
+    drawRange: /* alloc */ { start: 0, count: attributes.position.count },
+  };
+  area.mesh = /* alloc */ {
+      ...emptyNode(),
+      device,
+      geometry: meshGeometry,
+      program: createProgram(backend, /* 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),
+      }),
+      id: nextId.value++,
+      renderOrder: 0,
+      fadeDuration: 250,
+      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

@@ -0,0 +1,46 @@
+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';
+import { sourceAreaContext } from './sourceAreaContext.js';
+import { pump } from './pump.js';
+
+export async function buildArea(backend, area, map) {
+  let feature;
+  try {
+    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 /* alloc */ new Error('Invalid GeoJSON response');
+    }
+    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 /* alloc */ 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', /* alloc */ { error });
+    }
+  } finally {
+    sceneByLayer.get(backend)._inflight--;
+    pump(backend, map);
+  }
+}

package/src/sources/buildAreaFeature.js

@@ -0,0 +1,36 @@
+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 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(/* 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 (style === null) {
+    context.skipped++;
+    return;
+  }
+  const { top, bottom = 0, color = 0xd9b38c } = style;
+  const baseColor = parseColor(color);
+  const vertexStart = context.positions.length / 3;
+  if (isTree) buildAreaPoint(context, feature, lon, lat, style, 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(/* 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

@@ -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 /* 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);
+}

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 /* 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 = /* 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);
+    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,3 @@
+export function compareAreaDistance(a, b) {
+  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

@@ -0,0 +1,13 @@
+import { triangleContexts } from '../globals/triangleContexts.js';
+
+
+import { addGeneratedTriangle } from './addGeneratedTriangle.js';
+
+export function generateTreeGeometry(context, generator, point, style) {
+  triangleContexts.push(context);
+  try {
+    generator(point, style, addGeneratedTriangle);
+  } finally {
+    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,10 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { setGeoJSONLayerData } from './setGeoJSONLayerData.js';
+import { init3D } from '../scene/init3D.js';
+
+export function initializeGeoJSON(layer, options) {
+  sceneByLayer.get(layer)._geojson = true;
+  init3D(layer, options);
+}

package/src/sources/instanceAreaGeometry.js

@@ -0,0 +1,31 @@
+/** 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 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;
+    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]) ||
+          Math.fround(normals[i]) !== Math.fround(normals[start + i]) ||
+          Math.fround(colors[i]) !== Math.fround(colors[start + i])) return context;
+    }
+  }
+  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

@@ -0,0 +1,27 @@
+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 /* 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(sceneByLayer.get(backend).root.position[1])
+        ? elevation - sceneByLayer.get(backend).root.position[1] : 0,
+    });
+  }
+  return path;
+}