leaflet-city-mapper 0.0.2 → 0.0.4

package/src/scene/layerInitialize.js

@@ -0,0 +1,48 @@
+import { L } from '../globals/L.js';
+import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
+import { layerProto } from '../globals/layerProto.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { pendingInitializations } from '../globals/pendingInitializations.js';
+import { loading } from '../globals/loading.js';
+
+
+
+import { init3D } from './init3D.js';
+import { noOperation } from '../utils/noOperation.js';
+import { resolveNextInitialization } from './resolveNextInitialization.js';
+import { initializeLayer } from './initializeLayer.js';
+
+export function layerInitialize(options = sceneEmptyOptions) {
+  if (!sceneByLayer.has(this)) {
+    sceneByLayer.set(this, /* alloc */ {});
+  }
+  if (Object.getPrototypeOf(this) !== L.Layer.prototype || !options?.source) {
+    if (layerProto.value.initialize) return layerProto.value.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'
+        : /\.tiff?(?:[?#]|$)/i.test(options.source.url) ? 'cog' : '3d',
+      ...source
+    },
+    ...core
+  } = options;
+  const settings = /* alloc */ { ...source, ...core };
+  L.Util.setOptions(this, core);
+  sceneByLayer.get(this)._type = type;
+  if (type === '3d') {
+    init3D(this, settings);
+    return;
+  }
+  sceneByLayer.get(this).kind = 'pending';
+  const task = /* alloc */ { layer: this, type, settings, ready: null };
+  pendingInitializations.push(task);
+  loading.value = loading.value.catch(noOperation).then(resolveNextInitialization);
+  const ready = sceneByLayer.get(this).ready = loading.value.then(initializeLayer);
+  task.ready = ready;
+  ready.catch(noOperation);
+}

package/src/scene/layerLayerAdd.js

@@ -0,0 +1,43 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { layerProto } from '../globals/layerProto.js';
+
+
+
+import { initNativeGPU } from '../core/initNativeGPU.js';
+import { removeLayerEvents } from './removeLayerEvents.js';
+import { addSceneLayer } from './addSceneLayer.js';
+import { get3DEvents } from './get3DEvents.js';
+import { getRasterEvents } from '../raster/getRasterEvents.js';
+import { emptyEvents } from './emptyEvents.js';
+import { isNativeLayer } from './isNativeLayer.js';
+
+export function layerLayerAdd(event) {
+  const native = isNativeLayer(this);
+  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;
+  }
+  const map = event.target, state = sceneByLayer.get(this);
+  if (!map.hasLayer(this)) return;
+  if (state.kind) {
+    this._map = map;
+    this._zoomAnimated = map._zoomAnimated;
+    if (state.kind !== 'pending' && state.kind !== 'time') {
+      state.events = state.kind === 'raster' ? getRasterEvents(this) :
+        state._3d ? get3DEvents(this) : emptyEvents();
+      state.eventMap = map;
+      map.on(state.events, this);
+      this.once('remove', removeLayerEvents, this);
+    }
+    addSceneLayer(this, map);
+    this.fire('add');
+    map.fire('layeradd', /* alloc */ { layer: this });
+  } else {
+    layerProto.value._layerAdd.call(this, event);
+  }
+  if (!native || !event.target.hasLayer(this)) return;
+  initNativeGPU(this, event.target);
+}

package/src/scene/mountRenderer.js

@@ -0,0 +1,25 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { onMapChange } from './onMapChange.js';
+import { startZoom } from './startZoom.js';
+import { onZoomAnim } from './onZoomAnim.js';
+import { endZoom } from './endZoom.js';
+
+export function mountRenderer(backend, map, canvas) {
+  sceneByLayer.get(backend)._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, backend);
+  map.on('zoomstart', startZoom, backend);
+  map.on('zoomanim', onZoomAnim, backend);
+  map.on('zoomend', endZoom, backend);
+}

package/src/scene/onAdd3DLayer.js

@@ -0,0 +1,39 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import * as attach from './attach.js';
+import * as onClick from '../picking/onClick.js';
+import * as onPointerLeave from '../picking/onPointerLeave.js';
+import * as onPointerMove from '../picking/onPointerMove.js';
+import { pointerMove } from '../picking/pointerMove.js';
+import { pointerClick } from '../picking/pointerClick.js';
+import { pointerLeave } from '../picking/pointerLeave.js';
+import { attachLayer } from './attachLayer.js';
+
+/** Attach interaction immediately; initialization may finish before or after onAdd. */
+export function onAdd3DLayer(backend, map) {
+  if (!sceneByLayer.get(backend).location) {
+    const center = map.getCenter();
+    sceneByLayer.get(backend).location = /* alloc */ new L.LatLng(center.lat, center.lng);
+  }
+  if (sceneByLayer.get(backend).url || sceneByLayer.get(backend)._geojson || backend.options.tooltip || sceneByLayer.get(backend).modelUrl) {
+    sceneByLayer.get(backend).container = map.getContainer();
+    sceneByLayer.get(backend)._pointerEvents ||= /* alloc */ {
+      mousemove: pointerMove,
+      click: pointerClick,
+      mouseleave: pointerLeave,
+    };
+    if (backend.options.tooltip) {
+      sceneByLayer.get(backend)._tooltip = L.DomUtil.create('div', 'leaflet-3d-tooltip', sceneByLayer.get(backend).container);
+      sceneByLayer.get(backend)._tooltip.hidden = true;
+      sceneByLayer.get(backend)._tooltip.setAttribute('role', 'tooltip');
+      sceneByLayer.get(backend)._tooltip.setAttribute('aria-live', 'polite');
+      sceneByLayer.get(backend)._tooltip.style.cssText = 'position:absolute;z-index:600;max-width:220px;padding:10px 12px;border:1px solid #6b5140;border-radius:6px;background:#fffaf0;box-shadow:0 3px 12px #0005;color:#30251d;font:13px/1.45 sans-serif;pointer-events:none';
+    }
+    L.DomEvent.on(sceneByLayer.get(backend).container, sceneByLayer.get(backend)._pointerEvents, backend);
+  }
+  if (sceneByLayer.get(backend).root) {
+    attachLayer(backend, map);
+  }
+}

package/src/scene/onMapChange.js

@@ -0,0 +1,18 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { pendingMapChanges } from '../globals/pendingMapChanges.js';
+
+
+import { update } from './update.js';
+import { render } from "../rendering/render.js";
+
+import { renderPendingMapChange } from './renderPendingMapChange.js';
+
+/** Map movement: render within the frame of Leaflet's CSS transforms, coalescing same-tick events. */
+
+export function onMapChange() {
+  const layer = this;
+  if (sceneByLayer.get(layer)._queued) return;
+  sceneByLayer.get(layer)._queued = true;
+  pendingMapChanges.push(layer);
+  queueMicrotask(renderPendingMapChange);
+}

package/src/scene/onRemove3DLayer.js

@@ -0,0 +1,63 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { sceneTransferFields } from '../globals/sceneTransferFields.js';
+import { renderers } from '../globals/renderers.js';
+
+
+
+import * as endZoom from './endZoom.js';
+import * as onMapChange from './onMapChange.js';
+import * as onPointerLeave from '../picking/onPointerLeave.js';
+import * as onZoomAnim from './onZoomAnim.js';
+import { releaseArea } from '../sources/releaseArea.js';
+import { updateStatus } from '../sources/updateStatus.js';
+import { setParent } from './setParent.js';
+import * as startZoom from './startZoom.js';
+import { cancelUpdate } from './cancelUpdate.js';
+import { update } from './update.js';
+import { releaseSharedScene } from './releaseSharedScene.js';
+
+/** Release source meshes/UI; retain manually added objects and model CPU data. */
+export function onRemove3DLayer(backend, map) {
+  sceneByLayer.get(backend)._added = Promise.withResolvers();
+  if (sceneByLayer.get(backend).container) {
+    onPointerLeave.onPointerLeave(backend);
+    L.DomEvent.off(sceneByLayer.get(backend).container, sceneByLayer.get(backend)._pointerEvents, backend);
+    sceneByLayer.get(backend).container = null;
+  }
+  let area, key, layer;
+  for (area of sceneByLayer.get(backend)._areas.values()) releaseArea(backend, area);
+  sceneByLayer.get(backend)._areas.clear();
+  sceneByLayer.get(backend)._tooltip?.remove();
+  sceneByLayer.get(backend)._tooltip = null;
+  if (sceneByLayer.get(backend).url || sceneByLayer.get(backend)._geojson) updateStatus(backend, false);
+  const shared = sceneByLayer.get(backend)._shared;
+  if (!shared) return;
+  setParent(sceneByLayer.get(backend).root, null);
+  sceneByLayer.get(shared)._layers.delete(backend);
+  if (shared === backend) {
+    map.off('move zoom rotate pitch resize viewreset layeradd layerremove', onMapChange.onMapChange, backend);
+    map.off('zoomstart', startZoom.startZoom, backend);
+    map.off('zoomanim', onZoomAnim.onZoomAnim, backend);
+    map.off('zoomend', endZoom.endZoom, backend);
+    cancelUpdate(backend);
+    if (sceneByLayer.get(backend)._layers.size) {
+      // Keep the original scene origin and GPU resources when ownership changes.
+      const next = sceneByLayer.get(backend)._layers.values().next().value;
+      for (key of sceneTransferFields) {
+        sceneByLayer.get(next)[key] = sceneByLayer.get(backend)[key];
+        delete sceneByLayer.get(backend)[key];
+      }
+      for (layer of sceneByLayer.get(next)._layers) sceneByLayer.get(layer)._shared = next;
+      renderers.set(map, next);
+      map.on('move zoom rotate pitch resize viewreset layeradd layerremove', onMapChange.onMapChange, next);
+      map.on('zoomstart', startZoom.startZoom, next);
+      map.on('zoomanim', onZoomAnim.onZoomAnim, next);
+      map.on('zoomend', endZoom.endZoom, next);
+      update(next);
+    } else {
+      releaseSharedScene(backend, map);
+    }
+  } else update(shared);
+  sceneByLayer.get(backend)._shared = sceneByLayer.get(backend).renderer = sceneByLayer.get(backend).scene = sceneByLayer.get(backend).camera = null;
+}

package/src/scene/onZoomAnim.js

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

package/src/scene/placeEntry.js

@@ -0,0 +1,13 @@
+import { L } from '../globals/L.js';
+import { placeEntryElement } from './placeEntryElement.js';
+export function placeEntry(map, layer, element) {
+  let input, entry;
+  for (input of map.getContainer().querySelectorAll('.leaflet-control-layers-selector')) {
+    entry = map._layers[input.layerId];
+    if (input.layerId === L.Util.stamp(layer) || entry instanceof L.LayerGroup && entry.hasLayer(layer)) {
+      placeEntryElement(input, layer, element);
+      return true;
+    }
+  }
+  return false;
+}

package/src/scene/placeEntryElement.js

@@ -0,0 +1,22 @@
+import { L } from '../globals/L.js';
+
+export function placeEntryElement(input, layer, element) {
+  const label = input.closest('label');
+  if (element.classList.contains('layer-count')) {
+    if (!input.hasAttribute('aria-label')) input.setAttribute('aria-label', label.textContent.trim());
+    element.id = `leaflet-layer-count-${L.Util.stamp(layer)}`;
+    input.setAttribute('aria-describedby', element.id);
+    label.append(element);
+  }
+  else if (element.classList.contains('traffic-status')) {
+    let group = label.nextElementSibling;
+    if (!group?.classList.contains('traffic-status-group')) {
+      group = L.DomUtil.create('div', 'traffic-status-group');
+      group.style.cssText = 'display:flex;flex-wrap:wrap;gap:4px 8px;max-width:200px;margin:2px 0 6px 20px;';
+      group.setAttribute('role', 'group');
+      group.setAttribute('aria-label', 'Traffic counts');
+      label.after(group);
+    }
+    group.append(element);
+  } else label.after(element);
+}

package/src/scene/placeUnderEntry.js

@@ -0,0 +1,8 @@
+import { placeEntry } from './placeEntry.js';
+
+export function placeUnderEntry(state) {
+  const nested = placeEntry(state.map, state.layer, state.element);
+  const onPlace = state.onPlace;
+  onPlace?.(nested);
+  return nested;
+}

package/src/scene/ready.js

@@ -0,0 +1,9 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+
+export function ready(instance) {
+  return sceneByLayer.get(instance)?.ready ||
+    cameraByMap.get(instance)?.cameraReady || Promise.resolve(instance);
+}

package/src/scene/ready3D.js

@@ -0,0 +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 {
+    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

@@ -0,0 +1,14 @@
+export async function releaseRenderer(renderer, backend) {
+  try {
+    await renderer.device.queue.onSubmittedWorkDone();
+    renderer.depthTexture?.destroy();
+    renderer.roofFallbackTexture?.texture?.destroy();
+    renderer.uniformBuffer?.destroy();
+    renderer.sunlight?.texture?.destroy();
+    renderer.sunlight?.buffer?.destroy();
+    renderer.sunlight?.lights?.destroy();
+  } catch (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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,15 @@
+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 = 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

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

package/src/scene/renderPendingZoomAnimation.js

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

package/src/scene/rendererDeviceError.js

@@ -0,0 +1,14 @@
+import { rendererDevices } from '../globals/rendererDevices.js';
+import { renderers } from '../globals/renderers.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+
+export function rendererDeviceError(event) {
+  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 sceneByLayer.get(owner)._layers) layer.fire('error', /* alloc */ { error: event.error });
+}

package/src/scene/rendererDeviceLost.js

@@ -0,0 +1,14 @@
+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 = 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 sceneByLayer.get(owner)._layers) layer.fire('error', /* alloc */ { error });
+}

package/src/scene/replaceEntry.js

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

package/src/scene/reportError.js

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

package/src/scene/requestAdapter.js

@@ -0,0 +1,12 @@
+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(/* alloc */ new Error('Unable to acquire a WebGPU adapter'), backend, map);
+  return adapter;
+}

package/src/scene/requestDevice.js

@@ -0,0 +1,9 @@
+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/resolveNextInitialization.js

@@ -0,0 +1,13 @@
+import { pendingInitializations } from '../globals/pendingInitializations.js';
+
+
+import { initializerFor } from './initializerFor.js';
+
+export function resolveNextInitialization() {
+  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;
+  }
+}