leaflet-city-mapper 0.0.3 → 0.0.4

package/src/scene/ready3D.js

@@ -1,25 +1,35 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { emptyNode } from './emptyNode.js';
 import { getHeader } from '../archives/getHeader.js';
 import { attach } from './attach.js';
 import { loadModel } from '../models/loadModel.js';
 import { update } from './update.js';
 
-export async function ready3D(layer) {
-  try {
-    layer.root = 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 getHeader(layer);
-    }
-    if (layer._map) {
-      await attach(layer, layer._map);
-      layer._added.resolve();
-    }
-    if (layer.modelUrl) await loadModel(layer);
-    if (layer._shared) update(layer);
-    layer.fire('ready');
-  } catch (error) {
-    layer.fire('error', { error });
-  }
+export async function ready3D(layer) {
+  try {
+    sceneByLayer.get(layer).root = emptyNode();
+    sceneByLayer.get(layer).raycaster = /* alloc */ {
+      origin: /* alloc */ [0, 0, 0],
+      direction: /* alloc */ [0, 0, 0],
+      inverse: /* alloc */ new DOMMatrix(),
+      meshes: /* alloc */ [],
+    };
+    if (sceneByLayer.get(layer).url || sceneByLayer.get(layer)._geojson) {
+      sceneByLayer.get(layer).group = sceneByLayer.get(layer).root;
+      if (sceneByLayer.get(layer).url) sceneByLayer.get(layer).header = await getHeader(layer);
+    }
+    if (layer._map) {
+      await attach(layer, layer._map);
+      sceneByLayer.get(layer)._added.resolve();
+    }
+    if (sceneByLayer.get(layer).modelUrl) await loadModel(layer);
+    if (sceneByLayer.get(layer)._shared) update(layer);
+    layer.fire('ready');
+    return layer;
+  } catch (error) {
+    layer.fire('error', /* alloc */ { error });
+    throw error;
+  }
 }

package/src/scene/releaseRenderer.js

@@ -8,7 +8,7 @@ export async function releaseRenderer(renderer, backend) {
     renderer.sunlight?.buffer?.destroy();
     renderer.sunlight?.lights?.destroy();
   } catch (error) {
-    backend.fire('error', { error });
+    backend.fire('error', /* alloc */ { error });
   }
   renderer.device.destroy();
 }

package/src/scene/releaseSharedScene.js

@@ -0,0 +1,25 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { renderers } from '../globals/renderers.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { sceneCleanupFields } from '../globals/sceneCleanupFields.js';
+import { destroyTexture } from '../rendering/destroyTexture.js';
+import { releaseRenderer } from './releaseRenderer.js';
+
+export function releaseSharedScene(backend, map) {
+  if (sceneByLayer.get(backend)._roofRaster) destroyTexture(backend, sceneByLayer.get(backend)._roofRaster.texture.texture);
+  sceneByLayer.get(backend)._roofRaster = null;
+  if (sceneByLayer.get(backend)._zoomTransitions) {
+    let animation;
+    for (animation of sceneByLayer.get(backend)._zoomTransitions.keys()) animation.play();
+  }
+  sceneByLayer.get(backend)._zoomTransitions = null;
+  sceneByLayer.get(backend)._zoomView = null;
+  delete cameraByMap.get(map)._cameraView;
+  map.getContainer().classList.remove('leaflet-camera-zoom');
+  const renderer = sceneByLayer.get(backend).renderer;
+  renderer.canvas.remove();
+  releaseRenderer(renderer, backend);
+  renderers.delete(map);
+  let key;
+  for (key of sceneCleanupFields) delete sceneByLayer.get(backend)[key];
+}

package/src/scene/removeEntry.js

@@ -2,5 +2,7 @@ import { replaceEntry } from './replaceEntry.js';
 
 export function removeEntry() {
   this.map.off('layeradd layerremove', replaceEntry, this);
+  const group = this.element.parentElement;
   this.element.remove();
+  if (group?.classList.contains('traffic-status-group') && !group.childElementCount) group.remove();
 }

package/src/scene/removeLayerEvents.js

@@ -0,0 +1,9 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+
+export function removeLayerEvents() {
+  const state = sceneByLayer.get(this);
+  state.eventMap.off(state.events, this);
+  state.events = state.eventMap = null;
+}

package/src/scene/removeSceneLayer.js

@@ -0,0 +1,15 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+import { onRemove3DLayer } from './onRemove3DLayer.js';
+import { onPMTileRemove } from '../raster/onPMTileRemove.js';
+import { onTerrainRemove } from '../terrain/onTerrainRemove.js';
+import { removeTimeLayer } from '../sunlight/removeTimeLayer.js';
+
+export function removeSceneLayer(layer, map) {
+  switch (sceneByLayer.get(layer).kind) {
+    case '3d': return onRemove3DLayer(layer, map);
+    case 'raster': return onPMTileRemove(layer, map);
+    case 'terrain': return onTerrainRemove(layer, map);
+    case 'time': return removeTimeLayer.call(layer, map);
+  }
+}

package/src/scene/renderLayerCount.js

@@ -0,0 +1,13 @@
+export function renderLayerCount(scene, count, pending, error) {
+  const status = scene._countStatus;
+  if (scene.modelUrl) count = scene.model ? 1 : 0;
+  const loading = pending || (scene.modelUrl ? !scene.model : !scene.header && !scene._geojson);
+  const formatted = count.toLocaleString('en-US');
+  const text = error ? 'Error' : `${formatted}${loading ? '…' : ''}`;
+  const title = layerCountTitle(scene, formatted, pending, error);
+  if (status.textContent !== text) status.textContent = text;
+  if (status.title !== title) status.title = title;
+  if (error && status.getAttribute('role') !== 'alert') status.setAttribute('role', 'alert');
+  else if (!error && status.hasAttribute('role')) status.removeAttribute('role');
+}
+import { layerCountTitle } from './layerCountTitle.js';

package/src/scene/renderPendingMapChange.js

@@ -1,11 +1,15 @@
-import { onMapChangeState } from '../constants/onMapChangeState.js';
+import { pendingMapChanges } from '../globals/pendingMapChanges.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+
 import { update } from './update.js';
 import { render } from '../rendering/render.js';
 
 export function renderPendingMapChange() {
-  const layer = onMapChangeState.pendingMapChanges.shift();
-  layer._queued = false;
-  if (layer._shared !== layer || !layer.renderer) return;
+  const layer = pendingMapChanges.shift();
+  sceneByLayer.get(layer)._queued = false;
+  if (sceneByLayer.get(layer)._shared !== layer || !sceneByLayer.get(layer).renderer) return;
   if (layer._map._animatingZoom) update(layer);
   else render(layer);
 }

package/src/scene/renderPendingUpdates.js

@@ -1,14 +1,18 @@
-import { pendingUpdates } from '../constants/pendingUpdates.js';
+import { pendingUpdates } from '../globals/pendingUpdates.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+
 import { render } from '../rendering/render.js';
 
 export function renderPendingUpdates() {
-  const updates = [...pendingUpdates];
+  const updates = /* alloc */ [...pendingUpdates];
   pendingUpdates.clear();
   let failure;
   let backend;
   for (backend of updates) {
-    backend._frame = null;
-    if (backend._shared !== backend || !backend.renderer) continue;
+    sceneByLayer.get(backend)._frame = null;
+    if (sceneByLayer.get(backend)._shared !== backend || !sceneByLayer.get(backend).renderer) continue;
     try {
       render(backend);
     } catch (error) {

package/src/scene/renderPendingZoomAnimation.js

@@ -1,7 +1,11 @@
-import { onZoomAnimState } from '../constants/onZoomAnimState.js';
+import { pendingZoomAnimations } from '../globals/pendingZoomAnimations.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+
 import { render } from '../rendering/render.js';
 
 export function renderPendingZoomAnimation() {
-  const layer = onZoomAnimState.pendingZoomAnimations.shift();
-  if (layer._shared === layer && layer.renderer) render(layer);
+  const layer = pendingZoomAnimations.shift();
+  if (sceneByLayer.get(layer)._shared === layer && sceneByLayer.get(layer).renderer) render(layer);
 }

package/src/scene/rendererDeviceError.js

@@ -1,10 +1,14 @@
-import { attachState } from '../constants/attachState.js';
-import { cityMapper } from '../constants/cityMapper.js';
+import { rendererDevices } from '../globals/rendererDevices.js';
+import { renderers } from '../globals/renderers.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 
 export function rendererDeviceError(event) {
-  const map = attachState.rendererDevices.get(event.currentTarget);
-  const owner = cityMapper.renderers.get(map);
-  if (owner?.renderer?.device !== event.currentTarget) return;
+  const map = rendererDevices.get(event.currentTarget);
+  const owner = renderers.get(map);
+  if (sceneByLayer.get(owner)?.renderer?.device !== event.currentTarget) return;
+  if (!sceneByLayer.get(owner)._layers) return;
   let layer;
-  for (layer of owner._layers || []) layer.fire('error', { error: event.error });
+  for (layer of sceneByLayer.get(owner)._layers) layer.fire('error', /* alloc */ { error: event.error });
 }

package/src/scene/rendererDeviceLost.js

@@ -1,11 +1,14 @@
-import { attachState } from '../constants/attachState.js';
-import { cityMapper } from '../constants/cityMapper.js';
+import { rendererDevices } from '../globals/rendererDevices.js';
+import { renderers } from '../globals/renderers.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 
 export function rendererDeviceLost([info, device]) {
-  const map = attachState.rendererDevices.get(device);
-  const owner = cityMapper.renderers.get(map);
-  if (!owner || owner.renderer?.device !== device) return;
-  const error = new Error(`WebGPU device lost: ${info.message || info.reason}`);
+  const map = rendererDevices.get(device);
+  const owner = renderers.get(map);
+  if (!owner || sceneByLayer.get(owner).renderer?.device !== device) return;
+  const error = /* alloc */ new Error(`WebGPU device lost: ${info.message || info.reason}`);
   let layer;
-  for (layer of owner._layers) layer.fire('error', { error });
+  for (layer of sceneByLayer.get(owner)._layers) layer.fire('error', /* alloc */ { error });
 }

package/src/scene/replaceEntry.js

@@ -1,7 +1,9 @@
-import { underEntryState } from '../constants/underEntryState.js';
+import { pendingPlacements } from '../globals/pendingPlacements.js';
+
+
 import { runPlacements } from './runPlacements.js';
 
 export function replaceEntry() {
-  underEntryState.pendingPlacements.push(this);
+  pendingPlacements.push(this);
   queueMicrotask(runPlacements);
 }

package/src/scene/reportError.js

@@ -1,3 +1,3 @@
 export function reportError(source, error) {
-  source.fire('error', { error });
-}
+  source.fire('error', /* alloc */ { error });
+}

package/src/scene/requestAdapter.js

@@ -7,6 +7,6 @@ export async function requestAdapter(backend, map) {
   } catch (error) {
     failAttachment(error, backend, map);
   }
-  if (!adapter) failAttachment(new Error('Unable to acquire a WebGPU adapter'), backend, map);
+  if (!adapter) failAttachment(/* alloc */ new Error('Unable to acquire a WebGPU adapter'), backend, map);
   return adapter;
 }

package/src/scene/resolveNextInitialization.js

@@ -1,12 +1,13 @@
-import { indexState } from '../constants/indexState.js';
+import { pendingInitializations } from '../globals/pendingInitializations.js';
+
+
 import { initializerFor } from './initializerFor.js';
 
 export function resolveNextInitialization() {
-  const task = indexState.pendingInitializations.shift();
-  try {
-    task.initialize = initializerFor(task.type);
-  } catch (error) {
-    task.error = error;
+  const task = pendingInitializations.shift();
+  task.initialize = initializerFor(task.type);
+  if (!task.initialize) {
+    task.error = /* alloc */ new Error(`Unknown layer type: ${task.type}`);
   }
   return task;
 }

package/src/scene/restoreGeometry.js

@@ -0,0 +1,23 @@
+export function restoreGeometry(geometry, device) {
+  if (geometry.attributes.index?.data instanceof Uint8Array) {
+    geometry.attributes.index.data = /* alloc */ new Uint16Array(geometry.attributes.index.data);
+  }
+  let name, attribute, oldBuffer;
+  for (name in geometry.attributes) {
+    attribute = geometry.attributes[name];
+    attribute.size ||= 1;
+    attribute.count = attribute.data.length / attribute.size;
+    attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
+    oldBuffer = attribute.buffer;
+    attribute.buffer = device.createBuffer(/* alloc */ {
+      size: Math.max(4, attribute.data.byteLength),
+      usage: name === 'index'
+        ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+        : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+    oldBuffer?.destroy();
+  }
+  geometry.device = device;
+  geometry.drawRange.count = geometry.attributes.index?.count || geometry.attributes.position.count;
+}

package/src/scene/restoreMaterialTextures.js

@@ -0,0 +1,16 @@
+export function restoreMaterialTextures(material, device) {
+  let name, texture;
+  for (name in material) {
+    if (name !== 'baseTexture' && name !== 'metalTexture' && name !== 'emissiveTexture' && name !== 'occlusionTexture') continue;
+    texture = material[name];
+    if (!texture || texture.device === device) continue;
+    texture.device = device;
+    texture.texture = device.createTexture(/* alloc */ {
+      size: /* alloc */ [texture.image.width, texture.image.height],
+      format: texture.format,
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+    });
+    texture.sampler = device.createSampler(texture.samplerOptions);
+    texture.uploaded = null;
+  }
+}

package/src/scene/restoreObject.js

@@ -1,71 +1,35 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { createProgram } from '../rendering/createProgram.js';
+import { restoreGeometry } from './restoreGeometry.js';
+import { restoreMaterialTextures } from './restoreMaterialTextures.js';
 
-export function restoreObject(backend, shared, object) {
-  let name, attribute, data, size, count, normalized, key, texture;
-  if (object.geometry && object.geometry.device !== shared.renderer.device) {
+export function restoreObject(object, backend) {
+  const shared = sceneByLayer.get(backend)._shared;
+  let texture;
+  if (object.geometry && object.geometry.device !== sceneByLayer.get(shared).renderer.device) {
     const geometry = object.geometry;
     const material = object.program._layerMaterial;
-    const attributes = {};
-    for (name of ['position', 'normal', 'color', 'uv', 'index', 'instanceOffset']) {
-      attribute = geometry.attributes[name];
-      if (!attribute) continue;
-      ({ data, size, count, normalized } = attribute);
-      attributes[name] = { data: data.slice(0, count * size), size, normalized };
-    }
-    const device = shared.renderer.device;
-    if (attributes.index?.data instanceof Uint8Array) {
-      attributes.index.data = Uint16Array.from(attributes.index.data);
-    }
-    for ([name, attribute] of Object.entries(attributes)) {
-      attribute.size ||= 1;
-      attribute.count = attribute.data.length / attribute.size;
-      attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
-      attribute.buffer = device.createBuffer({
-        size: Math.max(4, attribute.data.byteLength),
-        usage: name === 'index'
-          ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
-          : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-      });
-      device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-    }
-    object.geometry = {
-      device,
-      attributes,
-      drawRange: { start: 0, count: attributes.index?.count || attributes.position.count },
-    };
-    for (attribute of Object.values(geometry.attributes)) attribute.buffer.destroy();
+    const device = sceneByLayer.get(shared).renderer.device;
+    restoreGeometry(geometry, device);
     object.bindGroup = null;
-    object.boundTextures = [];
-    for (key of ['baseTexture', 'metalTexture', 'emissiveTexture', 'occlusionTexture']) {
-      texture = material[key];
-      if (!texture || texture.device === device) continue;
-      material[key] = {
-        ...texture,
-        device,
-        texture: device.createTexture({
-          size: [texture.image.width, texture.image.height],
-          format: texture.format,
-          usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-        }),
-        sampler: device.createSampler(texture.samplerOptions),
-        uploaded: null,
-      };
-    }
+    if (object.boundTextures) object.boundTextures.length = 0;
+    else object.boundTextures = /* alloc */ [];
+    restoreMaterialTextures(material, device);
     object.program.pipelineCache.clear();
     object.program = createProgram(backend, material);
     object.device = device;
   }
-  if (object.texture && object.texture.device !== shared.renderer.device) {
-    object.texture = {
-      ...object.texture,
-      device: shared.renderer.device,
-      texture: shared.renderer.device.createTexture({
-        size: [object.texture.image.width, object.texture.image.height],
+  if (object.texture && object.texture.device !== sceneByLayer.get(shared).renderer.device) {
+    texture = object.texture;
+    texture.device = sceneByLayer.get(shared).renderer.device;
+    texture.texture = sceneByLayer.get(shared).renderer.device.createTexture(/* alloc */ {
+        size: /* alloc */ [object.texture.image.width, object.texture.image.height],
         format: object.texture.format,
         usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-      }),
-      sampler: shared.renderer.device.createSampler(object.texture.samplerOptions),
-      uploaded: null,
-    };
+      });
+    texture.sampler = sceneByLayer.get(shared).renderer.device.createSampler(texture.samplerOptions);
+    texture.uploaded = null;
   }
 }

package/src/scene/runPlacements.js

@@ -1,7 +1,9 @@
-import { underEntryState } from '../constants/underEntryState.js';
+import { pendingPlacements } from '../globals/pendingPlacements.js';
+
+
 import { placeUnderEntry } from './placeUnderEntry.js';
 
 export function runPlacements() {
-  const state = underEntryState.pendingPlacements.shift();
+  const state = pendingPlacements.shift();
   if (state?.map.hasLayer(state.layer)) placeUnderEntry(state);
 }

package/src/scene/startZoom.js

@@ -1,5 +1,8 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 /** Preserve the outgoing tile level before Leaflet changes its logical zoom. */
 
 export function startZoom() {
-  this._zoomLevel = null;
+  sceneByLayer.get(this)._zoomLevel = null;
 }

package/src/scene/underEntry.js

@@ -1,4 +1,4 @@
-import { underEntryState } from '../constants/underEntryState.js';
+
 import { placeUnderEntry } from './placeUnderEntry.js';
 import { replaceEntry } from './replaceEntry.js';
 import { removeEntry } from './removeEntry.js';
@@ -7,10 +7,9 @@ import { removeEntry } from './removeEntry.js';
  * Keeps `element` right under `layer`'s entry in the map's layers control while the layer is on the map.
  * Returns false when no layers control lists the layer.
  */
-underEntryState.pendingPlacements = [];
 
 export function underEntry(layer, element, onPlace) {
-  const state = { map: layer._map, layer, element, onPlace };
+  const state = /* alloc */ { map: layer._map, layer, element, onPlace };
   state.map.on('layeradd layerremove', replaceEntry, state);
   layer.once('remove', removeEntry, state);
   return placeUnderEntry(state);

package/src/scene/update.js

@@ -1,19 +1,23 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { pendingUpdates } from '../globals/pendingUpdates.js';
+
+
 import { render } from "../rendering/render.js";
-import { pendingUpdates } from '../constants/pendingUpdates.js';
+
 import { renderPendingUpdates } from './renderPendingUpdates.js';
 
 /** Scene graph, shared camera and frame rendering. */
 /** Content changes: render once on the next animation frame. */
 export function update(backend) {
-  const shared = backend._shared;
+  const shared = sceneByLayer.get(backend)._shared;
   if (!shared) return backend;
   if (shared !== backend) {
     update(shared);
     return backend;
   }
-  if (backend._frame != null) return backend;
+  if (sceneByLayer.get(backend)._frame != null) return backend;
   const first = pendingUpdates.values().next().value;
   pendingUpdates.add(backend);
-  backend._frame = first ? first._frame : requestAnimationFrame(renderPendingUpdates);
+  sceneByLayer.get(backend)._frame = first ? sceneByLayer.get(first)._frame : requestAnimationFrame(renderPendingUpdates);
   return backend;
 }

package/src/scene/updateCamera.js

@@ -1,34 +1,57 @@
-import { cross } from '../geometry/cross.js';
-
+import { halfRadians } from '../globals/halfRadians.js';
 /** Orthonormal view basis plus perspective matrices, refreshed before projecting/drawing. */
 
 export function updateCamera(camera) {
-  const z = [];
+  camera.x ||= /* alloc */ [0, 0, 0];
+  camera.y ||= /* alloc */ [0, 0, 0];
+  camera.z ||= /* alloc */ [0, 0, 0];
+  camera.viewTransform ||= /* alloc */ new DOMMatrix();
+  camera.projectionTransform ||= /* alloc */ new DOMMatrix();
+  camera.projectionViewTransform ||= /* alloc */ new DOMMatrix();
+  const { position, target, up, x, y, z, viewMatrix, projectionMatrix, projectionViewMatrix } = camera;
   let i, value;
-  for (i = 0; i < camera.position.length; i++) z.push(camera.position[i] - camera.target[i]);
-  const zLength = Math.hypot(...z) || 1;
-  for (i = 0; i < 3; i++) {
-    z[i] /= zLength;
-  }
-  const x = cross(camera.up, z), xLength = Math.hypot(...x) || 1;
-  for (i = 0; i < 3; i++) {
-    x[i] /= xLength;
-  }
-  const y = cross(z, x);
-  const view = new DOMMatrix([x[0], x[1], x[2], 0, y[0], y[1], y[2], 0, z[0], z[1], z[2], 0, ...camera.position, 1]).inverse().toFloat64Array();
-  for (value of view) {
-    if (!Number.isFinite(value)) throw new Error('Singular 3D transform');
-  }
-  for (i = 0; i < 16; i++) {
-    camera.viewMatrix[i] = view[i];
-  }
-  const f = 1 / Math.tan(camera.fov * Math.PI / 360), n = camera.near, r = camera.far;
-  const projection = [f / camera.aspect, 0, 0, 0, 0, f, 0, 0, 0, 0, r / (n - r), -1, 0, 0, r * n / (n - r), 0];
-  for (i = 0; i < 16; i++) {
-    camera.projectionMatrix[i] = projection[i];
-  }
-  const projectionView = new DOMMatrix(camera.projectionMatrix).multiply(new DOMMatrix(camera.viewMatrix)).toFloat64Array();
-  for (i = 0; i < 16; i++) {
-    camera.projectionViewMatrix[i] = projectionView[i];
+  z[0] = position[0] - target[0], z[1] = position[1] - target[1], z[2] = position[2] - target[2];
+  const zLength = Math.hypot(z[0], z[1], z[2]) || 1;
+  z[0] /= zLength, z[1] /= zLength, z[2] /= zLength;
+  x[0] = up[1] * z[2] - up[2] * z[1];
+  x[1] = up[2] * z[0] - up[0] * z[2];
+  x[2] = up[0] * z[1] - up[1] * z[0];
+  const xLength = Math.hypot(x[0], x[1], x[2]) || 1;
+  x[0] /= xLength, x[1] /= xLength, x[2] /= xLength;
+  y[0] = z[1] * x[2] - z[2] * x[1];
+  y[1] = z[2] * x[0] - z[0] * x[2];
+  y[2] = z[0] * x[1] - z[1] * x[0];
+  const viewTransform = camera.viewTransform;
+  viewTransform.m11 = x[0], viewTransform.m12 = x[1], viewTransform.m13 = x[2], viewTransform.m14 = 0;
+  viewTransform.m21 = y[0], viewTransform.m22 = y[1], viewTransform.m23 = y[2], viewTransform.m24 = 0;
+  viewTransform.m31 = z[0], viewTransform.m32 = z[1], viewTransform.m33 = z[2], viewTransform.m34 = 0;
+  viewTransform.m41 = position[0], viewTransform.m42 = position[1], viewTransform.m43 = position[2], viewTransform.m44 = 1;
+  viewTransform.invertSelf();
+  viewMatrix[0] = viewTransform.m11, viewMatrix[1] = viewTransform.m12, viewMatrix[2] = viewTransform.m13, viewMatrix[3] = viewTransform.m14;
+  viewMatrix[4] = viewTransform.m21, viewMatrix[5] = viewTransform.m22, viewMatrix[6] = viewTransform.m23, viewMatrix[7] = viewTransform.m24;
+  viewMatrix[8] = viewTransform.m31, viewMatrix[9] = viewTransform.m32, viewMatrix[10] = viewTransform.m33, viewMatrix[11] = viewTransform.m34;
+  viewMatrix[12] = viewTransform.m41, viewMatrix[13] = viewTransform.m42, viewMatrix[14] = viewTransform.m43, viewMatrix[15] = viewTransform.m44;
+  for (value of viewMatrix) {
+    if (!Number.isFinite(value)) throw /* alloc */ new Error('Singular 3D transform');
   }
+  const f = 1 / Math.tan(camera.fov * halfRadians), n = camera.near, r = camera.far;
+  projectionMatrix[0] = f / camera.aspect, projectionMatrix[1] = 0, projectionMatrix[2] = 0, projectionMatrix[3] = 0;
+  projectionMatrix[4] = 0, projectionMatrix[5] = f, projectionMatrix[6] = 0, projectionMatrix[7] = 0;
+  projectionMatrix[8] = 0, projectionMatrix[9] = 0, projectionMatrix[10] = r / (n - r), projectionMatrix[11] = -1;
+  projectionMatrix[12] = 0, projectionMatrix[13] = 0, projectionMatrix[14] = r * n / (n - r), projectionMatrix[15] = 0;
+  const projectionTransform = camera.projectionTransform;
+  projectionTransform.m11 = projectionMatrix[0], projectionTransform.m12 = projectionMatrix[1], projectionTransform.m13 = projectionMatrix[2], projectionTransform.m14 = projectionMatrix[3];
+  projectionTransform.m21 = projectionMatrix[4], projectionTransform.m22 = projectionMatrix[5], projectionTransform.m23 = projectionMatrix[6], projectionTransform.m24 = projectionMatrix[7];
+  projectionTransform.m31 = projectionMatrix[8], projectionTransform.m32 = projectionMatrix[9], projectionTransform.m33 = projectionMatrix[10], projectionTransform.m34 = projectionMatrix[11];
+  projectionTransform.m41 = projectionMatrix[12], projectionTransform.m42 = projectionMatrix[13], projectionTransform.m43 = projectionMatrix[14], projectionTransform.m44 = projectionMatrix[15];
+  const combined = camera.projectionViewTransform;
+  combined.m11 = projectionTransform.m11, combined.m12 = projectionTransform.m12, combined.m13 = projectionTransform.m13, combined.m14 = projectionTransform.m14;
+  combined.m21 = projectionTransform.m21, combined.m22 = projectionTransform.m22, combined.m23 = projectionTransform.m23, combined.m24 = projectionTransform.m24;
+  combined.m31 = projectionTransform.m31, combined.m32 = projectionTransform.m32, combined.m33 = projectionTransform.m33, combined.m34 = projectionTransform.m34;
+  combined.m41 = projectionTransform.m41, combined.m42 = projectionTransform.m42, combined.m43 = projectionTransform.m43, combined.m44 = projectionTransform.m44;
+  combined.multiplySelf(viewTransform);
+  projectionViewMatrix[0] = combined.m11, projectionViewMatrix[1] = combined.m12, projectionViewMatrix[2] = combined.m13, projectionViewMatrix[3] = combined.m14;
+  projectionViewMatrix[4] = combined.m21, projectionViewMatrix[5] = combined.m22, projectionViewMatrix[6] = combined.m23, projectionViewMatrix[7] = combined.m24;
+  projectionViewMatrix[8] = combined.m31, projectionViewMatrix[9] = combined.m32, projectionViewMatrix[10] = combined.m33, projectionViewMatrix[11] = combined.m34;
+  projectionViewMatrix[12] = combined.m41, projectionViewMatrix[13] = combined.m42, projectionViewMatrix[14] = combined.m43, projectionViewMatrix[15] = combined.m44;
 }

package/src/scene/updateLayerCount.js

@@ -0,0 +1,22 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { underEntry } from './underEntry.js';
+import { renderLayerCount } from './renderLayerCount.js';
+
+export function updateLayerCount(event) {
+  const layer = event.target, scene = sceneByLayer.get(layer), status = scene._countStatus;
+  if (!layer._map) return;
+  if (event.type === 'add') underEntry(layer, status);
+  let count = 0, pending = 0, error = event.error, area;
+  if (Number.isFinite(event.loaded)) {
+    count = event.loaded;
+    pending = event.pending ?? 0;
+    error ||= event.errors?.[0];
+  } else {
+    for (area of scene._areas.values()) {
+      count += area.buildings ?? 0;
+      if (!area.done && !area.error) pending++;
+      error ||= area.error;
+    }
+  }
+  renderLayerCount(scene, count, pending, error);
+}