leaflet-city-mapper 0.0.3 → 0.0.4

package/src/globals/shadowCamera.js

@@ -0,0 +1,15 @@
+export const shadowCamera = {
+  position: [0, 0, 0],
+  target: [0, 0, 0],
+  up: [0, 0, -1],
+  x: [0, 0, 0],
+  y: [0, 0, 0],
+  z: [0, 0, 0],
+  fov: 45,
+  aspect: 1,
+  near: 1,
+  far: 500,
+  viewMatrix: [],
+  projectionMatrix: [],
+  projectionViewMatrix: [],
+};

package/src/globals/shadowDepthLayout.js

@@ -0,0 +1,9 @@
+export const shadowDepthLayout = {
+  entries: [{
+    binding: 0,
+    visibility: null,
+    buffer: {
+      type: 'uniform'
+    }
+  }]
+};

package/src/globals/shadowHigh.js

@@ -0,0 +1 @@
+export const shadowHigh = [0, 0, 0];

package/src/globals/shadowInstanceLayouts.js

@@ -0,0 +1,4 @@
+import { positionLayout as sharedPositionLayout } from './positionLayout.js';
+import { instanceLayout as sharedInstanceLayout } from './instanceLayout.js';
+
+export const shadowInstanceLayouts = [sharedPositionLayout, sharedInstanceLayout];

package/src/globals/shadowLayouts.js

@@ -0,0 +1,3 @@
+import { positionLayout as sharedPositionLayout } from './positionLayout.js';
+
+export const shadowLayouts = [sharedPositionLayout];

package/src/globals/shadowLow.js

@@ -0,0 +1 @@
+export const shadowLow = [0, 0, 0];

package/src/globals/shadowMeshLayout.js

@@ -0,0 +1,10 @@
+export const shadowMeshLayout = {
+  entries: [{
+    binding: 0,
+    visibility: null,
+    buffer: {
+      type: 'uniform',
+      hasDynamicOffset: true
+    }
+  }]
+};

package/src/globals/shadowOffsets.js

@@ -0,0 +1 @@
+export const shadowOffsets = [null];

package/src/globals/shadowPass.js

@@ -0,0 +1,9 @@
+export const shadowPass = {
+  colorAttachments: [],
+  depthStencilAttachment: {
+    view: null,
+    depthClearValue: 1,
+    depthLoadOp: 'clear',
+    depthStoreOp: 'store'
+  }
+};

package/src/globals/shadowPipeline.js

@@ -0,0 +1,24 @@
+export const shadowPipeline = {
+  layout: null,
+  vertex: {
+    module: null,
+    entryPoint: 'main',
+    buffers: null
+  },
+  fragment: {
+    module: null,
+    entryPoint: 'fragmentMain',
+    targets: []
+  },
+  primitive: {
+    topology: 'triangle-list',
+    cullMode: 'none'
+  },
+  depthStencil: {
+    format: 'depth32float',
+    depthWriteEnabled: true,
+    depthCompare: 'less',
+    depthBias: 2,
+    depthBiasSlopeScale: 2
+  }
+};

package/src/globals/shadowPipelineLayout.js

@@ -0,0 +1,3 @@
+export const shadowPipelineLayout = {
+  bindGroupLayouts: [null, null]
+};

package/src/globals/shadowShader.js

@@ -0,0 +1,3 @@
+export const shadowShader = {
+  code: null
+};

package/src/globals/shadowTexture.js

@@ -0,0 +1,5 @@
+export const shadowTexture = {
+  size: [null, null],
+  format: 'depth32float',
+  usage: null
+};

package/src/globals/shadowValues.js

@@ -0,0 +1 @@
+export const shadowValues = new Float32Array(20);

package/src/globals/sinObliquity.js

@@ -0,0 +1,3 @@
+import { radians } from './radians.js';
+
+export const sinObliquity = Math.sin(23.4397 * radians);

package/src/globals/sizes.js

@@ -0,0 +1,6 @@
+export const sizes = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4
+};

package/src/globals/sunBindGroup.js

@@ -0,0 +1,20 @@
+export const sunBindGroup = {
+  layout: null,
+  entries: [{
+    binding: 0,
+    resource: {
+      buffer: null
+    }
+  }, {
+    binding: 1,
+    resource: null
+  }, {
+    binding: 2,
+    resource: null
+  }, {
+    binding: 3,
+    resource: {
+      buffer: null
+    }
+  }]
+};

package/src/globals/sunByMap.js

@@ -0,0 +1 @@
+export const sunByMap = new WeakMap();

package/src/globals/sunlightByControl.js

@@ -0,0 +1 @@
+export const sunlightByControl = new WeakMap();

package/src/globals/tau.js

@@ -0,0 +1 @@
+export const tau = 2 * Math.PI;

package/src/globals/terrainLayoutEntry.js

@@ -0,0 +1,8 @@
+export const terrainLayoutEntry = {
+  binding: 2,
+  visibility: null,
+  texture: {
+    sampleType: 'unfilterable-float',
+    viewDimension: '2d'
+  }
+};

package/src/globals/textureLayoutEntries.js

@@ -0,0 +1,41 @@
+export const textureLayoutEntries = [{
+    binding: null,
+    visibility: null,
+    texture: {
+      sampleType: 'float',
+      viewDimension: '2d'
+    }
+  },
+  {
+    binding: null,
+    visibility: null,
+    texture: {
+      sampleType: 'float',
+      viewDimension: '2d'
+    }
+  },
+  {
+    binding: null,
+    visibility: null,
+    texture: {
+      sampleType: 'float',
+      viewDimension: '2d'
+    }
+  },
+  {
+    binding: null,
+    visibility: null,
+    texture: {
+      sampleType: 'float',
+      viewDimension: '2d'
+    }
+  },
+  {
+    binding: null,
+    visibility: null,
+    texture: {
+      sampleType: 'float',
+      viewDimension: '2d'
+    }
+  },
+];

package/src/globals/tiledBounds.js

@@ -0,0 +1 @@
+export const tiledBounds = { value: undefined };

package/src/globals/tooltipEvents.js

@@ -0,0 +1 @@
+export const tooltipEvents = { value: undefined };

package/src/globals/tooltipPosition.js

@@ -0,0 +1 @@
+export const tooltipPosition = { value: undefined };

package/src/globals/touchByContainer.js

@@ -0,0 +1 @@
+export const touchByContainer = new WeakMap();

package/src/globals/trafficByLayer.js

@@ -0,0 +1 @@
+export const trafficByLayer = new WeakMap();

package/src/globals/trafficClocks.js

@@ -0,0 +1 @@
+export const trafficClocks = new Map();

package/src/globals/trafficEmptyList.js

@@ -0,0 +1 @@
+export const trafficEmptyList = Object.freeze([]);

package/src/globals/trafficEmptyOptions.js

@@ -0,0 +1 @@
+export const trafficEmptyOptions = Object.freeze({});

package/src/globals/trafficRouteMaterial.js

@@ -0,0 +1 @@
+export const trafficRouteMaterial = Object.freeze({ unlit: true });

package/src/{constants → globals}/trafficShader.js

@@ -1,49 +1,49 @@
-// One workgroup per vehicle shares its lane lookup and pose across all model vertices.
-export const trafficShader = /* wgsl */ `
-  struct Params { seconds: f32, side: f32, vertices: u32, total: u32 }
-  struct Vehicle { start: u32, count: u32, base: f32, speed: f32 }
-  @group(0) @binding(0) var<uniform> params: Params;
-  @group(0) @binding(1) var<storage, read> model: array<f32>;
-  @group(0) @binding(2) var<storage, read> points: array<vec4f>;
-  @group(0) @binding(3) var<storage, read> vehicles: array<Vehicle>;
-  @group(0) @binding(4) var<storage, read_write> position: array<f32>;
-  @group(0) @binding(5) var<storage, read_write> normal: array<f32>;
-  var<workgroup> center: vec3f;
-  var<workgroup> heading: vec2f;
-  @compute @workgroup_size(64)
-  fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) thread: u32) {
-    let vehicleIndex = group.x;
-    if (thread == 0u) {
-      let vehicle = vehicles[vehicleIndex];
-      let last = vehicle.start + vehicle.count - 1u;
-      let length = points[last].w;
-      var s = vehicle.base + params.seconds * vehicle.speed;
-      s -= length * floor(s / length);
-      var i = vehicle.start + 1u;
-      var end = last;
-      while (i < end) {
-        let middle = i + (end - i) / 2u;
-        if (points[middle].w < s) { i = middle + 1u; }
-        else { end = middle; }
-      }
-      let a = points[i - 1u];
-      let b = points[i];
-      let d = select(b.w - a.w, 1.0, b.w == a.w);
-      let t = (s - a.w) / d;
-      heading = (b.xy - a.xy) / d;
-      center = vec3f(a.x + (b.x - a.x) * t - heading.y * params.side,
-        a.z + (b.z - a.z) * t, a.y + (b.y - a.y) * t + heading.x * params.side);
-    }
-    workgroupBarrier();
-    for (var vertex = thread; vertex < params.vertices; vertex += 64u) {
-      let k = vertex * 3u;
-      let n = params.vertices * 3u + k;
-      let o = (vehicleIndex * params.vertices + vertex) * 3u;
-      position[o] = center.x - model[k] * heading.y - model[k + 2u] * heading.x;
-      position[o + 1u] = center.y + model[k + 1u];
-      position[o + 2u] = center.z + model[k] * heading.x - model[k + 2u] * heading.y;
-      normal[o] = -model[n] * heading.y - model[n + 2u] * heading.x;
-      normal[o + 1u] = model[n + 1u];
-      normal[o + 2u] = model[n] * heading.x - model[n + 2u] * heading.y;
-    }
-  }`;
+// One workgroup per vehicle shares its lane lookup and pose across all model vertices.
+export const trafficShader = /* wgsl */`
+  struct Params { seconds: f32, side: f32, vertices: u32, total: u32 }
+  struct Vehicle { start: u32, count: u32, base: f32, speed: f32 }
+  @group(0) @binding(0) var<uniform> params: Params;
+  @group(0) @binding(1) var<storage, read> model: array<f32>;
+  @group(0) @binding(2) var<storage, read> points: array<vec4f>;
+  @group(0) @binding(3) var<storage, read> vehicles: array<Vehicle>;
+  @group(0) @binding(4) var<storage, read_write> position: array<f32>;
+  @group(0) @binding(5) var<storage, read_write> normal: array<f32>;
+  var<workgroup> center: vec3f;
+  var<workgroup> heading: vec2f;
+  @compute @workgroup_size(64)
+  fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) thread: u32) {
+    let vehicleIndex = group.x;
+    if (thread == 0u) {
+      let vehicle = vehicles[vehicleIndex];
+      let last = vehicle.start + vehicle.count - 1u;
+      let length = points[last].w;
+      var s = vehicle.base + params.seconds * vehicle.speed;
+      s -= length * floor(s / length);
+      var i = vehicle.start + 1u;
+      var end = last;
+      while (i < end) {
+        let middle = i + (end - i) / 2u;
+        if (points[middle].w < s) { i = middle + 1u; }
+        else { end = middle; }
+      }
+      let a = points[i - 1u];
+      let b = points[i];
+      let d = select(b.w - a.w, 1.0, b.w == a.w);
+      let t = (s - a.w) / d;
+      heading = (b.xy - a.xy) / d;
+      center = vec3f(a.x + (b.x - a.x) * t - heading.y * params.side,
+        a.z + (b.z - a.z) * t, a.y + (b.y - a.y) * t + heading.x * params.side);
+    }
+    workgroupBarrier();
+    for (var vertex = thread; vertex < params.vertices; vertex += 64u) {
+      let k = vertex * 3u;
+      let n = params.vertices * 3u + k;
+      let o = (vehicleIndex * params.vertices + vertex) * 3u;
+      position[o] = center.x - model[k] * heading.y - model[k + 2u] * heading.x;
+      position[o + 1u] = center.y + model[k + 1u];
+      position[o + 2u] = center.z + model[k] * heading.x - model[k + 2u] * heading.y;
+      normal[o] = -model[n] * heading.y - model[n + 2u] * heading.x;
+      normal[o + 1u] = model[n + 1u];
+      normal[o + 2u] = model[n] * heading.x - model[n + 2u] * heading.y;
+    }
+  }`;

package/src/globals/triangleContexts.js

@@ -0,0 +1 @@
+export const triangleContexts = [];

package/src/globals/uVLayout.js

@@ -0,0 +1,8 @@
+export const uVLayout = Object.freeze({
+  arrayStride: 8,
+  attributes: Object.freeze([Object.freeze({
+    shaderLocation: 3,
+    offset: 0,
+    format: 'float32x2'
+  })])
+});

package/src/{constants → globals}/vehicles.js

@@ -1,21 +1,36 @@
-import { carModel } from '../vehicles/carModel.js';
-import { boatModel } from '../vehicles/boatModel.js';
+import { bicycleModel } from '../vehicles/bicycleModel.js';
+import { pedestrianModel } from '../vehicles/pedestrianModel.js';
 import { busModel } from '../vehicles/busModel.js';
 import { tramModel } from '../vehicles/tramModel.js';
 import { metroModel } from '../vehicles/metroModel.js';
-import { bicycleModel } from '../vehicles/bicycleModel.js';
-import { pedestrianModel } from '../vehicles/pedestrianModel.js';
+import { carModel } from '../vehicles/carModel.js';
+import { boatModel } from '../vehicles/boatModel.js';
 
 /**
  * `side`: default offset (metres) to the right of the lane centreline. `model(i)` gives the prisms of the i-th vehicle.
  * `lights`: night point lights in model space (see the night lighting grid), e.g. the pool cast by the headlights.
  */
 export const vehicles = {
-  bicycle: { side: 0.4, model: bicycleModel },
-  pedestrian: { side: 0.3, model: pedestrianModel },
-  bus: { side: 1.5, model: busModel },
-  tram: { side: 0, model: tramModel },
-  metro: { side: 0, model: metroModel },
+  bicycle: {
+    side: 0.4,
+    model: bicycleModel
+  },
+  pedestrian: {
+    side: 0.3,
+    model: pedestrianModel
+  },
+  bus: {
+    side: 1.5,
+    model: busModel
+  },
+  tram: {
+    side: 0,
+    model: tramModel
+  },
+  metro: {
+    side: 0,
+    model: metroModel
+  },
   car: {
     side: 1.8,
     model: carModel,

package/src/globals/vertexShader.js

@@ -0,0 +1,3 @@
+export const vertexShader = {
+  code: null
+};

package/src/globals/walkByMap.js

@@ -0,0 +1 @@
+export const walkByMap = new WeakMap();

package/src/globals/wantedTiles.js

@@ -0,0 +1 @@
+export const wantedTiles = new Map();

package/src/index.js

@@ -1,3 +1,8 @@
+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';
@@ -7,10 +12,15 @@ 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';
+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`
@@ -19,8 +29,8 @@ import { layerInitialize } from './scene/layerInitialize.js';
 
 /**
  * Router for `new L.Layer({ source: { type, url, ...settings }, pane, attribution })`.
- * It initializes the existing instance from the bundled source modules;
- * 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:
  * - scene/: source routing, lifecycle and graph; initializers live in their domain folders.
@@ -29,44 +39,33 @@ import { layerInitialize } from './scene/layerInitialize.js';
  * - 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.
+ * - 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'.
  */
 
-indexState.layerProto = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Layer.prototype));
-
-// 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 = [];
+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' or 'traffic'.
+ * @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.
@@ -108,8 +107,11 @@ indexState.pendingRasterLoads = [];
  */
 
 L.Layer.include({
-  _layerAdd: layerLayerAdd,
   initialize: layerInitialize,
+  _layerAdd: layerLayerAdd,
+  callInitHooks: layerCallInitHooks,
 });
 
-L.Layer.addInitHook(initializeNativeLayer);
+sharedRemoveLayer.value = L.Map.prototype.removeLayer;
+L.Map.include({ removeLayer, getPitch, getBearing });
+L.Marker.include({ setRotation });

package/src/lighting/cacheLightGrid.js

@@ -4,7 +4,6 @@ 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;
@@ -12,12 +11,22 @@ export function cacheLightGrid(meshes, previous, maxBytes) {
     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) };
+      cache = mesh._worldLights = /* alloc */ {
+        lights,
+        matrix: /* alloc */ [...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 };
+  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

@@ -1,6 +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 || []) collectLightMeshes(child, fixed, moving);
+  for (child of node.children || geometryEmpty) collectLightMeshes(child, fixed, moving);
 }

package/src/lighting/lightGrid.js

@@ -6,7 +6,7 @@ export function lightGrid(packed, maxBytes) {
   let values, i, value, key;
   for (values of packed) count += values.length / 8;
   const cellSize = 32;
-  let data = new Float32Array(8);
+  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) {
@@ -18,17 +18,18 @@ export function lightGrid(packed, maxBytes) {
     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);
+    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 new Error('Streetlight grid exceeds GPU storage limit');
+      throw /* alloc */ new Error('Streetlight grid exceeds GPU storage limit');
     }
-    data = new Float32Array(length);
-    data.set([minX, minZ, cellSize, columns, rows, count, 0, 0]);
+    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;
@@ -36,7 +37,7 @@ export function lightGrid(packed, maxBytes) {
       offset += counts[key] * 2;
     }
     visitCells(packed, minX, minZ, cellSize, columns, next, data);
-  }
+  } else data = /* alloc */ new Float32Array(8);
 
-  return { data, count };
+  return /* alloc */ { data, count };
 }

package/src/lighting/updatePointLights.js

@@ -1,26 +1,30 @@
+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 } = backend.renderer;
-  const fixed = [], moving = [];
+  const { device, sunlight: sun } = sceneByLayer.get(backend).renderer;
+  const fixed = /* alloc */ [];
+  const moving = /* alloc */ [];
   let layer;
-  for (layer of backend._layers) {
-    if (!layer.options.nightLight || !layer.root.visible) continue;
-    collectLightMeshes(layer.root, fixed, moving);
+  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 new Error('Streetlight grid exceeds GPU storage limit');
+  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({ size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+    sun.lights = device.createBuffer(/* alloc */ { size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
     bindSunlight(backend);
     uploadStatic = true;
   }