leaflet-city-mapper 0.0.4 → 0.0.6

package/src/workers/settleGeometryWorker.js

@@ -0,0 +1,10 @@
+export function settleGeometryWorker(task, event) {
+  if (event.type === 'abort') task.reject(task.signal.reason);
+  else if (event.type === 'error') task.reject(/* alloc */ new Error(`Geometry worker failed: ${event.message}`));
+  else if (event.type === 'messageerror') task.reject(/* alloc */ new Error('Unable to receive geometry worker buffers'));
+  else if (event.data.error) {
+    const error = /* alloc */ new Error(event.data.error.message);
+    error.name = event.data.error.name;
+    task.reject(error);
+  } else task.resolve(event.data);
+}

package/src/workers/startGeometryWorker.js

@@ -0,0 +1,16 @@
+import { settleGeometryWorker } from './settleGeometryWorker.js';
+
+export function startGeometryWorker(task, resolve, reject) {
+  task.resolve = resolve;
+  task.reject = reject;
+  task.onEvent = settleGeometryWorker.bind(null, task);
+  task.worker.addEventListener('message', task.onEvent);
+  task.worker.addEventListener('error', task.onEvent);
+  task.worker.addEventListener('messageerror', task.onEvent);
+  task.signal.addEventListener('abort', task.onEvent, /* alloc */ { once: true });
+  if (task.signal.aborted) {
+    reject(task.signal.reason);
+    return;
+  }
+  task.worker.postMessage(task.input);
+}

package/src/core/bringNativeLayerToBack.js

@@ -1,8 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-import { reorderNativeLayer } from './reorderNativeLayer.js';
-
-export function bringNativeLayerToBack(layer = this) {
-  const native = sceneByLayer.get(layer)?._nativeGPU;
-  if (native?.backend && !native.disposed) reorderNativeLayer.call(native, false);
-}

package/src/core/bringNativeLayerToFront.js

@@ -1,8 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-import { reorderNativeLayer } from './reorderNativeLayer.js';
-
-export function bringNativeLayerToFront(layer = this) {
-  const native = sceneByLayer.get(layer)?._nativeGPU;
-  if (native?.backend && !native.disposed) reorderNativeLayer.call(native, true);
-}

package/src/core/current.js

@@ -1,6 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-
-export function current(state) {
-  return sceneByLayer.get(state.source)._nativeGPU === state && state.map.hasLayer(state.source);
-}

package/src/core/localPosition.js

@@ -1,10 +0,0 @@
-import { radians } from '../globals/radians.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-
-export function localPosition(state, latlng) {
-  const { map, backend } = state, crs = map.options.crs;
-  const origin = crs.project(sceneByLayer.get(backend).location), point = crs.project(latlng);
-  const metres = Math.cos(sceneByLayer.get(backend).location.lat * radians);
-  return /* alloc */ [(point.x - origin.x) * metres, 0, -(point.y - origin.y) * metres];
-}

package/src/core/readyNativeGPU.js

@@ -1,9 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-
-import { nativeLayer } from './nativeLayer.js';
-
-export function readyNativeGPU(state) {
-  if (sceneByLayer.get(state.source)._nativeGPU !== state) return state.source;
-  return nativeLayer(state);
-}

package/src/core/reorderNativeLayer.js

@@ -1,9 +0,0 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
-
-
-import { refreshNativeLayer } from './refreshNativeLayer.js';
-
-export function reorderNativeLayer(front) {
-  this.order = front ? ++cameraByMap.get(this.map)._nativeGPUOrder : --cameraByMap.get(this.map)._nativeGPUBack;
-  refreshNativeLayer(this);
-}

package/src/core/scheduleGridFade.js

@@ -1,14 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { pendingGridFades } from '../globals/pendingGridFades.js';
-import { gridFadeFrame } from '../globals/gridFadeFrame.js';
-
-
-
-import { runGridFades } from './runGridFades.js';
-
-export function scheduleGridFade(layer) {
-  sceneByLayer.get(layer)._fadeVersion = (sceneByLayer.get(layer)._fadeVersion || 0) + 1;
-  pendingGridFades.set(layer, sceneByLayer.get(layer)._fadeVersion);
-  if (gridFadeFrame.value === null) gridFadeFrame.value = requestAnimationFrame(runGridFades);
-  sceneByLayer.get(layer)._fadeFrame = gridFadeFrame.value;
-}

package/src/core/updateNativeLayerView.js

@@ -1,9 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-
-import { update } from '../scene/update.js';
-
-export function updateNativeLayerView() {
-  this.viewDirty = true;
-  if (sceneByLayer.get(this.backend)._shared) update(this.backend);
-}

package/src/geometry/dot.js

@@ -1,6 +0,0 @@
-export function dot(a, b) {
-  let sum = 0;
-  let i;
-  for (i = 0; i < a.length; i++) sum += a[i] * b[i];
-  return sum;
-}

package/src/geometry/push.js

@@ -1,3 +0,0 @@
-export function push(position, normal, color, p, n) {
-  position.push(...p); normal.push(...n); color.push(0.6, 0.58, 0.54);
-}

package/src/globals/cameraByMap.js

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

package/src/raster/finishAttachment.js

@@ -1,15 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
-
-
-import { setRasterTerrain } from "./setRasterTerrain.js";
-
-export async function finishAttachment(backend, map, attached) {
-  try {
-    await attached;
-    sceneByLayer.get(backend)._added.resolve();
-    setRasterTerrain(backend, cameraByMap.get(map)._terrain3D);
-  } catch (error) {
-    backend.fire('error', /* alloc */ { error });
-  }
-}

package/src/raster/isLoading.js

@@ -1,7 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-
-
-export function isLoading(layer) {
-  return sceneByLayer.get(layer)._loadingTiles > 0;
-}

package/src/raster/terrainTileGeometry.js

@@ -1,16 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-export function terrainTileGeometry(backend, attributes, sizeX, sizeZ) {
-  const scene = sceneByLayer.get(backend), base = scene._terrainOriginElevation;
-  const bottom = Math.min(scene._dem.low, base) - base, top = Math.max(scene._dem.high, base) - base;
-  return /* alloc */ {
-    device: scene.renderer.device,
-    attributes,
-    drawRange: /* alloc */ { start: 0, count: attributes.index.count },
-    // Bounds must cover the DEM-displaced tile, although picking uses the flat grid.
-    bounds: /* alloc */ {
-      min: /* alloc */ [0, bottom, 0], max: /* alloc */ [1, top, 1], center: /* alloc */ [0.5, (bottom + top) / 2, 0.5],
-      radius: Math.hypot(sizeX, top - bottom, sizeZ) / 2 / Math.max(sizeX, 1, sizeZ),
-    },
-  };
-}

package/src/rendering/destroyTexture.js

@@ -1,9 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-
-
-import { destroyAfterSubmission } from './destroyAfterSubmission.js';
-
-export function destroyTexture(layer, texture) {
-  destroyAfterSubmission(layer, texture, sceneByLayer.get(layer).renderer.device.queue.onSubmittedWorkDone());
-}

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/updateRoofAtlas.js

@@ -1,20 +0,0 @@
-import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { roofSignatures } from '../globals/roofSignatures.js';
-import { rebuildRoofAtlas } from './rebuildRoofAtlas.js';
-
-export function updateRoofAtlas(backend, rasters, now) {
-  const signatures = roofSignatures;
-  signatures.length = 0;
-  let loading = false, layer;
-  for (layer of rasters) {
-    signatures.push(`${L.Util.stamp(layer)}:${sceneByLayer.get(layer)._rasterVersion || 0}:${layer.options.opacity}:${layer.options.zIndex}`);
-    loading ||= Boolean(sceneByLayer.get(layer)._loadingTiles);
-  }
-  const signature = signatures.join('|');
-  signatures.length = 0;
-  if (!sceneByLayer.get(backend)._roofRaster || sceneByLayer.get(backend)._roofRaster.signature !== signature &&
-    (!loading || now - sceneByLayer.get(backend)._roofRaster.updatedAt >= 50)) {
-    rebuildRoofAtlas(backend, rasters, signature, now);
-  }
-}

package/src/rendering/updateRoofRaster.js

@@ -1,25 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-import { updateRoofAtlas } from './updateRoofAtlas.js';
-import { destroyTexture } from './destroyTexture.js';
-
-export function updateRoofRaster(backend, now) {
-  const map = backend._map;
-  const rasters = sceneByLayer.get(backend)._roofRasters ||= /* alloc */ [];
-  rasters.length = 0;
-  let hasRoofTexture = false;
-  let layer;
-  for (layer of sceneByLayer.get(backend)._layers) {
-    if (layer.options.roofTexture || layer.options.wallTexture) { hasRoofTexture = true; break; }
-  }
-  if (hasRoofTexture) {
-    for (layer of Object.values(map._layers)) {
-      if (sceneByLayer.get(layer).kind === 'raster' && sceneByLayer.get(layer)._rasterTiles && layer.options.opacity > 0) rasters.push(layer);
-    }
-    updateRoofAtlas(backend, rasters, now);
-  } else if (sceneByLayer.get(backend)._roofRaster) {
-    destroyTexture(backend, sceneByLayer.get(backend)._roofRaster.texture.texture);
-    sceneByLayer.get(backend)._roofRaster = null;
-  }
-  return rasters;
-}

package/src/scene/attach.js

@@ -1,54 +0,0 @@
-import { radians } from '../globals/radians.js';
-import { renderers } from '../globals/renderers.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { setParent } from './setParent.js';
-import { render } from '../rendering/render.js';
-import { update } from './update.js';
-import { updateArea } from '../sources/updateArea.js';
-import { setTerrainHeight } from '../terrain/setTerrainHeight.js';
-import { noOperation } from '../utils/noOperation.js';
-import { restoreObject } from './restoreObject.js';
-import { traverse } from './traverse.js';
-import { initializeSharedRenderer } from './initializeSharedRenderer.js';
-
-/**
- * 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 = renderers.get(map);
-  if (sceneByLayer.get(shared)?._rendererReady) {
-    await sceneByLayer.get(shared)._rendererReady.promise;
-  }
-  if (!shared) {
-    shared = backend;
-    sceneByLayer.get(backend)._rendererReady = Promise.withResolvers();
-    sceneByLayer.get(backend)._rendererReady.promise.catch(noOperation);
-    renderers.set(map, shared);
-    await initializeSharedRenderer(backend, map);
-    sceneByLayer.get(backend)._rendererReady.resolve();
-    delete sceneByLayer.get(shared)._rendererReady;
-    render(shared);
-    renderers.set(map, shared);
-  }
-  const origin = map.options.crs.project(sceneByLayer.get(shared)._sceneOrigin);
-  const point = map.options.crs.project(sceneByLayer.get(backend).location);
-  const metres = Math.cos(sceneByLayer.get(shared)._sceneOrigin.lat * radians);
-  sceneByLayer.get(backend)._terrainBaseY ??= sceneByLayer.get(backend).root.position[1];
-  sceneByLayer.get(backend).root.position[0] = (point.x - origin.x) * metres;
-  sceneByLayer.get(backend).root.position[1] = sceneByLayer.get(backend)._terrainBaseY;
-  sceneByLayer.get(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.
-  sceneByLayer.get(backend).root.scale.fill(metres / Math.cos(sceneByLayer.get(backend).location.lat * radians));
-  sceneByLayer.get(backend)._shared = shared;
-  sceneByLayer.get(backend).renderer = sceneByLayer.get(shared).renderer;
-  sceneByLayer.get(backend).scene = sceneByLayer.get(shared).scene;
-  sceneByLayer.get(backend).camera = sceneByLayer.get(shared).camera;
-  sceneByLayer.get(shared)._layers.add(backend);
-  setParent(sceneByLayer.get(backend).root, sceneByLayer.get(shared).scene);
-  traverse(sceneByLayer.get(backend).root, restoreObject, backend);
-  update(shared);
-  if ((sceneByLayer.get(backend).header && sceneByLayer.get(backend).kind !== 'raster') || sceneByLayer.get(backend)._geojson) updateArea(backend);
-}

package/src/scene/endZoom.js

@@ -1,23 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
-
-import { mapUpdateCameraOverlays } from '../camera/mapUpdateCameraOverlays.js';
-
-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;
-  if (sceneByLayer.get(backend)._zoomTransitions) {
-    for (animation of sceneByLayer.get(backend)._zoomTransitions.keys()) animation.finish();
-  }
-  sceneByLayer.get(backend)._zoomTransitions = null;
-  sceneByLayer.get(backend)._zoomView = null;
-  delete cameraByMap.get(backend._map)._cameraView;
-  backend._map.getContainer().classList.remove('leaflet-camera-zoom');
-  mapUpdateCameraOverlays(backend._map);
-  sceneByLayer.get(backend)._zoomLevel = null;
-  update(backend);
-}

package/src/scene/initializeSharedRenderer.js

@@ -1,45 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { rendererDevices } from '../globals/rendererDevices.js';
-import { emptyNode } from './emptyNode.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 { createSceneCamera } from './createSceneCamera.js';
-import { initializeRendererResources } from './initializeRendererResources.js';
-import { mountRenderer } from './mountRenderer.js';
-
-export async function initializeSharedRenderer(backend, map) {
-  const canvas = document.createElement('canvas');
-  if (!navigator.gpu) {
-    failAttachment(/* alloc */ new Error('Layer3D requires WebGPU'), backend, map);
-  }
-  const adapter = await requestAdapter(backend, map);
-  const device = await requestDevice(adapter, backend, map);
-  rendererDevices.set(device, map);
-  device.addEventListener('uncapturederror', rendererDeviceError);
-  Promise.all(/* alloc */ [device.lost, Promise.resolve(device)]).then(rendererDeviceLost);
-  const context = canvas.getContext('webgpu');
-  if (!context) {
-    device.destroy();
-    failAttachment(/* alloc */ new Error('Unable to create a WebGPU canvas context'), backend, map);
-  }
-  const format = navigator.gpu.getPreferredCanvasFormat();
-  context.configure(/* alloc */ { device, format, alphaMode: 'premultiplied' });
-  map.getContainer().querySelector('.leaflet-webgpu-warning')?.remove();
-  sceneByLayer.get(backend)._shared = backend;
-  sceneByLayer.get(backend)._layers = /* alloc */ new Set();
-  sceneByLayer.get(backend)._sceneOrigin = sceneByLayer.get(backend).location;
-  sceneByLayer.get(backend).scene = emptyNode();
-  sceneByLayer.get(backend).camera = createSceneCamera();
-  sceneByLayer.get(backend).renderer = /* alloc */ {
-    device,
-    context,
-    format,
-    canvas,
-    dpr: Math.min(window.devicePixelRatio, 2)
-  };
-  initializeRendererResources(backend, device);
-  mountRenderer(backend, map, canvas);
-}

package/src/scene/layerCountTitle.js

@@ -1,4 +0,0 @@
-export function layerCountTitle(scene, formatted, pending, error) {
-  return error ? `Unable to load: ${typeof error === 'string' ? error : error.message}` :
-    `${formatted} loaded ${scene.modelUrl ? 'models' : 'elements'} in the current area${pending ? `; ${pending} blocks loading` : ''}`;
-}

package/src/scene/mountRenderer.js

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

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

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

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

@@ -1,14 +0,0 @@
-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/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(/* alloc */ 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,23 +0,0 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { pendingUpdates } from '../globals/pendingUpdates.js';
-
-
-import { render } from "../rendering/render.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 = sceneByLayer.get(backend)._shared;
-  if (!shared) return backend;
-  if (shared !== backend) {
-    update(shared);
-    return backend;
-  }
-  if (sceneByLayer.get(backend)._frame != null) return backend;
-  const first = pendingUpdates.values().next().value;
-  pendingUpdates.add(backend);
-  sceneByLayer.get(backend)._frame = first ? sceneByLayer.get(first)._frame : requestAnimationFrame(renderPendingUpdates);
-  return backend;
-}

package/src/sources/projectedTree.js

@@ -1,19 +0,0 @@
-import { L } from '../globals/L.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-
-import { getElevation } from '../terrain/getElevation.js';
-
-export function projectedTree(context, lon, lat) {
-  const { backend, crs, origin, metres, map } = context;
-  const location = /* alloc */ new L.LatLng(lat, lon);
-  const point = crs.project(location);
-  const elevation = cameraByMap.get(map)._terrain3D ? getElevation(cameraByMap.get(map)._terrain3D, location) : undefined;
-  return /* alloc */ {
-    x: (point.x - origin.x) * metres,
-    y: (point.y - origin.y) * metres,
-    ground: Number.isFinite(elevation) && Number.isFinite(sceneByLayer.get(backend).root.position[1])
-      ? elevation - sceneByLayer.get(backend).root.position[1] : 0,
-  };
-}

package/src/sources/pump.js

@@ -1,44 +0,0 @@
-import { renderers } from '../globals/renderers.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-
-
-import { emptyNode } from "../scene/emptyNode.js";
-import { isClockWise } from "../triangulation/isClockWise.js";
-import { lampPostGeometry } from "../geometry/lampPostGeometry.js";
-import { lightGeometry } from "../geometry/lightGeometry.js";
-import { parseColor } from "../utils/parseColor.js";
-import { treeGeometry } from "../geometry/treeGeometry.js";
-import { triangulate } from "../triangulation/triangulate.js";
-import { createProgram } from '../rendering/createProgram.js';
-import { updateStatus } from './updateStatus.js';
-import { loadSource } from '../archives/loadSource.js';
-import { setParent } from '../scene/setParent.js';
-import { update } from '../scene/update.js';
-import { getElevation } from "../terrain/getElevation.js";
-
-import { buildArea } from './buildArea.js';
-import { pendingSourceAreas } from './pendingSourceAreas.js';
-
-/** Share four load/build slots across source layers, nearest ground blocks first. */
-export function pump(backend, map = backend._map) {
-  const shared = map && renderers.get(map);
-  if (!shared) return;
-  const layers = /* alloc */ [];
-  let layer, area, areaBackend;
-  for (layer of sceneByLayer.get(shared)._layers) {
-    if (Number.isFinite(sceneByLayer.get(layer)._inflight) && sceneByLayer.get(layer)._areas && (sceneByLayer.get(layer).url || sceneByLayer.get(layer)._geojson)) layers.push(layer);
-  }
-  const pending = pendingSourceAreas(layers, map);
-  let inflight = 0;
-  for (layer of layers) inflight += sceneByLayer.get(layer)._inflight;
-  for ({ layer: areaBackend, area } of pending) {
-    if (inflight >= 4) break;
-    if (sceneByLayer.get(areaBackend)._inflight >= 2) continue;
-    area.started = true;
-    sceneByLayer.get(areaBackend)._inflight++;
-    inflight++;
-    buildArea(areaBackend, area, map);
-  }
-  for (layer of layers) updateStatus(layer);
-}

package/src/sunlight/render.js

@@ -1,9 +0,0 @@
-import { renderers } from '../globals/renderers.js';
-
-
-import { update as updateScene } from '../scene/update.js';
-
-export function render(map) {
-  const renderer = renderers.get(map);
-  if (renderer) updateScene(renderer);
-}

package/src/terrain/rasterProgram.js

@@ -1,51 +0,0 @@
-import { demTexture } from '../globals/demTexture.js';
-import { demTarget } from '../globals/demTarget.js';
-import { demLayout } from '../globals/demLayout.js';
-import { demSize } from '../globals/demSize.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { createProgram } from '../rendering/createProgram.js';
-import { destroyTexture } from '../rendering/destroyTexture.js';
-import { terrainAtlas } from './terrainAtlas.js';
-
-export function rasterProgram(backend, texture) {
-  const state = sceneByLayer.get(backend), device = state.renderer.device;
-  if (state._rasterProgram?.device === device) return state._rasterProgram;
-  // DEM atlas over the archive's tile grid; invalid or missing samples become -1e9 (the shader's no-data).
-  // ponytail: one texture, capped by maxTextureDimension2D (32x32 DEM tiles at 8192 px); split it for larger archives.
-  const bounds = state._terrainBounds, columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
-  const { elevations, low, high } = terrainAtlas(state._terrainTiles, bounds);
-  if (state._dem) destroyTexture(backend, state._dem.texture);
-  state._dem = /* alloc */ {
-    texture: device.createTexture((
-      demTexture.size[0] = columns * 256,
-      demTexture.size[1] = rows * 256,
-      demTexture.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
-      demTexture
-    )),
-    low: Number.isFinite(low) ? low : state._terrainOriginElevation,
-    high: Number.isFinite(high) ? high : state._terrainOriginElevation,
-  };
-  device.queue.writeTexture((
-    demTarget.texture = state._dem.texture,
-    demTarget
-  ), elevations,
-    (
-      demLayout.bytesPerRow = columns * 1024,
-      demLayout
-    ), (
-      demSize[0] = columns * 256,
-      demSize[1] = rows * 256,
-      demSize
-    ));
-  demTarget.texture = null;
-  state._terrainGrids = /* alloc */ new Map();
-  state._rasterProgram = createProgram(backend, /* alloc */ {
-    baseTexture: texture,
-    unlit: true,
-    terrain: state._dem,
-    alphaMode: 'BLEND',
-    depthWrite: true,
-    doubleSided: backend.options.doubleSided,
-  });
-  return state._rasterProgram;
-}