leaflet-city-mapper 0.0.2 → 0.0.4

package/src/index.js

@@ -1,46 +1,71 @@
-import './utils/mapCamera.js';
+import { L } from './globals/L.js';
+import { layerProto } from './globals/layerProto.js';
+import { layerCallInitHooks as sharedLayerCallInitHooks } from './globals/layerCallInitHooks.js';
+import { removeLayer as sharedRemoveLayer } from './globals/removeLayer.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 { initializeNativeLayer } from './core/initializeNativeLayer.js';
+import { layerLayerAdd } from './scene/layerLayerAdd.js';
+import { layerInitialize } from './scene/layerInitialize.js';
+import { removeLayer } from './core/removeLayer.js';
+import { getPitch } from './camera/getPitch.js';
+import { getBearing } from './camera/getBearing.js';
+import { setRotation } from './core/setRotation.js';
+import { layerCallInitHooks } from './core/layerCallInitHooks.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;
- * types receive flat options (`{ ...source, pane, attribution }`), so `layer.options.url` etc.
+ * It initializes a native instance from the bundled source modules;
+ * types receive flat options (`{ ...source, pane, attribution }`); plugin state remains external.
  *
  * 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.
+ * - globals/: one shared value per module, imported directly by its consumers.
+ * - 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, inline FeatureCollections use 'geojson'; otherwise *.pmtiles URLs use
- * 'pmtiles' and other sources use '3d'.
+ * When `type` is omitted, inline FeatureCollections use 'geojson'; *.pmtiles URLs use
+ * 'pmtiles', *.tif/*.tiff URLs use 'cog', and other sources use '3d'.
  */
 
-const 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;
+layerProto.value = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Layer.prototype));
+sharedLayerCallInitHooks.value = L.Layer.prototype.callInitHooks;
 
 /**
  * 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', 'cog', '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 {string} [url] GLB/glTF model URL, PMTiles archive URL or supported COG URL.
+ * @property {boolean} [doubleSided=false] Show raster/terrain surfaces from below.
+ * @property {{x:number,y:number,radius:number,outside?:boolean}} [cutout] Raster screen-space circle in CSS pixels; outside keeps only the circle.
  * @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.
@@ -81,317 +106,12 @@ 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 }));
-  },
+  initialize: layerInitialize,
+  _layerAdd: layerLayerAdd,
+  callInitHooks: layerCallInitHooks,
 });
 
-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?.();
-  }
-});
+sharedRemoveLayer.value = L.Map.prototype.removeLayer;
+L.Map.include({ removeLayer, getPitch, getBearing });
+L.Marker.include({ setRotation });

package/src/lighting/cacheLightGrid.js

@@ -0,0 +1,32 @@
+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;
+  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 = /* alloc */ {
+        lights,
+        matrix: /* alloc */ [...matrix],
+        data: worldLights(lights, matrix),
+      };
+    }
+    unchanged &&= previous.meshes[i].mesh === mesh && previous.meshes[i].cache === cache;
+  }
+  if (unchanged) return previous;
+  const packed = /* alloc */ new Array(meshes.length);
+  const snapshots = /* alloc */ new Array(meshes.length);
+  for (i = 0; i < meshes.length; i++) {
+    mesh = meshes[i];
+    cache = mesh._worldLights;
+    packed[i] = cache.data;
+    snapshots[i] = /* alloc */ { mesh, cache };
+  }
+  return /* alloc */ { ...lightGrid(packed, maxBytes), meshes: snapshots };
+}

package/src/lighting/collectLightMeshes.js

@@ -0,0 +1,9 @@
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+
+
+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 || geometryEmpty) collectLightMeshes(child, fixed, moving);
+}

package/src/lighting/lightGrid.js

@@ -0,0 +1,43 @@
+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;
+  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 = /* alloc */ new Uint32Array(columns * rows),
+            next = /* alloc */ 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 /* alloc */ new Error('Streetlight grid exceeds GPU storage limit');
+    }
+    data = /* alloc */ new Float32Array(length);
+    data[0] = minX; data[1] = minZ; data[2] = cellSize;
+    data[3] = columns; data[4] = rows; data[5] = count;
+    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);
+  } else data = /* alloc */ new Float32Array(8);
+
+  return /* alloc */ { data, count };
+}

package/src/lighting/updatePointLights.js

@@ -0,0 +1,38 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+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 } = sceneByLayer.get(backend).renderer;
+  const fixed = /* alloc */ [];
+  const moving = /* alloc */ [];
+  let layer;
+  for (layer of sceneByLayer.get(backend)._layers) {
+    if (!layer.options.nightLight || !sceneByLayer.get(layer).root.visible) continue;
+    collectLightMeshes(sceneByLayer.get(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 /* alloc */ 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(/* alloc */ { 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,8 @@
+import { visitLightCells } from './visitLightCells.js';
+
+export function visitCells(packed, minX, minZ, cellSize, columns, offsets, data) {
+  let values, i;
+  for (values of packed) for (i = 0; i < values.length; i += 8) {
+    visitLightCells(values, i, minX, minZ, cellSize, columns, offsets, data);
+  }
+}

package/src/lighting/visitLightCells.js

@@ -0,0 +1,13 @@
+export function visitLightCells(values, i, minX, minZ, cellSize, columns, offsets, data) {
+  const radius = values[i + 3], x = values[i] - minX, z = values[i + 2] - minZ;
+  let y, c, key;
+  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) {
+        writeLightCell(values, i, key, offsets, data);
+      } else offsets[key]++;
+    }
+  }
+}
+import { writeLightCell } from './writeLightCell.js';

package/src/lighting/worldLights.js

@@ -0,0 +1,25 @@
+import { lightScale } from '../globals/lightScale.js';
+
+/** World-space [x, y, z, radius, r, g, b, intensity] for one mesh's point lights. */
+export function worldLights(lights, m) {
+  const values = /* alloc */ 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[i * 8] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+    values[i * 8 + 1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+    values[i * 8 + 2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+    values[i * 8 + 3] = radius;
+    values[i * 8 + 4] = color[0];
+    values[i * 8 + 5] = color[1];
+    values[i * 8 + 6] = color[2];
+    values[i * 8 + 7] = flux * lightScale;
+  }
+  return values;
+}

package/src/lighting/writeLightCell.js

@@ -0,0 +1,5 @@
+export function writeLightCell(values, i, key, offsets, data) {
+  let j, o;
+  for (j = 0, o = offsets[key] * 4; j < 8; j++) data[o + j] = values[i + j];
+  offsets[key] += 2;
+}

package/src/models/applyModelTransform.js

@@ -0,0 +1,13 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+export function applyModelTransform(backend) {
+  const model = sceneByLayer.get(backend).model;
+  if (backend.options.rotation) {
+    const [x, y = x, z = x] = backend.options.rotation;
+    model.rotation[0] = x; model.rotation[1] = y; model.rotation[2] = z;
+  }
+  if (backend.options.scale) {
+    const [x, y = x, z = x] = backend.options.scale;
+    model.scale[0] = x; model.scale[1] = y; model.scale[2] = z;
+  }
+}

package/src/models/buildModelNodes.js

@@ -0,0 +1,14 @@
+import { modelNode } from './modelNode.js';
+import { releaseModelResources } from './releaseModelResources.js';
+
+export function buildModelNodes(context, scene) {
+  const nodes = /* alloc */ [];
+  let index;
+  try {
+    for (index of scene.nodes) nodes.push(modelNode(context, index));
+  } catch (error) {
+    releaseModelResources(context);
+    throw error;
+  }
+  return nodes;
+}

package/src/models/createModelContext.js

@@ -0,0 +1,15 @@
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+import { materialFor } from './materialFor.js';
+
+export function createModelContext(backend, description, images) {
+  const context = /* alloc */ {
+    backend, description, images,
+    textures: /* alloc */ new Map(),
+    materials: /* alloc */ [],
+    active: /* alloc */ new Set(),
+    resources: /* alloc */ [],
+  };
+  let material;
+  for (material of description.materials || geometryEmpty) context.materials.push(materialFor(context, material));
+  return context;
+}