leaflet-city-mapper 0.0.2 → 0.0.3

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,19 +1,36 @@
-import './utils/mapCamera.js';
+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 specialized utilities on first use. Native map layers also join the WebGPU scene.
+ * 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 source utilities on demand and initializes the existing instance;
+ * It initializes the existing instance from the bundled source modules;
  * types receive flat options (`{ ...source, pane, attribution }`), so `layer.options.url` etc.
  *
  * Folder layout:
- * - Vector ('3d', 'geojson') and raster ('pmtiles') initialization lives here.
- * - utils/: lazy operations for rendering, archives, geometry and specialized layers:
- *   terrain (Float32 DEM), sunlight (clock and lighting), traffic and walking.
+ * - 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/.
  *
@@ -21,19 +38,28 @@ import './utils/mapCamera.js';
  * 'pmtiles' and other sources use '3d'.
  */
 
-const layerProto = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Layer.prototype));
+indexState.layerProto = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Layer.prototype));
 
-// One chain for every pending layer: they become real layers in creation order, whatever the import timing.
-let loading = Promise.resolve();
-let sceneModules, sceneLoading, rasterModules;
-let nativeLoading;
+// 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();
+
+indexState.pendingGridFades = new Map();
+indexState.gridFadeFrame = null;
+
+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', 'sunlight', 'traffic' or 'walk'.
+ * @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.
@@ -81,317 +107,9 @@ let nativeLoading;
  * @param {Layer3DOptions} [options] World origin comes from center or the first map centre.
  */
 
-L.Layer._renderers = new WeakMap();
-L.Layer._nextId = 0;
-
 L.Layer.include({
-  _layerAdd(event) {
-    const native = !this._3d && (
-      this instanceof L.GridLayer ||
-      this instanceof L.Polyline ||
-      this instanceof L.CircleMarker ||
-      this instanceof L.Marker && !(this.options.icon instanceof L.DivIcon) ||
-      this instanceof L.ImageOverlay && !(this instanceof L.VideoOverlay) && !(this instanceof L.SVGOverlay)
-    );
-    if (native) {
-      if (this instanceof L.GridLayer || this instanceof L.ImageOverlay) {
-        this.options.crossOrigin ||= true;
-      }
-      if (this instanceof L.Marker) this.options.icon.options.crossOrigin ||= true;
-    }
-    layerProto._layerAdd.call(this, event);
-    if (!native || !event.target.hasLayer(this)) return;
-    this._initNativeGPU(event.target);
-  },
-  _initNativeGPU(map) {
-    if (this._nativeGPU) return;
-    if (!document.getElementById('leaflet-webgpu-targets')) {
-      const style = document.createElement('style');
-      style.id = 'leaflet-webgpu-targets';
-      style.textContent = '.leaflet-webgpu-target{opacity:0!important}';
-      document.head.append(style);
-    }
-    const state = this._nativeGPU = { source: this, map, hidden: new Set() };
-    state.hide = () => {
-      const htmlIcon = this instanceof L.Marker && this.options.icon instanceof L.DivIcon;
-      const targets = [htmlIcon ? null : this._icon, htmlIcon ? null : this._shadow];
-      for (const element of state.hidden) {
-        if (targets.includes(element)) continue;
-        element.classList.remove('leaflet-webgpu-target');
-        state.hidden.delete(element);
-      }
-      for (const element of targets) {
-        if (!element || state.hidden.has(element)) continue;
-        element.classList.add('leaflet-webgpu-target');
-        state.hidden.add(element);
-      }
-    };
-    state.hide();
-    this.once('remove', () => {
-      if (this._nativeGPU === state) this._nativeGPU = null;
-      state.dispose?.();
-      for (const element of state.hidden) {
-        element.classList.remove('leaflet-webgpu-target');
-      }
-    });
-
-    nativeLoading ||= import('./utils/nativeLayer.js');
-    this.ready = nativeLoading.then(({ nativeLayer }) => {
-      if (this._nativeGPU !== state) return this;
-      return nativeLayer(state);
-    });
-    this.ready.catch(error => this.fire('error', { error }));
-  },
-  _init3D(options = {}) {
-    const layer = this;
-    const ready = sceneLoading ||= Promise.all([
-      import('./utils/onAdd3DLayer.js'),
-      import('./utils/onRemove3DLayer.js'),
-      import('./utils/updateArea.js'),
-      import('./utils/onTerrainChange.js'),
-    ]).then(([add, remove, update, terrain]) => sceneModules = { ...add, ...remove, ...update, ...terrain });
-    layer._3d = true;
-    L.Util.setOptions(layer, { ariaLabel: '3D scene', ...options });
-    layer.onAdd = map => {
-      if (sceneModules) return sceneModules.onAdd3DLayer(layer, map);
-      ready.then(({ onAdd3DLayer }) => {
-        if (layer._map === map) onAdd3DLayer(layer, map);
-      }).catch(error => layer.fire('error', { error }));
-    };
-    layer.onRemove = map => {
-      if (sceneModules) return sceneModules.onRemove3DLayer(layer, map);
-      ready.then(({ onRemove3DLayer }) => onRemove3DLayer(layer, map))
-        .catch(error => layer.fire('error', { error }));
-    };
-    layer.getEvents = () => {
-      const events = {};
-      if (layer.url) {
-        events.moveend = events.zoomend = events.rotate = events.pitch = events.resize = () =>
-          sceneModules ? sceneModules.updateArea(layer) : ready.then(({ updateArea }) => updateArea(layer));
-      }
-      if (layer._geojson || layer.url) {
-        events.terrainchange = () => sceneModules
-          ? sceneModules.onTerrainChange(layer)
-          : ready.then(({ onTerrainChange }) => onTerrainChange(layer));
-      }
-      return events;
-    };
-    // ponytail: models are recognised by extension; extensionless model URLs need a .glb/.gltf suffix or query.
-    const isModel = !layer._geojson && /\.(glb|gltf)(?:[?#]|$)/i.test(layer.options.url);
-    layer.modelUrl = isModel ? layer.options.url : null;
-    layer.url = layer.options.url && !isModel && !layer._geojson ? new URL(layer.options.url, document.baseURI).href : null;
-    layer._directories = new Map();
-    if (layer.options.center) {
-      layer.location = new L.LatLng(layer.options.center[0], layer.options.center[1]);
-    }
-    /** @type {Map<string, SourceArea>} Keys are archive x/y, not screen tiles. */
-    layer._areas = new Map();
-    layer._inflight = 0;
-    layer._added = Promise.withResolvers();
-    queueMicrotask(async () => {
-      try {
-        await ready;
-        layer.root = (await import('./utils/emptyNode.js')).emptyNode();
-        layer.raycaster = { origin: [0, 0, 0], direction: [0, 0, 0] };
-        if (layer.url || layer._geojson) {
-          layer.group = layer.root;
-          if (layer.url) layer.header = await (await import('./utils/getHeader.js')).getHeader(layer);
-        }
-        if (layer._map) {
-          await (await import('./utils/attach.js')).attach(layer, layer._map);
-          layer._added.resolve();
-        }
-        if (layer.modelUrl) await (await import('./utils/loadModel.js')).loadModel(layer);
-        if (layer._shared) (await import('./utils/update.js')).update(layer);
-        layer.fire('ready');
-      } catch (error) {
-        layer.fire('error', { error });
-      }
-    });
-  },
-  _initRaster(options) {
-    const layer = this;
-    const [{ read }, { getHeader }, { getZxy }, { onPMTileAdd }, { onPMTileRemove },
-      { getRasterTileSize, updateRasterTiles }, { setPMTileOpacity }, { setPMTileZIndex }, { emptyNode }] = rasterModules;
-    layer._read = (offset, length, signal) => read(layer, offset, length, signal);
-    layer.getHeader = () => getHeader(layer);
-    layer.getZxy = (z, x, y, signal) => getZxy(layer, z, x, y, signal);
-    layer.getTileSize = () => getRasterTileSize();
-    layer.isLoading = () => layer._loadingTiles > 0;
-    layer.setOpacity = opacity => setPMTileOpacity(layer, opacity);
-    layer.setZIndex = zIndex => setPMTileZIndex(layer, zIndex);
-    layer.onAdd = map => onPMTileAdd(layer, map);
-    layer.onRemove = map => onPMTileRemove(layer, map);
-    const update = () => updateRasterTiles(layer);
-    layer.getEvents = () => ({
-      moveend: update,
-      zoomend: update,
-      rotate: update,
-      pitch: update,
-      resize: update,
-    });
-    options = { ariaLabel: 'PMTiles raster', maxZoom: 18, opacity: 1, zIndex: 0, ...options };
-    L.Util.setOptions(layer, options);
-    layer.root = emptyNode();
-    layer._areas = new Map();
-    layer._rasterTiles = new Map();
-    layer._loadingTiles = 0;
-    layer._added = Promise.withResolvers();
-    layer.url = new URL(options.url, document.baseURI).href;
-    layer._directories = new Map();
-    layer.ready = Promise.resolve(layer.options.archive || layer).then(async archive => {
-      const header = await archive.getHeader();
-      layer.options.archive = archive;
-      layer.header = header;
-      if (layer.options.maxNativeZoom === undefined) {
-        layer.options.maxNativeZoom = header.maxZoom;
-      }
-      layer.options.maxZoom = Math.max(layer.options.minZoom || 0, layer.options.maxZoom);
-      layer.fire('ready');
-      return layer;
-    }).catch(error => {
-      layer.fire('error', { error });
-      throw error;
-    });
-  },
-  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 {
-      source: {
-        type = options.source.data?.type === 'FeatureCollection'
-          ? 'geojson'
-          : /\.pmtiles(?:[?#]|$)/i.test(options.source.url) ? 'pmtiles' : '3d',
-        ...source
-      },
-      ...core
-    } = options;
-    const settings = { ...source, ...core };
-    L.Util.setOptions(this, core);
-    this._type = type;
-    if (type === '3d') {
-      this._init3D(settings);
-      return;
-    }
-    if (type === 'pmtiles' && rasterModules) {
-      this._initRaster(settings);
-      return;
-    }
-    this.onAdd = () => {};
-    this.onRemove = () => {};
-    // ponytail: type methods (setOpacity, add, ...) exist only once `ready` resolves.
-    loading = loading.catch(() => {}).then(async () => {
-      switch (type) {
-        case 'geojson': {
-          const { setGeoJSONData } = await import('./utils/setGeoJSONData.js');
-          return (layer, options) => {
-            layer._geojson = true;
-            layer.setData = data => setGeoJSONData(layer, data);
-            layer._init3D(options);
-          };
-        }
-        case 'pmtiles': {
-          rasterModules = await Promise.all([
-            import('./utils/read.js'),
-            import('./utils/getHeader.js'),
-            import('./utils/getZxy.js'),
-            import('./utils/onPMTileAdd.js'),
-            import('./utils/onPMTileRemove.js'),
-            import('./utils/rasterTiles.js'),
-            import('./utils/setPMTileOpacity.js'),
-            import('./utils/setPMTileZIndex.js'),
-            import('./utils/emptyNode.js'),
-          ]);
-          return (layer, options) => layer._initRaster(options);
-        }
-        case 'terrain':
-          return (await import('./utils/initTerrain.js')).initTerrain;
-        case 'sunlight':
-          return (await import('./utils/initSunlight.js')).initSunlight;
-        case 'traffic':
-          return (await import('./utils/initTraffic.js')).initTraffic;
-        case 'walk':
-          return (await import('./utils/initWalk.js')).initWalk;
-        default:
-          throw new Error(`Unknown layer type: ${type}`);
-      }
-    });
-    const ready = this.ready = loading.then(initialize => {
-      const map = this._map;
-      map?.removeLayer(this);
-      delete this.onAdd;
-      delete this.onRemove;
-      initialize(this, settings);
-      map?.addLayer(this);
-      return this.ready === ready ? this : this.ready;
-    });
-    ready.catch(error => this.fire('error', { error }));
-  },
+  _layerAdd: layerLayerAdd,
+  initialize: layerInitialize,
 });
 
-L.Layer.addInitHook(function () {
-  if (this instanceof L.Polyline || this instanceof L.CircleMarker) {
-    const refresh = () => this._nativeGPU?.refresh?.();
-    this.beforeAdd = this.onAdd = this.onRemove = this._updateBounds = () => {};
-    this.getEvents = () => ({});
-    // Leaflet mutators call this renderer contract, but no SVG/Canvas renderer is created.
-    this._renderer = {
-      options: { tolerance: 0 },
-      _updatePath: refresh,
-      _updateStyle: refresh,
-      _bringToFront: () => this._nativeGPU?.reorder?.(true),
-      _bringToBack: () => this._nativeGPU?.reorder?.(false),
-    };
-    if (this instanceof L.Polyline) {
-      const closest = this.closestLayerPoint;
-      this.closestLayerPoint = function (point) {
-        this._project();
-        this._parts = this._rings;
-        return closest.call(this, point);
-      };
-    }
-    if (this instanceof L.Circle) {
-      const getBounds = this.getBounds;
-      this.getBounds = function () {
-        this._project();
-        return getBounds.call(this);
-      };
-    }
-  } else if (this instanceof L.GridLayer) {
-    const initialize = this._initContainer;
-    this._initContainer = function () {
-      initialize.call(this);
-      this._container.remove();
-    };
-    this._updateOpacity = function () {
-      if (!this._map) return;
-      const now = Date.now();
-      let fading = false, prune = false;
-      for (const tile of Object.values(this._tiles || {})) {
-        if (!tile.current || !tile.loaded) continue;
-        tile._gpuOpacity = this._map._fadeAnimated ? Math.min(1, (now - tile.loaded) / 200) : 1;
-        if (tile._gpuOpacity < 1) fading = true;
-        else if (!tile.active) {
-          this._onOpaqueTile(tile);
-          tile.active = true;
-          prune = true;
-        }
-      }
-      if (prune && !this._noPrune) this._pruneTiles();
-      this._nativeGPU?.refresh?.();
-      cancelAnimationFrame(this._fadeFrame);
-      if (fading) this._fadeFrame = requestAnimationFrame(() => this._updateOpacity());
-    };
-  } else if (this instanceof L.ImageOverlay && !(this instanceof L.VideoOverlay) && !(this instanceof L.SVGOverlay)) {
-    this.onAdd = function () {
-      if (!this._image) this._initImage();
-      if (this._image.complete && this._image.naturalWidth) queueMicrotask(() => this.fire('load'));
-    };
-    this.onRemove = () => {};
-    this.getEvents = () => ({});
-    this._reset = () => this._nativeGPU?.refresh?.();
-  }
-});
+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();
+}