leaflet-city-mapper 0.0.3 → 0.0.5

package/src/rendering/ensureRoofBlit.js

@@ -1,40 +0,0 @@
-export function ensureRoofBlit(renderer) {
-  const device = renderer.device;
-  if (!renderer.roofBlit) {
-    const module = device.createShaderModule({
-      code: /* wgsl */ `
-      @group(0) @binding(0) var source: texture_2d<f32>;
-      @group(0) @binding(1) var sourceSampler: sampler;
-      @group(0) @binding(2) var<uniform> opacity: f32;
-      struct Varyings { @builtin(position) position: vec4f, @location(0) uv: vec2f };
-      @vertex fn vertexMain(@builtin(vertex_index) index: u32) -> Varyings {
-        let uv = vec2f(f32(index & 1u), f32(index >> 1u));
-        return Varyings(vec4f(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, 0.0, 1.0), uv);
-      }
-      @fragment fn fragmentMain(input: Varyings) -> @location(0) vec4f {
-        let color = textureSample(source, sourceSampler, input.uv);
-        return vec4f(color.rgb, color.a * opacity);
-      }
-    `
-    });
-    renderer.roofBlit = {
-      pipeline: device.createRenderPipeline({
-        layout: 'auto',
-        vertex: { module, entryPoint: 'vertexMain' },
-        fragment: {
-          module,
-          entryPoint: 'fragmentMain',
-          targets: [{
-            format: 'rgba8unorm',
-            blend: {
-              color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-              alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-            },
-          }],
-        },
-        primitive: { topology: 'triangle-strip' },
-      }),
-      sampler: device.createSampler({ magFilter: 'linear', minFilter: 'linear' }),
-    };
-  }
-}

package/src/rendering/rebuildRoofAtlas.js

@@ -1,67 +0,0 @@
-import { ensureRoofBlit } from './ensureRoofBlit.js';
-import { composeRoofAtlas } from './composeRoofAtlas.js';
-import { destroyTexture } from './destroyTexture.js';
-import { getRasterTileSize } from '../raster/getRasterTileSize.js';
-
-export function rebuildRoofAtlas(backend, rasters, signature, now) {
-  const map = backend._map, renderer = backend.renderer;
-  const tiles = [];
-  let zoom = -Infinity;
-  let layer, tile, coords, size2;
-  for (layer of rasters) for (tile of layer._rasterTiles.values()) {
-    if (tile.done && !tile.request.signal.aborted && tile.image) {
-      tiles.push({ tile, layer });
-      zoom = Math.max(zoom, tile.coords.z);
-    }
-  }
-  if (!tiles.length) zoom = map.getZoom();
-  const bounds = new L.Bounds();
-  for ({ tile: { coords }, layer } of tiles) {
-    size2 = getRasterTileSize().multiplyBy(map.getZoomScale(zoom, coords.z));
-    bounds.extend(new L.Point(coords.x, coords.y).scaleBy(size2));
-    bounds.extend(new L.Point(coords.x + 1, coords.y + 1).scaleBy(size2));
-  }
-  const min = bounds.min || map.project(backend._sceneOrigin, zoom);
-  const size = bounds.isValid() ? bounds.getSize() : new L.Point(1, 1);
-  // ponytail: cap at 4096 px; virtual textures if wide views need native detail.
-  const limit = 4096;
-  const scale = Math.min(1, limit / Math.max(size.x, size.y));
-  const width = Math.max(1, Math.ceil(size.x * scale));
-  const height = Math.max(1, Math.ceil(size.y * scale));
-  const origin = map.project(backend._sceneOrigin, zoom);
-  const pixels = map.options.crs.scale(zoom) / (40075016.68557849 * Math.cos(backend._sceneOrigin.lat * Math.PI / 180));
-  const matrix = new DOMMatrix();
-  matrix.m11 = pixels / size.x; matrix.m33 = pixels / size.y;
-  matrix.m41 = (origin.x - min.x) / size.x; matrix.m43 = (origin.y - min.y) / size.y;
-  const texture = backend._roofRaster?.texture;
-  if (texture && (texture.width !== width || texture.height !== height)) {
-    destroyTexture(backend, texture.texture);
-    texture.texture = renderer.device.createTexture({
-      size: [width, height],
-      format: 'rgba8unorm',
-      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-    });
-    texture.width = width;
-    texture.height = height;
-  }
-  backend._roofRaster = {
-    signature, updatedAt: now, matrix: Array.from(matrix.toFloat64Array()),
-    texture: texture || {
-      device: renderer.device,
-      texture: renderer.device.createTexture({
-        size: [width, height],
-        format: 'rgba8unorm',
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-      }),
-      sampler: renderer.device.createSampler({
-        addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge',
-      }),
-      samplerOptions: { addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge' },
-      image: null, width, height,
-      format: 'rgba8unorm', srgb: false, flipY: false, uploaded: null,
-    },
-  };
-  // Compose the atlas on the GPU: re-uploading a large canvas stalls Firefox for hundreds of ms.
-  ensureRoofBlit(renderer);
-  composeRoofAtlas(backend, tiles, zoom, min, size, width, height);
-}

package/src/rendering/reportCompilation.js

@@ -1,17 +0,0 @@
-export async function reportCompilation(backend, pending) {
-  let info, message;
-  try {
-    const infos = await Promise.all(pending);
-    const errors = [];
-    for (info of infos) {
-      for (message of info.messages) if (message.type === 'error') errors.push(message.message);
-    }
-    if (errors.length) {
-      backend.fire('error', {
-        error: new Error(`Unable to compile Layer3D WGSL: ${errors.join('\n')}`),
-      });
-    }
-  } catch (error) {
-    backend.fire('error', { error });
-  }
-}

package/src/rendering/sortMeshes.js

@@ -1,6 +0,0 @@
-
-import { compareMeshes } from './compareMeshes.js';
-
-export function sortMeshes(meshes) {
-  return meshes.sort(compareMeshes);
-}

package/src/rendering/synchronizeZoomView.js

@@ -1,34 +0,0 @@
-export function synchronizeZoomView(backend, now) {
-  const map = backend._map;
-  let animation, time, start;
-  if (map._animatingZoom) {
-    backend._zoomTransitions ||= new Map();
-    for (animation of map.getContainer().getAnimations({ subtree: true })) {
-      if (!(animation instanceof CSSTransition) || animation.transitionProperty !== 'transform' ||
-        !animation.effect.target.classList.contains('leaflet-zoom-animated') ||
-        backend._zoomTransitions.has(animation)) {
-        continue;
-      }
-      time = animation.currentTime || 0;
-      animation.pause();
-      backend._zoomTransitions.set(animation, { start: now, time });
-    }
-    // Freeze CSS between rendered frames: the compositor must not outrun the canvas.
-    for ([animation, { start, time }] of backend._zoomTransitions) {
-      animation.currentTime = Math.min(animation.effect.getComputedTiming().endTime, time + now - start);
-    }
-    if (backend._zoomView) {
-      const view = backend._zoomView;
-      let proxy;
-      for (animation of backend._zoomTransitions.keys()) {
-        if (animation.effect.target === map._proxy) { proxy = animation; break; }
-      }
-      const progress = proxy?.effect.getComputedTiming().progress ?? Math.min(1, (now - view.start) / 250);
-      const targetScale = map.getZoomScale(view.targetZoom, view.zoom), scale = 1 + (targetScale - 1) * progress;
-      const from = map.project(view.from, view.zoom), to = map.project(view.to, view.zoom);
-      map._cameraView = { zoom: map.getScaleZoom(scale, view.zoom),
-        center: map.unproject(from.add(to.subtract(from).multiplyBy(targetScale * progress / scale)), view.zoom) };
-      map._updateCameraOverlays();
-    }
-  }
-}

package/src/rendering/updateMapCamera.js

@@ -1,32 +0,0 @@
-import { updateCamera } from "../scene/updateCamera.js";
-import { getElevation } from "../terrain/getElevation.js";
-
-export function updateMapCamera(backend, size) {
-  const map = backend._map;
-  // Match the map's perspective, including the intermediate view of an animated zoom.
-  const zoom = map._cameraView?.zoom ?? map.getZoom(), center = map._cameraView?.center ?? map.getCenter();
-  const pixelsPerMeter = map.options.crs.scale(zoom) / (40075016.68557849 * Math.cos(backend._sceneOrigin.lat * Math.PI / 180));
-  const offset = map.project(center, zoom).subtract(map.project(backend._sceneOrigin, zoom));
-  const distance = size.y * 1.5 / pixelsPerMeter;
-  const target = [
-    offset.x / pixelsPerMeter,
-    (map._terrain3D ? getElevation(map._terrain3D, center): undefined) ?? 0,
-    offset.y / pixelsPerMeter
-  ];
-  const pitch = map.getPitch() * Math.PI / 180;
-  const bearing = map.getBearing() * Math.PI / 180;
-  const camera = backend.camera;
-  camera.fov = 2 * Math.atan(1 / 3) * 180 / Math.PI;
-  camera.aspect = size.x / size.y;
-  camera.near = Math.max(0.1, distance / 10000);
-  camera.far = Math.max(10000, distance * 10);
-  camera.position[0] = target[0] + Math.sin(bearing) * Math.sin(pitch) * distance;
-  camera.position[1] = target[1] + Math.cos(pitch) * distance;
-  camera.position[2] = target[2] + Math.cos(bearing) * Math.sin(pitch) * distance;
-  camera.up[0] = -Math.sin(bearing) * Math.cos(pitch);
-  camera.up[1] = Math.sin(pitch);
-  camera.up[2] = -Math.cos(bearing) * Math.cos(pitch);
-  camera.target[0] = target[0]; camera.target[1] = target[1]; camera.target[2] = target[2];
-  // Refresh the camera view, projection and combined projection-view matrices.
-  updateCamera(camera);
-}

package/src/rendering/updateRoofRaster.js

@@ -1,32 +0,0 @@
-import { rebuildRoofAtlas } from './rebuildRoofAtlas.js';
-import { destroyTexture } from './destroyTexture.js';
-
-export function updateRoofRaster(backend, now) {
-  const map = backend._map;
-  const rasters = [];
-  let hasRoofTexture = false;
-  let layer;
-  for (layer of backend._layers) {
-    if (layer.options.roofTexture) { hasRoofTexture = true; break; }
-  }
-  if (hasRoofTexture) {
-    for (layer of Object.values(map._layers)) {
-      if (layer._type === 'pmtiles' && layer._rasterTiles && layer.options.opacity > 0) rasters.push(layer);
-    }
-    const signatures = [];
-    let loading = false;
-    for (layer of rasters) {
-      signatures.push(`${L.Util.stamp(layer)}:${layer._rasterVersion || 0}:${layer.options.opacity}:${layer.options.zIndex}`);
-      loading ||= Boolean(layer._loadingTiles);
-    }
-    const signature = signatures.join('|');
-    if (!backend._roofRaster || backend._roofRaster.signature !== signature &&
-      (!loading || now - backend._roofRaster.updatedAt >= 50)) {
-      rebuildRoofAtlas(backend, rasters, signature, now);
-    }
-  } else if (backend._roofRaster) {
-    destroyTexture(backend, backend._roofRaster.texture.texture);
-    backend._roofRaster = null;
-  }
-  return rasters;
-}

package/src/scene/attach.js

@@ -1,161 +0,0 @@
-import { cityMapper } from '../constants/cityMapper.js';
-import { emptyNode } from './emptyNode.js';
-import { setParent } from './setParent.js';
-import { createProgram } from '../rendering/createProgram.js';
-import { endZoom } from './endZoom.js';
-import { onMapChange } from './onMapChange.js';
-import { onZoomAnim } from './onZoomAnim.js';
-import { render } from '../rendering/render.js';
-import { startZoom } from './startZoom.js';
-import { update } from './update.js';
-import { updateArea } from '../sources/updateArea.js';
-import { setTerrainHeight } from '../terrain/setTerrainHeight.js';
-import { resizeSunlight } from '../shadows/resizeSunlight.js';
-import { attachState } from '../constants/attachState.js';
-import { noOperation } from '../utils/noOperation.js';
-import { failAttachment } from './failAttachment.js';
-import { requestAdapter } from './requestAdapter.js';
-import { requestDevice } from './requestDevice.js';
-import { rendererDeviceError } from './rendererDeviceError.js';
-import { rendererDeviceLost } from './rendererDeviceLost.js';
-import { restoreObject } from './restoreObject.js';
-
-attachState.rendererDevices = new WeakMap();
-
-/** WebGPU device attachment, materials/pipelines and draw calls. */
-/**
- * Join/create this map's shared scene and rebuild GPU objects if its context changed.
- * Buffer/program handles belong to one context; typed arrays and decoded images do not.
- * @private
- */
-
-export async function attach(backend, map) {
-  let shared = cityMapper.renderers.get(map);
-  if (shared?._rendererReady) {
-    await shared._rendererReady.promise;
-  }
-  if (!shared) {
-    shared = backend;
-    backend._rendererReady = Promise.withResolvers();
-    backend._rendererReady.promise.catch(noOperation);
-    cityMapper.renderers.set(map, shared);
-    const canvas = document.createElement('canvas');
-    if (!navigator.gpu) {
-      failAttachment(new Error('Layer3D requires WebGPU'), backend, map);
-    }
-    const adapter = await requestAdapter(backend, map);
-    const device = await requestDevice(adapter, backend, map);
-    attachState.rendererDevices.set(device, map);
-    device.addEventListener('uncapturederror', rendererDeviceError);
-    Promise.all([device.lost, Promise.resolve(device)]).then(rendererDeviceLost);
-    const context = canvas.getContext('webgpu');
-    if (!context) {
-      device.destroy();
-      failAttachment(new Error('Unable to create a WebGPU canvas context'), backend, map);
-    }
-    const format = navigator.gpu.getPreferredCanvasFormat();
-    context.configure({ device, format, alphaMode: 'premultiplied' });
-    map.getContainer().querySelector('.leaflet-webgpu-warning')?.remove();
-    backend._shared = backend;
-    backend._layers = new Set();
-    backend._sceneOrigin = backend.location;
-    backend.scene = emptyNode();
-    // Perspective camera state: fov in degrees, near/far in scene metres.
-    backend.camera = {
-      position: [0, 0, 0],
-      up: [0, 1, 0],
-      target: [0, 0, 0],
-      viewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-      projectionMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-      projectionViewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-      fov: 45,
-      aspect: 1,
-      near: 0.1,
-      far: 10000,
-    };
-    backend.renderer = {
-      device,
-      context,
-      format,
-      canvas,
-      dpr: Math.min(window.devicePixelRatio, 2)
-    };
-    const layout = device.createBindGroupLayout({
-      entries: [
-        { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: 'uniform' } },
-        { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'depth' } },
-        { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' } },
-        { binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'read-only-storage' } },
-      ]
-    });
-    const buffer = backend.renderer.device.createBuffer({ size: 80, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-    const sampler = backend.renderer.device.createSampler({ compare: 'less-equal', minFilter: 'linear', magFilter: 'linear' });
-    const lights = backend.renderer.device.createBuffer({ size: 32, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
-    backend.renderer.sunlight = { layout, buffer, sampler, lights, size: 0 };
-    const values = new Float32Array(20);
-    values.set([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-    backend.renderer.device.queue.writeBuffer(buffer, 0, values);
-    resizeSunlight(backend, 1);
-    const emptyImage = document.createElement('canvas');
-    emptyImage.width = 1;
-    emptyImage.height = 1;
-    backend.renderer.roofFallbackTexture = {
-      device,
-      texture: device.createTexture({
-        size: [1, 1],
-        format: 'rgba8unorm',
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-      }),
-      sampler: device.createSampler({
-        addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge',
-      }),
-      image: emptyImage, format: 'rgba8unorm', srgb: false, uploaded: null,
-    };
-    shared._size = null;
-    canvas.className = 'leaflet-3d';
-    canvas.style.cssText = 'position:absolute;top:0;left:0;pointer-events:none';
-    canvas.setAttribute('role', 'img');
-    canvas.setAttribute('aria-label', backend.options.ariaLabel ?? '3D scene');
-    let pane = map.getPane('webgpuPane');
-    if (!pane) {
-      pane = map.createPane('webgpuPane', map.getContainer());
-      // The pitch sky uses 0 and may be inserted after this pane.
-      pane.style.zIndex = 1;
-      pane.style.pointerEvents = 'none';
-    }
-    pane.append(canvas);
-    map.on('move zoom rotate pitch resize viewreset layeradd layerremove', onMapChange, shared);
-    map.on('zoomstart', startZoom, shared);
-    map.on('zoomanim', onZoomAnim, shared);
-    map.on('zoomend', endZoom, shared);
-    backend._rendererReady.resolve();
-    delete shared._rendererReady;
-    render(shared);
-    cityMapper.renderers.set(map, shared);
-  }
-  const origin = map.options.crs.project(shared._sceneOrigin);
-  const point = map.options.crs.project(backend.location);
-  const metres = Math.cos(shared._sceneOrigin.lat * Math.PI / 180);
-  backend._terrainBaseY ??= backend.root.position[1];
-  backend.root.position[0] = (point.x - origin.x) * metres;
-  backend.root.position[1] = backend._terrainBaseY;
-  backend.root.position[2] = -(point.y - origin.y) * metres;
-  setTerrainHeight(backend);
-  // Each group's metres are measured at its own latitude, not the shared camera origin.
-  backend.root.scale.fill(metres / Math.cos(backend.location.lat * Math.PI / 180));
-  backend._shared = shared;
-  backend.renderer = shared.renderer;
-  backend.scene = shared.scene;
-  backend.camera = shared.camera;
-  shared._layers.add(backend);
-  setParent(backend.root, shared.scene);
-  const pendingObjects = [backend.root];
-  let object, i;
-  while (pendingObjects.length) {
-    object = pendingObjects.pop();
-    restoreObject(backend, shared, object);
-    for (i = object.children.length - 1; i >= 0; i--) pendingObjects.push(object.children[i]);
-  }
-  update(shared);
-  if ((backend.header && backend._type !== 'pmtiles') || backend._geojson) updateArea(backend);
-}

package/src/scene/emptyNode.js

@@ -1,11 +0,0 @@
-/** A fresh, empty scene-graph node. */
-export function emptyNode() {
-  return {
-  position: [0, 0, 0],
-  rotation: [0, 0, 0],
-  scale: [1, 1, 1],
-  worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-  children: [],
-  visible: true,
-  };
-}

package/src/scene/endZoom.js

@@ -1,16 +0,0 @@
-import { update } from './update.js';
-
-/** Stop using the outgoing level after zoomend; the next redraw uses current tiles. */
-
-export function endZoom() {
-  const backend = this;
-  let animation;
-  for (animation of backend._zoomTransitions?.keys() || []) animation.finish();
-  backend._zoomTransitions = null;
-  backend._zoomView = null;
-  delete backend._map._cameraView;
-  backend._map.getContainer().classList.remove('leaflet-camera-zoom');
-  backend._map._updateCameraOverlays();
-  backend._zoomLevel = null;
-  update(backend);
-}

package/src/scene/layerLayerAdd.js

@@ -1,21 +0,0 @@
-import { indexState } from '../constants/indexState.js';
-import { initNativeGPU } from '../core/initNativeGPU.js';
-
-export function layerLayerAdd(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;
-  }
-  indexState.layerProto._layerAdd.call(this, event);
-  if (!native || !event.target.hasLayer(this)) return;
-  initNativeGPU(this, event.target);
-}

package/src/scene/onZoomAnim.js

@@ -1,16 +0,0 @@
-import { render } from "../rendering/render.js";
-import { onZoomAnimState } from '../constants/onZoomAnimState.js';
-import { renderPendingZoomAnimation } from './renderPendingZoomAnimation.js';
-
-onZoomAnimState.pendingZoomAnimations = [];
-
-export function onZoomAnim(event) {
-  const map = this._map;
-  if (event && !this._zoomView) {
-    this._zoomView = { from: map.getCenter(), zoom: map.getZoom(), to: event.center,
-      targetZoom: event.zoom, start: performance.now() };
-    map.getContainer().classList.add('leaflet-camera-zoom');
-  }
-  onZoomAnimState.pendingZoomAnimations.push(this);
-  queueMicrotask(renderPendingZoomAnimation);
-}

package/src/scene/renderPendingZoomAnimation.js

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

package/src/scene/rendererDeviceError.js

@@ -1,10 +0,0 @@
-import { attachState } from '../constants/attachState.js';
-import { cityMapper } from '../constants/cityMapper.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;
-  let layer;
-  for (layer of owner._layers || []) layer.fire('error', { error: event.error });
-}

package/src/scene/rendererDeviceLost.js

@@ -1,11 +0,0 @@
-import { attachState } from '../constants/attachState.js';
-import { cityMapper } from '../constants/cityMapper.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}`);
-  let layer;
-  for (layer of owner._layers) layer.fire('error', { error });
-}

package/src/scene/reportError.js

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

package/src/scene/requestAdapter.js

@@ -1,12 +0,0 @@
-import { failAttachment } from './failAttachment.js';
-
-export async function requestAdapter(backend, map) {
-  let adapter;
-  try {
-    adapter = await navigator.gpu.requestAdapter();
-  } catch (error) {
-    failAttachment(error, backend, map);
-  }
-  if (!adapter) failAttachment(new Error('Unable to acquire a WebGPU adapter'), backend, map);
-  return adapter;
-}

package/src/scene/requestDevice.js

@@ -1,9 +0,0 @@
-import { failAttachment } from './failAttachment.js';
-
-export async function requestDevice(adapter, backend, map) {
-  try {
-    return await adapter.requestDevice();
-  } catch (error) {
-    failAttachment(error, backend, map);
-  }
-}

package/src/scene/update.js

@@ -1,19 +0,0 @@
-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;
-  if (!shared) return backend;
-  if (shared !== backend) {
-    update(shared);
-    return backend;
-  }
-  if (backend._frame != null) return backend;
-  const first = pendingUpdates.values().next().value;
-  pendingUpdates.add(backend);
-  backend._frame = first ? first._frame : requestAnimationFrame(renderPendingUpdates);
-  return backend;
-}

package/src/scene/updateCamera.js

@@ -1,34 +0,0 @@
-import { cross } from '../geometry/cross.js';
-
-/** Orthonormal view basis plus perspective matrices, refreshed before projecting/drawing. */
-
-export function updateCamera(camera) {
-  const z = [];
-  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];
-  }
-}

package/src/scene/updateWorldMatrix.js

@@ -1,48 +0,0 @@
-/** Compose parent*local matrices; a node.matrix overrides its position/rotation/scale. */
-
-export function updateWorldMatrix(node) {
-  const parent = node.parent;
-  const parentVersion = parent?._worldMatrixVersion || 0;
-  const matrixMode = Boolean(node.matrix);
-  let changed = node._worldParent !== parent || node._parentWorldVersion !== parentVersion ||
-    node._worldMatrixMode !== matrixMode;
-  let i, value, child;
-  if (node.matrix) {
-    const state = node._matrixState ||= new Float64Array(16);
-    for (i = 0; i < 16; i++) {
-      if (state[i] !== node.matrix[i]) changed = true;
-      state[i] = node.matrix[i];
-    }
-  } else {
-    const state = node._transformState ||= new Float64Array(9);
-    for (i = 0; i < 9; i++) {
-      value = i < 3 ? node.position[i] : i < 6 ? node.rotation[i - 3] : node.scale[i - 6];
-      if (state[i] !== value) changed = true;
-      state[i] = value;
-    }
-  }
-  if (!changed) {
-    for (child of node.children) updateWorldMatrix(child);
-    return;
-  }
-  let local;
-  if (node.matrix) local = node.matrix;
-  else {
-    const degrees = 180 / Math.PI;
-    const matrix = new DOMMatrix().translate(...node.position);
-    // Node rotations use YXZ, as did the previous renderer.
-    matrix.rotateAxisAngleSelf(0, 1, 0, node.rotation[1] * degrees);
-    matrix.rotateAxisAngleSelf(1, 0, 0, node.rotation[0] * degrees);
-    matrix.rotateAxisAngleSelf(0, 0, 1, node.rotation[2] * degrees);
-    local = matrix.scale(...node.scale).toFloat64Array();
-  }
-  const world = parent
-    ? new DOMMatrix(parent.worldMatrix).multiply(new DOMMatrix(local)).toFloat64Array()
-    : local;
-  for (i = 0; i < 16; i++) node.worldMatrix[i] = world[i];
-  node._worldParent = parent;
-  node._parentWorldVersion = parentVersion;
-  node._worldMatrixMode = matrixMode;
-  node._worldMatrixVersion = (node._worldMatrixVersion || 0) + 1;
-  for (child of node.children) updateWorldMatrix(child);
-}