leaflet-city-mapper 0.0.1 → 0.0.3

package/src/geometry/quad.js

@@ -0,0 +1,4 @@
+export function quad(addTriangle, color, a, b, c, d, height, normal) {
+  addTriangle(a, height, b, height, c, height, ...normal, color);
+  addTriangle(a, height, c, height, d, height, ...normal, color);
+}

package/src/geometry/roofCoverage.js

@@ -0,0 +1,52 @@
+/** Test the mesh's ground footprint against loaded imagery, including coarse parent tiles. */
+export function roofCoverage(mesh, backend, rasters) {
+  const map = backend._map, bounds = mesh.geometry.bounds, world = mesh.worldMatrix;
+  let intersectsArchive = false;
+  let layer, zoom, origin, scale, min, max, i, x, y, z, px, py, nw, se, remaining, tile, size, left;
+  let top, pieces, x0, y0, x1, y1, l, t, r, b;
+  for (layer of rasters) {
+    zoom = layer._tileZoom, origin = map.project(backend._sceneOrigin, zoom);
+    scale = map.options.crs.scale(zoom) / (40075016.68557849 * Math.cos(backend._sceneOrigin.lat * Math.PI / 180));
+    min = [Infinity, Infinity], max = [-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];
+      px = origin.x + (world[0] * x + world[4] * y + world[8] * z + world[12]) * scale;
+      py = origin.y + (world[2] * x + world[6] * y + world[10] * z + world[14]) * scale;
+      min[0] = Math.min(min[0], px); min[1] = Math.min(min[1], py);
+      max[0] = Math.max(max[0], px); max[1] = Math.max(max[1], py);
+    }
+    if (layer.header.maxLat !== undefined && layer.header.minLon !== undefined &&
+      layer.header.minLat !== undefined && layer.header.maxLon !== undefined) {
+      nw = map.project([layer.header.maxLat, layer.header.minLon], zoom);
+      se = map.project([layer.header.minLat, layer.header.maxLon], zoom);
+      min[0] = Math.max(min[0], nw.x); min[1] = Math.max(min[1], nw.y);
+      max[0] = Math.min(max[0], se.x); max[1] = Math.min(max[1], se.y);
+      if (min[0] >= max[0] || min[1] >= max[1]) continue;
+    }
+    intersectsArchive = true;
+    remaining = [[min[0], min[1], max[0], max[1]]];
+    for (tile of layer._rasterTiles.values()) {
+      // Failed imagery already reports an error; do not hide the building indefinitely.
+      if (!tile.done && !tile.error) continue;
+      size = 256 * 2 ** (zoom - tile.coords.z);
+      left = tile.coords.x * size, top = tile.coords.y * size;
+      pieces = [];
+      for ([x0, y0, x1, y1] of remaining) {
+        l = Math.max(x0, left), t = Math.max(y0, top);
+        r = Math.min(x1, left + size), b = Math.min(y1, top + size);
+        if (l >= r || t >= b) {
+          pieces.push([x0, y0, x1, y1]);
+          continue;
+        }
+        if (y0 < t) pieces.push([x0, y0, x1, t]);
+        if (b < y1) pieces.push([x0, b, x1, y1]);
+        if (x0 < l) pieces.push([x0, t, l, b]);
+        if (r < x1) pieces.push([r, t, x1, b]);
+      }
+      remaining = pieces;
+      if (!remaining.length) return true;
+    }
+  }
+  return !intersectsArchive;
+}

package/src/geometry/samePoint.js

@@ -0,0 +1,3 @@
+export function samePoint(a, b) {
+  return Math.abs(a[0] - b[0]) < 1e-10 && Math.abs(a[1] - b[1]) < 1e-10;
+}

package/src/geometry/segment.js

@@ -0,0 +1,21 @@
+import { triangle } from './nativeTriangle.js';
+import { disk } from './disk.js';
+
+export function segment(context, a, b, startCap, endCap) {
+  const { options, width, stroke, point } = context;
+  const radius = width / 2;
+  const length = a.distanceTo(b);
+  if (!length) return;
+  const direction = b.subtract(a).divideBy(length);
+  const normal = new L.Point(-direction.y * radius, direction.x * radius);
+  if (options.lineCap === 'square') {
+    if (startCap) a = a.subtract(direction.multiplyBy(radius));
+    if (endCap) b = b.add(direction.multiplyBy(radius));
+  }
+  triangle(point, stroke, a.add(normal), a.subtract(normal), b.add(normal));
+  triangle(point, stroke, b.add(normal), a.subtract(normal), b.subtract(normal));
+  if (options.lineCap === 'round') {
+    if (startCap) disk(point, a, radius, stroke);
+    if (endCap) disk(point, b, radius, stroke);
+  }
+}

package/src/geometry/setVertexColor.js

@@ -0,0 +1,15 @@
+/**
+ * Paints the vertices `[start, end)` of a mesh and marks its color buffer dirty.
+ * @param {Object} mesh Layer-created mesh with a color attribute.
+ * @param {number} start Inclusive vertex index, not an offset into the RGB array.
+ * @param {number} end Exclusive vertex index.
+ * @param {Object} color sRGB {r,g,b}, typically from parseColor().
+ */
+
+export function setVertexColor(mesh, start, end, color) {
+  let i;
+  for (i = start; i < end; i++) {
+    mesh.geometry.attributes.color.data.set([color.r, color.g, color.b], i * 3);
+  }
+  mesh.geometry.attributes.color.needsUpdate = true;
+}

package/src/geometry/sub.js

@@ -0,0 +1,6 @@
+export function sub(a, b) {
+  const result = [];
+  let i;
+  for (i = 0; i < a.length; i++) result.push(a[i] - b[i]);
+  return result;
+}

package/src/geometry/surface.js

@@ -0,0 +1,17 @@
+import { ring } from './treeRing.js';
+import { ringDirections } from '../constants/ringDirections.js';
+
+export function surface(point, addTriangle, lowRadius, low, highRadius, high, color) {
+  const lower = ring(point, lowRadius), upper = ring(point, highRadius);
+  let i, next, slope, length, nx, nz, ny, normalX, normalZ;
+  for (i = 0; i < 8; i++) {
+    next = (i + 1) % 8;
+    slope = (lowRadius - highRadius) / (high - low);
+    length = Math.hypot(1, slope);
+    ({ nx, nz } = ringDirections[i]);
+    ny = slope / length;
+    normalX = nx / length, normalZ = nz / length;
+    if (lowRadius) addTriangle(lower[i], low, lower[next], low, upper[next], high, normalX, ny, normalZ, color);
+    if (highRadius) addTriangle(lower[i], low, upper[next], high, upper[i], high, normalX, ny, normalZ, color);
+  }
+}

package/src/geometry/treeGeometry.js

@@ -0,0 +1,31 @@
+import { roundProfile } from '../constants/roundProfile.js';
+import { parseColor } from "../utils/parseColor.js";
+import { ring } from './treeRing.js';
+import { surface } from './surface.js';
+
+/** Low-poly tree, sharing the source block's buffers, picking and terrain offset. */
+
+export function treeGeometry(point, style, addTriangle) {
+  const { top, bottom = 0, trunkRadius, crownRadius, crownBottom, crownShape = 'round' } = style;
+  if (!Number.isFinite(trunkRadius) || !Number.isFinite(crownRadius) || !Number.isFinite(crownBottom) ||
+    trunkRadius <= 0 || crownRadius < trunkRadius || crownBottom <= bottom || crownBottom >= top ||
+    !['round', 'cone'].includes(crownShape)) {
+    throw new Error('Invalid tree dimensions or crown shape');
+  }
+  const trunk = parseColor(style.trunkColor ?? 0x72513a);
+  const crown = parseColor(style.color ?? 0x4f823b);
+  surface(point, addTriangle, trunkRadius, bottom, trunkRadius, crownBottom + (top - crownBottom) * 0.25, trunk);
+  let i, low, lr, high, hr;
+  if (crownShape === 'cone') {
+    const base = ring(point, crownRadius);
+    for (i = 0; i < 8; i++) addTriangle(point, crownBottom, base[i], crownBottom,
+      base[(i + 1) % 8], crownBottom, 0, -1, 0, crown);
+    surface(point, addTriangle, crownRadius, crownBottom, 0, top, crown);
+  } else {
+    for (i = 1; i < roundProfile.length; i++) {
+      [low, lr] = roundProfile[i - 1], [high, hr] = roundProfile[i];
+      surface(point, addTriangle, lr * crownRadius, crownBottom + low * (top - crownBottom),
+        hr * crownRadius, crownBottom + high * (top - crownBottom), crown);
+    }
+  }
+}

package/src/geometry/treeRing.js

@@ -0,0 +1,14 @@
+import { ringDirections } from '../constants/ringDirections.js';
+
+export function ring(point, radius) {
+  const result = [];
+  let direction;
+  for (direction of ringDirections) {
+    result.push({
+      x: point.x + direction.x * radius,
+      y: point.y + direction.y * radius,
+      ground: point.ground,
+    });
+  }
+  return result;
+}

package/src/geometry/triangle.js

@@ -0,0 +1,12 @@
+export function triangle(position, normal, color, a, b, c, tint) {
+  const u = [], v = [];
+  let i, point, value;
+  for (i = 0; i < b.length; i++) u.push(b[i] - a[i]);
+  for (i = 0; i < c.length; i++) v.push(c[i] - a[i]);
+  const n = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]], length = Math.hypot(...n);
+  for (point of [a, b, c]) {
+    position.push(...point);
+    for (value of n) normal.push(value / length);
+    color.push(...tint);
+  }
+}

package/src/geometry/vertexNormals.js

@@ -0,0 +1,32 @@
+/** Area-weighted vertex normals, for indexed or non-indexed triangles. */
+
+export function vertexNormals(p, indices) {
+  // Accumulate area-weighted face normals for shared vertices, then normalize.
+  const normals = new Float32Array(p.length);
+  let i, a, b, c, u, v, j, n, index, length;
+  for (i = 0; i < (indices?.length || p.length / 3); i += 3) {
+    a = indices ? indices[i] : i, b = indices ? indices[i + 1] : i + 1, c = indices ? indices[i + 2] : i + 2;
+    u = [], v = [];
+    for (j = 0; j < 3; j++) {
+      u.push(p[b * 3 + j] - p[a * 3 + j]);
+      v.push(p[c * 3 + j] - p[a * 3 + j]);
+    }
+    n = [
+      u[1] * v[2] - u[2] * v[1],
+      u[2] * v[0] - u[0] * v[2],
+      u[0] * v[1] - u[1] * v[0]
+    ];
+    for (index of [a, b, c]) {
+      for (j = 0; j < 3; j++) {
+        normals[index * 3 + j] += n[j];
+      }
+    }
+  }
+  for (i = 0; i < normals.length; i += 3) {
+    length = Math.hypot(...normals.subarray(i, i + 3)) || 1;
+    for (j = 0; j < 3; j++) {
+      normals[i + j] /= length;
+    }
+  }
+  return normals;
+}

package/src/geometry/visit.js

@@ -0,0 +1,9 @@
+import { polygon } from './polygon.js';
+
+export function visit(context, coordinates, closed) {
+  if (!coordinates.length) return;
+  let child;
+  if (coordinates[0] instanceof L.LatLng) polygon(context, [coordinates], closed);
+  else if (closed && coordinates[0][0] instanceof L.LatLng) polygon(context, coordinates, closed);
+  else for (child of coordinates) visit(context, child, closed);
+}

package/src/index.js

@@ -1,82 +1,115 @@
+import './camera/mapCamera.js';
+import { init3D } from './scene/init3D.js';
+import { initNativeGPU } from './core/initNativeGPU.js';
+import { initRaster } from './raster/initRaster.js';
+import { setGeoJSONData } from './sources/setGeoJSONData.js';
+import { initTerrain } from './terrain/initTerrain.js';
+import './sunlight/initSunlight.js';
+import { initTraffic } from './traffic/initTraffic.js';
+import './walk/initWalk.js';
+import { indexState } from './constants/indexState.js';
+import { initializeNativeLayer } from './core/initializeNativeLayer.js';
+import { layerLayerAdd } from './scene/layerLayerAdd.js';
+import { layerInitialize } from './scene/layerInitialize.js';
+
 /**
  * `new L.Layer({ source: { type, url, ...settings }, pane, attribution })`: layers with a `source`
- * load their type module on first use. Subclasses are unchanged.
+ * initialize their specialized behavior on first use. Native map layers also join the WebGPU scene.
  */
 
 /**
  * Router for `new L.Layer({ source: { type, url, ...settings }, pane, attribution })`.
- * It imports the type module on demand and turns the
- * layer into it; types receive flat options (`{ ...source, pane, attribution }`), so `layer.options.url` etc.
+ * It initializes the existing instance from the bundled source modules;
+ * types receive flat options (`{ ...source, pane, attribution }`), so `layer.options.url` etc.
  *
  * Folder layout:
- * - types/: one module per `source.type`, the only files imported by this router:
- *   - 'pmtiles': raster PMTiles basemap (an L.TileLayer), draped on the terrain when present;
- *   - '3d': shared WebGPU scene with a GLB/glTF model, PMTiles GeoJSON features, or empty;
- *   - 'geojson': inline or URL-backed GeoJSON features rendered by the shared 3D scene;
- *   - 'terrain': Float32 PMTiles DEM that deforms raster tiles, buildings and the camera, plus optional bridge decks;
- *   - 'sunlight': simulation clock control, sun/moon lighting and shadows;
- *   - 'traffic': vehicles moving along GeoJSON lanes (measured flow or timetable);
- *   - 'walk': third-person pedestrian moved with the keyboard, the camera following behind.
- * - scene/: named operations for GPU resources, model/archive loading, lighting, sources, picking
- *   and rendering. They receive the layer explicitly; types/3d.js declares its delegates, without mixins.
- * - utils/: computations and scene-data helpers, independent of Leaflet layers and GPU devices.
- *   Geometry, decoders, lighting grids, terrain sampling, traffic and collisions can be tested in Node;
- *   scene transforms/picking use browser DOMMatrix/DOMPoint, and CSS colors use a canvas.
+ * - scene/: source routing, lifecycle and graph; initializers live in their domain folders.
+ * - core/: Leaflet layer integration; camera/ and controls/: camera and interaction.
+ * - sources/ and picking/: source geometry and feature interaction.
+ * - rendering/, shaders/, shadows/ and lighting/: WebGPU drawing and illumination.
+ * - geometry/, triangulation/ and collision/: mesh operations and spatial queries.
+ * - models/, archives/ and raster/: glTF loading, archive access and raster tiles.
+ * - constants/ and state/: exported module-level const and let bindings.
+ * - terrain/, sunlight/, traffic/ and walk/: feature-specific operations.
+ *   Operations receive the layer explicitly, without subclasses or prototype replacement.
  * Dataset-specific code and data (routes, timetables, API loaders) belong to the application, e.g. misc/.
  *
- * When `type` is omitted it is inferred from `source.url`: *.pmtiles -> 'pmtiles', anything else -> '3d'.
+ * When `type` is omitted, inline FeatureCollections use 'geojson'; otherwise *.pmtiles URLs use
+ * 'pmtiles' and other sources use '3d'.
  */
 
-const layerProto = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Layer.prototype));
+indexState.layerProto = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Layer.prototype));
 
-// Stand-in while the type module loads: remembers the map, renders nothing.
-const Pending = L.Layer.extend({
-  onAdd() {},
-  onRemove() {},
-});
+// One chain for every pending layer: they become real layers in creation order.
+indexState.loading = Promise.resolve();
+
+indexState.pendingInitializations = [];
+
+indexState.closestMethods = new WeakMap();
+indexState.boundsMethods = new WeakMap();
+indexState.gridInitializers = new WeakMap();
 
-// One chain for every pending layer: they become real layers in creation order, whatever the import timing.
-let loading = Promise.resolve();
+indexState.pendingGridFades = new Map();
+indexState.gridFadeFrame = null;
 
-// Shared registry: type modules (src/types) register here.
-L.Layer.types = {};
+indexState.pendingRasterLoads = [];
+
+/**
+ * The '3d' layer type: native WebGPU scene synchronized with the map camera.
+ * Layers on one map share a canvas, scene and camera; each has its own root transform.
+ *
+ * @typedef {Object} Layer3DOptions Layer options; pane and attribution remain standard L.Layer options.
+ * @property {string} [type] '3d', 'geojson', 'pmtiles', 'terrain' or 'traffic'.
+ * @property {number[]} [center] Local origin [lat,lng]; defaults to the first map center.
+ * @property {number} [terrainOffset=0] Vertical offset in metres when terrain is enabled.
+ * @property {boolean} [terrainConform=false] Fit lower model geometry to local terrain elevation.
+ * @property {'OPAQUE'|'MASK'|'BLEND'} [alphaMode] Override every glTF material's alpha mode.
+ * @property {number[]} [rotation] Model Euler rotation [x,y,z] in radians, YXZ order.
+ * @property {number[]} [scale] Model scale [x,y,z].
+ * @property {string} [url] GLB/glTF model URL or PMTiles archive URL.
+ * @property {function(Object): (ExtrusionStyle|null)} [style] Source styling; null skips a feature.
+ * @property {function(PickedFeature): (Node|string)} [tooltip] Tooltip content; strings are text.
+ * @property {string} [ariaLabel='3D scene'] Shared canvas accessible name.
+ * @property {boolean} [nightLight=false] Point sources: emissive bulbs and local illumination.
+ * @property {boolean} [nightSparkle=false] Model: sparse luminous points at night.
+ *
+ * @typedef {Object} ExtrusionStyle
+ * @property {number} top Roof height in metres; must exceed bottom.
+ * @property {number} [bottom=0] Nonnegative base height.
+ * @property {number|string|Object} [color=0xd9b38c] RGB/CSS color or linear-space {h,s,l}.
+ * @property {number} [trunkRadius] Point tree trunk radius in metres.
+ * @property {number} [crownRadius] Point tree crown radius in metres.
+ * @property {number} [crownBottom] Point tree crown base in metres.
+ * @property {string} [crownShape='round'] Point tree crown shape.
+ * @property {number|string|Object} [trunkColor=0x72513a] Point tree bark color.
+ * @property {number} [lightRadius] Point light estimated ground reach in metres.
+ * @property {number} [lightFlux] Point light luminous flux in lumens.
+ *
+ * @typedef {Object} PickedFeature
+ * @property {string|number} id Source feature id or configured model URL.
+ * @property {Object} properties GeoJSON properties or model-level glTF extras.
+ * @property {Object} mesh Intersected mesh.
+ * @property {number[]} point Intersection [x,y,z] in shared scene metres.
+ * @property {Object} [model] Configured model root; absent for source polygons.
+ * @property {number} [vertexStart] First polygon vertex in the batched mesh.
+ * @property {number} [vertexEnd] Exclusive end of the polygon's vertex range.
+ *
+ * @typedef {Object} SourceArea
+ * @property {Object} coords Archive block {z,x,y}.
+ * @property {AbortController} request Cancellation prevents attaching obsolete results.
+ * @property {boolean} [done] Geometry built successfully, including empty blocks.
+ * @property {Object|null} [mesh] Batched GPU mesh.
+ * @property {number} [buildings] Emitted feature count.
+ * @property {number} [skipped] Features skipped by style.
+ * @property {string} [error] Failed load/build message.
+ *
+ * @param {L.Layer} backend
+ * @param {Layer3DOptions} [options] World origin comes from center or the first map centre.
+ */
 
-// Core L.Layer has no initialize and init hooks get no arguments: keep the options for the hook.
 L.Layer.include({
-  initialize(options = {}) {
-    if (Object.getPrototypeOf(this) !== L.Layer.prototype || !options.source) {
-      if (layerProto.initialize) return layerProto.initialize.apply(this, arguments);
-      L.Util.setOptions(this, options);
-      return;
-    }
-    const layer = this;
-    const { source: { type = /\.pmtiles(?:[?#]|$)/i.test(options.source.url) ? 'pmtiles' : '3d', ...source }, ...core } = options;
-    const settings = { ...source, ...core };
-    // A stand-in created by the entry point before this module loaded may already be on a map.
-    const map = layer._map;
-    map?.removeLayer(layer);
-    delete layer.onAdd;
-    delete layer.onRemove;
-    if (L.Layer.types[type]) {
-      Object.setPrototypeOf(layer, L.Layer.types[type].prototype);
-      layer.options = Object.create(L.Layer.types[type].prototype.options);
-      L.Layer.types[type].prototype.initialize.call(layer, settings);
-      map?.addLayer(layer);
-      return;
-    }
-    Object.setPrototypeOf(layer, Pending.prototype);
-    L.Util.setOptions(layer, core);
-    map?.addLayer(layer);
-    // ponytail: type methods (setOpacity, add, ...) exist only once `ready` resolves.
-    loading = loading.catch(() => {}).then(() => import(`./types/${type}.js`));
-    const pending = layer.ready = loading.then(() => {
-      const map = layer._map;
-      map?.removeLayer(layer);
-      Object.setPrototypeOf(layer, L.Layer.types[type].prototype);
-      layer.options = Object.create(L.Layer.types[type].prototype.options);
-      L.Layer.types[type].prototype.initialize.call(layer, settings);
-      map?.addLayer(layer);
-      return layer.ready === pending ? layer : layer.ready;
-    });
-  },
-});
+  _layerAdd: layerLayerAdd,
+  initialize: layerInitialize,
+});
+
+L.Layer.addInitHook(initializeNativeLayer);

package/src/lighting/cacheLightGrid.js

@@ -0,0 +1,23 @@
+import { lightGrid } from './lightGrid.js';
+import { worldLights } from './worldLights.js';
+
+/** Keep fixed lamps cached when moving headlights change. */
+export function cacheLightGrid(meshes, previous, maxBytes) {
+  let unchanged = previous?.meshes.length === meshes.length;
+  const packed = [], snapshots = [];
+  let i, mesh, matrix, lights, cache, sameMatrix, j;
+  for (i = 0; i < meshes.length; i++) {
+    mesh = meshes[i], matrix = mesh.worldMatrix, lights = mesh.extras.lights;
+    cache = mesh._worldLights;
+    sameMatrix = Boolean(cache);
+    for (j = 0; j < matrix.length && sameMatrix; j++) sameMatrix = matrix[j] === cache.matrix[j];
+    if (!sameMatrix || cache.lights !== lights) {
+      cache = mesh._worldLights = { lights, matrix: [...matrix], data: worldLights(lights, matrix) };
+    }
+    unchanged &&= previous.meshes[i].mesh === mesh && previous.meshes[i].cache === cache;
+    packed.push(cache.data);
+    snapshots.push({ mesh, cache });
+  }
+  if (unchanged) return previous;
+  return { ...lightGrid(packed, maxBytes), meshes: snapshots };
+}

package/src/lighting/collectLightMeshes.js

@@ -0,0 +1,6 @@
+export function collectLightMeshes(node, fixed, moving) {
+  if (!node.visible) return;
+  if (node.extras?.lights) (node.extras.dynamicLights ? moving : fixed).push(node);
+  let child;
+  for (child of node.children || []) collectLightMeshes(child, fixed, moving);
+}

package/src/lighting/lightGrid.js

@@ -0,0 +1,42 @@
+import { visitCells } from './visitCells.js';
+
+/** Pack world-space point lights into the shader's spatial grid. */
+export function lightGrid(packed, maxBytes) {
+  let count = 0;
+  let values, i, value, key;
+  for (values of packed) count += values.length / 8;
+  const cellSize = 32;
+  let data = new Float32Array(8);
+  if (count) {
+    let minX = Infinity, minZ = Infinity, maxX = -Infinity, maxZ = -Infinity;
+    for (values of packed) for (i = 0; i < values.length; i += 8) {
+      minX = Math.min(minX, values[i] - values[i + 3]);
+      maxX = Math.max(maxX, values[i] + values[i + 3]);
+      minZ = Math.min(minZ, values[i + 2] - values[i + 3]);
+      maxZ = Math.max(maxZ, values[i + 2] + values[i + 3]);
+    }
+    const columns = Math.ceil((maxX - minX) / cellSize) + 1,
+             rows = Math.ceil((maxZ - minZ) / cellSize) + 1;
+    // Counting sort: count the lights of each cell, then fill each cell's slice.
+    const counts = new Uint32Array(columns * rows),
+            next = new Uint32Array(columns * rows);
+    visitCells(packed, minX, minZ, cellSize, columns, counts);
+    let entries = 0;
+    for (value of counts) entries += value;
+    const length = (2 + columns * rows + entries * 2) * 4;
+    if (length * 4 > maxBytes) {
+      throw new Error('Streetlight grid exceeds GPU storage limit');
+    }
+    data = new Float32Array(length);
+    data.set([minX, minZ, cellSize, columns, rows, count, 0, 0]);
+    let offset = 2 + columns * rows;
+    for (key = 0; key < counts.length; key++) if (counts[key]) {
+      data[(2 + key) * 4] = next[key] = offset;
+      data[(2 + key) * 4 + 1] = counts[key];
+      offset += counts[key] * 2;
+    }
+    visitCells(packed, minX, minZ, cellSize, columns, next, data);
+  }
+
+  return { data, count };
+}

package/src/lighting/updatePointLights.js

@@ -0,0 +1,34 @@
+import { destroyTexture } from '../rendering/destroyTexture.js';
+import { bindSunlight } from '../shadows/bindSunlight.js';
+import { cacheLightGrid } from './cacheLightGrid.js';
+import { collectLightMeshes } from './collectLightMeshes.js';
+
+export function updatePointLights(backend) {
+  const { device, sunlight: sun } = backend.renderer;
+  const fixed = [], moving = [];
+  let layer;
+  for (layer of backend._layers) {
+    if (!layer.options.nightLight || !layer.root.visible) continue;
+    collectLightMeshes(layer.root, fixed, moving);
+  }
+  const maxBytes = device.limits.maxStorageBufferBindingSize;
+  const staticGrid = cacheLightGrid(fixed, sun.staticLightGrid, maxBytes);
+  const dynamicGrid = cacheLightGrid(moving, sun.dynamicLightGrid, maxBytes);
+  if (staticGrid === sun.staticLightGrid && dynamicGrid === sun.dynamicLightGrid) return;
+  const size = staticGrid.data.byteLength + dynamicGrid.data.byteLength;
+  if (size > maxBytes) throw new Error('Streetlight grid exceeds GPU storage limit');
+  let uploadStatic = staticGrid !== sun.staticLightGrid;
+  if (sun.lights.size < size) {
+    destroyTexture(backend, sun.lights);
+    sun.lights = device.createBuffer({ size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+    bindSunlight(backend);
+    uploadStatic = true;
+  }
+  // The spare header component points to a second grid in the same storage binding.
+  staticGrid.data[6] = staticGrid.data.length / 4;
+  if (uploadStatic) device.queue.writeBuffer(sun.lights, 0, staticGrid.data);
+  device.queue.writeBuffer(sun.lights, staticGrid.data.byteLength, dynamicGrid.data);
+  sun.lightCount = staticGrid.count + dynamicGrid.count;
+  sun.staticLightGrid = staticGrid;
+  sun.dynamicLightGrid = dynamicGrid;
+}

package/src/lighting/visitCells.js

@@ -0,0 +1,15 @@
+export function visitCells(packed, minX, minZ, cellSize, columns, offsets, data) {
+  let values, i, radius, x, z, y, c, key, j, o;
+  for (values of packed) for (i = 0; i < values.length; i += 8) {
+    radius = values[i + 3], x = values[i] - minX, z = values[i + 2] - minZ;
+    for (y = Math.floor((z - radius) / cellSize); y <= Math.floor((z + radius) / cellSize); y++) {
+      for (c = Math.floor((x - radius) / cellSize); c <= Math.floor((x + radius) / cellSize); c++) {
+        key = y * columns + c;
+        if (data) {
+          for (j = 0, o = offsets[key] * 4; j < 8; j++) data[o + j] = values[i + j];
+          offsets[key] += 2;
+        } else offsets[key]++;
+      }
+    }
+  }
+}

package/src/lighting/worldLights.js

@@ -0,0 +1,27 @@
+
+/** World-space [x, y, z, radius, r, g, b, intensity] for one mesh's point lights. */
+export function worldLights(lights, m) {
+  const values = new Float32Array(lights.length * 8);
+  let i, x, y, z, radius, color, flux, w;
+  for (i = 0; i < lights.length; i++) {
+    ({
+      position: [x, y, z],
+      radius,
+      color,
+      flux
+    } = lights[i]);
+    w = m[3] * x + m[7] * y + m[11] * z + m[15];
+    values.set(
+      [
+        (m[0] * x + m[4] * y + m[8] * z + m[12]) / w,
+        (m[1] * x + m[5] * y + m[9] * z + m[13]) / w,
+       (m[2] * x + m[6] * y + m[10] * z + m[14]) / w,
+       radius,
+       ...color,
+       flux / (4 * Math.PI) * 0.03
+      ],
+       i * 8
+    );
+  }
+  return values;
+}

package/src/models/decodeModel.js

@@ -0,0 +1,45 @@
+/** Decode a static glTF JSON document or GLB v2 container. */
+import { hasUnsupportedPrimitives } from './hasUnsupportedPrimitives.js';
+
+export function decodeModel(data) {
+  const view = new DataView(data), decoder = new TextDecoder();
+  let description;
+  let offset, length, type, chunk;
+  if (view.getUint32(0, true) === 0x46546c67) {
+    // Decode GLB v2 chunks; unknown types are skipped.
+    if (view.getUint32(4, true) !== 2 || view.getUint32(8, true) !== data.byteLength) {
+      throw new Error('Invalid GLB header');
+    }
+    let binary;
+    for (offset = 12; offset < data.byteLength;) {
+      if (offset + 8 > data.byteLength) {
+        throw new Error('Truncated GLB chunk');
+      }
+      length = view.getUint32(offset, true), type = view.getUint32(offset + 4, true);
+      offset += 8;
+      if (offset + length > data.byteLength) {
+        throw new Error('Truncated GLB data');
+      }
+      chunk = data.slice(offset, offset + length);
+      if (type === 0x4e4f534a) {
+        description = JSON.parse(decoder.decode(chunk));
+      }
+      if (type === 0x004e4942) {
+        binary = chunk;
+      }
+      offset += length;
+    }
+    if (!description) {
+      throw new Error('Missing GLB JSON');
+    }
+    if (binary) {
+      description.buffers[0].binary = binary;
+    }
+  } else {
+    description = JSON.parse(decoder.decode(data));
+  }
+  if (description.skins?.length || description.animations?.length || description.extensionsRequired?.length || hasUnsupportedPrimitives(description.meshes)) {
+    throw new Error('Layer3D supports static triangle glTF models without required extensions');
+  }
+  return description;
+}

package/src/models/hasUnsupportedPrimitives.js

@@ -0,0 +1,10 @@
+export function hasUnsupportedPrimitives(meshes) {
+  if (!meshes) return false;
+  let mesh, primitive;
+  for (mesh of meshes) {
+    for (primitive of mesh.primitives) {
+      if (primitive.targets || (primitive.mode !== undefined && primitive.mode !== 4)) return true;
+    }
+  }
+  return false;
+}

package/src/models/loadBuffer.js

@@ -0,0 +1,6 @@
+export async function loadBuffer(buffer, directory) {
+  if (buffer.binary) return;
+  const response = await fetch(new URL(buffer.uri, directory).href);
+  if (!response.ok) throw new Error(`Unable to load model buffer: HTTP ${response.status}`);
+  buffer.binary = await response.arrayBuffer();
+}