leaflet-city-mapper 0.0.2 → 0.0.4

package/src/picking/onPointerLeave.js

@@ -0,0 +1,14 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { setHighlight } from './setHighlight.js';
+import { showFeature } from './showFeature.js';
+
+/** Clear hover, highlight and tooltip without retaining a selected feature. */
+
+export function onPointerLeave(layer) {
+  sceneByLayer.get(layer).hoveredFeature = null;
+  setHighlight(layer, null);
+  showFeature(layer, null);
+  layer.fire('featurehover', /* alloc */ { feature: null });
+}

package/src/picking/onPointerMove.js

@@ -0,0 +1,18 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { findFeature } from './findFeature.js';
+import { setHighlight } from './setHighlight.js';
+import { showFeature } from './showFeature.js';
+
+/** Hover is transient; featurehover also reports misses with feature:null. */
+
+export function onPointerMove(layer, event) {
+  sceneByLayer.get(layer).hoveredFeature = findFeature(layer, event);
+  setHighlight(layer, sceneByLayer.get(layer).hoveredFeature);
+  showFeature(layer, sceneByLayer.get(layer).hoveredFeature, event);
+  layer.fire('featurehover', /* alloc */ {
+    feature: sceneByLayer.get(layer).hoveredFeature,
+    originalEvent: event
+  });
+}

package/src/picking/pointerClick.js

@@ -0,0 +1,5 @@
+import * as onClick from './onClick.js';
+
+export function pointerClick(event) {
+  onClick.onClick(this, event);
+}

package/src/picking/pointerLeave.js

@@ -0,0 +1,5 @@
+import * as onPointerLeave from './onPointerLeave.js';
+
+export function pointerLeave() {
+  onPointerLeave.onPointerLeave(this);
+}

package/src/picking/pointerMove.js

@@ -0,0 +1,5 @@
+import * as onPointerMove from './onPointerMove.js';
+
+export function pointerMove(event) {
+  onPointerMove.onPointerMove(this, event);
+}

package/src/picking/raycast.js

@@ -0,0 +1,66 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { trafficByLayer } from '../globals/trafficByLayer.js';
+
+
+import { intersectMeshes } from '../collision/intersectMeshes.js';
+import { traverse } from '../scene/traverse.js';
+import { updateCamera } from '../scene/updateCamera.js';
+import { updateWorldMatrix } from '../scene/updateWorldMatrix.js';
+import { collectVisibleMesh } from './collectVisibleMesh.js';
+import { placeTraffic } from '../traffic/placeTraffic.js';
+import { validateCameraInverse } from './validateCameraInverse.js';
+
+/** Raycasting, hover/click highlight and tooltips. */
+/**
+ * Finds the objects under a mouse or pointer event, nearest first.
+ *
+ * @param {MouseEvent} event
+ * @param {Object[]} [objects] Defaults to this layer's root children, not all map layers.
+ * @param {boolean} [recursive] Also test the descendants of `objects`.
+ * @returns {Object[]} Nearest hit per mesh: object, shared-world point/distance and triangle faceIndex.
+ */
+
+export function raycast(backend, event, objects = sceneByLayer.get(backend).root.children, recursive = true) {
+  if (!sceneByLayer.get(backend).renderer) {
+    return /* alloc */ [];
+  }
+  const traffic = trafficByLayer.get(backend);
+  if (traffic) placeTraffic(traffic);
+  const rect = backend._map.getContainer().getBoundingClientRect();
+  updateWorldMatrix(sceneByLayer.get(backend).scene);
+  updateCamera(sceneByLayer.get(backend).camera);
+  // Unproject the mouse (-1..1) into a world-space ray from the camera.
+  const inverseCamera = sceneByLayer.get(backend).raycaster.inverse;
+  const matrix = sceneByLayer.get(backend).camera.projectionViewMatrix;
+  inverseCamera.m11 = matrix[0], inverseCamera.m12 = matrix[1], inverseCamera.m13 = matrix[2], inverseCamera.m14 = matrix[3];
+  inverseCamera.m21 = matrix[4], inverseCamera.m22 = matrix[5], inverseCamera.m23 = matrix[6], inverseCamera.m24 = matrix[7];
+  inverseCamera.m31 = matrix[8], inverseCamera.m32 = matrix[9], inverseCamera.m33 = matrix[10], inverseCamera.m34 = matrix[11];
+  inverseCamera.m41 = matrix[12], inverseCamera.m42 = matrix[13], inverseCamera.m43 = matrix[14], inverseCamera.m44 = matrix[15];
+  inverseCamera.invertSelf();
+  const x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
+  const y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+  const endX = inverseCamera.m11 * x + inverseCamera.m21 * y + inverseCamera.m41;
+  const endY = inverseCamera.m12 * x + inverseCamera.m22 * y + inverseCamera.m42;
+  const endZ = inverseCamera.m13 * x + inverseCamera.m23 * y + inverseCamera.m43;
+  const endW = inverseCamera.m14 * x + inverseCamera.m24 * y + inverseCamera.m44;
+  let object;
+  validateCameraInverse(inverseCamera);
+  sceneByLayer.get(backend).raycaster.origin[0] = sceneByLayer.get(backend).camera.position[0];
+  sceneByLayer.get(backend).raycaster.origin[1] = sceneByLayer.get(backend).camera.position[1];
+  sceneByLayer.get(backend).raycaster.origin[2] = sceneByLayer.get(backend).camera.position[2];
+  sceneByLayer.get(backend).raycaster.direction[0] = endX / endW - sceneByLayer.get(backend).raycaster.origin[0];
+  sceneByLayer.get(backend).raycaster.direction[1] = endY / endW - sceneByLayer.get(backend).raycaster.origin[1];
+  sceneByLayer.get(backend).raycaster.direction[2] = endZ / endW - sceneByLayer.get(backend).raycaster.origin[2];
+  const direction = sceneByLayer.get(backend).raycaster.direction;
+  const rayLength = Math.hypot(direction[0], direction[1], direction[2]) || 1;
+  sceneByLayer.get(backend).raycaster.direction[0] /= rayLength;
+  sceneByLayer.get(backend).raycaster.direction[1] /= rayLength;
+  sceneByLayer.get(backend).raycaster.direction[2] /= rayLength;
+  const meshes = sceneByLayer.get(backend).raycaster.meshes;
+  meshes.length = 0;
+  for (object of objects) {
+    if (recursive) traverse(object, collectVisibleMesh, meshes);
+    else if (object.geometry && object.visible && object._appearance !== 0) meshes.push(object);
+  }
+  return intersectMeshes(sceneByLayer.get(backend).raycaster, meshes, sceneByLayer.get(backend).renderer.uniformData?.[55]);
+}

package/src/picking/setHighlight.js

@@ -0,0 +1,20 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { update } from '../scene/update.js';
+
+/** Highlight a source vertex range in the shader; vertex colors stay untouched. */
+
+export function setHighlight(backend, feature) {
+  if (feature?.model) feature = null;
+  if (sceneByLayer.get(backend).highlightedFeature?.mesh === feature?.mesh &&
+    sceneByLayer.get(backend).highlightedFeature?.vertexStart === feature?.vertexStart) return;
+  if (sceneByLayer.get(backend).highlightedFeature) sceneByLayer.get(backend).highlightedFeature.mesh.highlight = null;
+  sceneByLayer.get(backend).highlightedFeature = feature;
+  if (feature) {
+    feature.mesh.highlightRange[0] = feature.vertexStart;
+    feature.mesh.highlightRange[1] = feature.vertexEnd;
+    feature.mesh.highlight = feature.mesh.highlightRange;
+  }
+  update(backend);
+}

package/src/picking/shouldSkipOther.js

@@ -0,0 +1,6 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+export function shouldSkipOther(other, layer) {
+  return other === layer || sceneByLayer.get(other)._type === 'terrain' || sceneByLayer.get(other)._type === 'traffic';
+}

package/src/picking/showFeature.js

@@ -0,0 +1,37 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+/** Update tooltip content/position and arbitrate cursor ownership across shared layers. */
+
+export function showFeature(backend, feature, event) {
+  const tooltip = sceneByLayer.get(backend)._tooltip;
+  if (!tooltip) return;
+  if (feature) {
+    tooltip.replaceChildren(backend.options.tooltip(feature));
+    tooltip.hidden = false;
+    const rect = sceneByLayer.get(backend).container.getBoundingClientRect();
+    const x = event.clientX - rect.left, y = event.clientY - rect.top;
+    tooltip.style.left = `${x + tooltip.offsetWidth + 16 > rect.width ? x - tooltip.offsetWidth - 12 : x + 12}px`;
+    tooltip.style.top = `${y + tooltip.offsetHeight + 16 > rect.height ? y - tooltip.offsetHeight - 12 : y + 12}px`;
+  } else {
+    tooltip.hidden = true;
+  }
+  const shared = sceneByLayer.get(backend)._shared;
+  let layer;
+  if (shared) {
+    let visible = false;
+    for (layer of sceneByLayer.get(shared)._layers) {
+      if (sceneByLayer.get(layer)._tooltip && !sceneByLayer.get(layer)._tooltip.hidden) {
+        visible = true;
+        break;
+      }
+    }
+    if (visible) {
+      if (sceneByLayer.get(shared)._cursor === undefined) sceneByLayer.get(shared)._cursor = sceneByLayer.get(backend).container.style.cursor;
+      sceneByLayer.get(backend).container.style.cursor = 'pointer';
+    } else if (sceneByLayer.get(shared)._cursor !== undefined) {
+      sceneByLayer.get(backend).container.style.cursor = sceneByLayer.get(shared)._cursor;
+      delete sceneByLayer.get(shared)._cursor;
+    }
+  }
+}

package/src/picking/validateCameraInverse.js

@@ -0,0 +1,8 @@
+export function validateCameraInverse(matrix) {
+  let column, row;
+  for (column = 1; column <= 4; column++) {
+    for (row = 1; row <= 4; row++) {
+      if (!Number.isFinite(matrix[`m${column}${row}`])) throw /* alloc */ new Error('Singular 3D transform');
+    }
+  }
+}

package/src/raster/addRasterTile.js

@@ -0,0 +1,69 @@
+import { radians } from '../globals/radians.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { rasterPoint } from '../globals/rasterPoint.js';
+import { nextId } from '../globals/nextId.js';
+import { rasterProgram } from '../terrain/rasterProgram.js';
+import { terrainBuffers } from '../terrain/terrainBuffers.js';
+import { setParent } from '../scene/setParent.js';
+import { update } from '../scene/update.js';
+import { terrainTileGeometry } from './terrainTileGeometry.js';
+
+export async function addRasterTile(backend, layer, coords, tile) {
+  const ready = await sceneByLayer.get(backend)._terrainPromise;
+  if (!ready || !backend._map || cameraByMap.get(backend._map)._terrain3D !== backend || sceneByLayer.get(layer)._terrain3D !== backend ||
+    tile.request.signal.aborted || !sceneByLayer.get(layer)._rasterTiles.has(`${coords.z}/${coords.x}/${coords.y}`) ||
+    sceneByLayer.get(backend)._rasterTiles.has(tile)) {
+    return;
+  }
+  // Match DEM pixel spacing, capped at 64 subdivisions per tile.
+  const divisions = Math.max(1, Math.min(64, 256 / 2 ** (coords.z - sceneByLayer.get(backend)._terrainZoom)));
+  const map = backend._map, crs = map.options.crs;
+  const origin = crs.project(sceneByLayer.get(backend).location), metres = Math.cos(sceneByLayer.get(backend).location.lat * radians);
+  // Tile pixels map linearly to projected metres: one scaled unit grid per tile, elevation in the vertex shader.
+  const scale = crs.scale(coords.z), terrainScale = 2 ** (sceneByLayer.get(backend)._terrainZoom - coords.z);
+  const point = rasterPoint;
+  point.x = coords.x * 256; point.y = coords.y * 256;
+  const corner = crs.transformation.untransform(point, scale);
+  point.x = (coords.x + 1) * 256; point.y = (coords.y + 1) * 256;
+  const opposite = crs.transformation.untransform(point, scale);
+  const device = sceneByLayer.get(backend).renderer.device;
+  const texture = tile.texture;
+  const program = rasterProgram(backend, texture);
+  const attributes = terrainBuffers(backend, divisions);
+  const base = sceneByLayer.get(backend)._terrainOriginElevation;
+  const sizeX = (opposite.x - corner.x) * metres, sizeZ = -(opposite.y - corner.y) * metres;
+  // ponytail: ray picking sees the flat unit grid; read the DEM back if terrain must be pickable.
+  const geometry = terrainTileGeometry(backend, attributes, sizeX, sizeZ);
+  const mesh = /* alloc */ {
+    position: /* alloc */ [(corner.x - origin.x) * metres, 0, -(corner.y - origin.y) * metres],
+    rotation: /* alloc */ [0, 0, 0],
+    scale: /* alloc */ [sizeX, 1, sizeZ],
+    worldMatrix: /* alloc */ [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    children: /* alloc */ [],
+    visible: true,
+    device,
+    geometry,
+    program,
+    texture,
+    // DEM pixel of the tile's corner, DEM pixels per tile, and the elevation at the layer origin.
+    terrain: /* alloc */ [
+      coords.x * 256 * terrainScale - sceneByLayer.get(backend)._terrainBounds.min.x * 256,
+      coords.y * 256 * terrainScale - sceneByLayer.get(backend)._terrainBounds.min.y * 256,
+      256 * terrainScale,
+      base,
+    ],
+    tile,
+    opacity: layer.options.opacity ?? 1,
+    id: nextId.value++,
+    renderOrder: layer.options.zIndex || 0,
+    fadeDuration: 250,
+    fadeStart: tile.loadedAt,
+    ground: true,
+    _rasterSource: layer,
+  };
+  tile.mesh.visible = false;
+  setParent(mesh, sceneByLayer.get(backend).root);
+  update(backend);
+  sceneByLayer.get(backend)._rasterTiles.set(tile, mesh);
+}

package/src/raster/comparePendingTiles.js

@@ -0,0 +1,5 @@
+
+
+export function comparePendingTiles(a, b) {
+  return a.tile.coords.z - b.tile.coords.z || a.distance - b.distance;
+}

package/src/raster/createGeometry.js

@@ -0,0 +1,29 @@
+import { rasterBuffer } from '../globals/rasterBuffer.js';
+import { rasterPositions } from '../globals/rasterPositions.js';
+import { rasterNormals } from '../globals/rasterNormals.js';
+import { rasterUVs } from '../globals/rasterUVs.js';
+import { rasterIndices } from '../globals/rasterIndices.js';
+
+
+export function createGeometry(device) {
+  const attributes = /* alloc */ {
+    position: /* alloc */ { size: 3, data: /* alloc */ new Float32Array(rasterPositions) },
+    normal: /* alloc */ { size: 3, data: /* alloc */ new Float32Array(rasterNormals) },
+    uv: /* alloc */ { size: 2, data: /* alloc */ new Float32Array(rasterUVs) },
+    index: /* alloc */ { data: /* alloc */ new Uint16Array(rasterIndices) },
+  };
+  let name, attribute;
+  for ([name, attribute] of Object.entries(attributes)) {
+    attribute.count = attribute.data.length / (attribute.size || 1);
+    attribute.indexFormat = 'uint16';
+    attribute.buffer = device.createBuffer((
+      rasterBuffer.size = attribute.data.byteLength,
+      rasterBuffer.usage = name === 'index' ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+        : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+      rasterBuffer
+    ));
+
+    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+  }
+  return /* alloc */ { device, attributes, drawRange: /* alloc */ { start: 0, count: attributes.index.count } };
+}

package/src/raster/createRasterMesh.js

@@ -0,0 +1,76 @@
+import { radians } from '../globals/radians.js';
+import { rasterTexture } from '../globals/rasterTexture.js';
+import { rasterSampler } from '../globals/rasterSampler.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { meshImage } from '../globals/meshImage.js';
+import { meshTarget } from '../globals/meshTarget.js';
+import { meshCopySize } from '../globals/meshCopySize.js';
+import { rasterPoint } from '../globals/rasterPoint.js';
+import { TILE_SIZE } from '../globals/TILE_SIZE.js';
+import { nextId } from '../globals/nextId.js';
+
+
+
+import { createProgram } from "../rendering/createProgram.js";
+import { setParent } from "../scene/setParent.js";
+
+import { createGeometry } from './createGeometry.js';
+
+export function createRasterMesh(backend, tile) {
+  const device = sceneByLayer.get(backend).renderer.device;
+  const texture = /* alloc */ {
+    device,
+    texture: device.createTexture((
+    rasterTexture.size[0] = tile.image.width,
+    rasterTexture.size[1] = tile.image.height,
+    rasterTexture.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+    rasterTexture
+  )),
+    sampler: device.createSampler(rasterSampler),
+    image: tile.image, format: 'rgba8unorm', srgb: false, uploaded: null,
+  };
+  const source = meshImage;
+  const destination = meshTarget;
+  const dimensions = meshCopySize;
+  source.source = tile.image;
+  source.flipY = false;
+  destination.texture = texture.texture;
+  dimensions[0] = tile.image.width;
+  dimensions[1] = tile.image.height;
+  device.queue.copyExternalImageToTexture(source, destination, dimensions);
+  source.source = null;
+  destination.texture = null;
+  texture.uploaded = tile.image;
+
+  if (!sceneByLayer.get(backend)._rasterProgram) {
+    sceneByLayer.get(backend)._rasterProgram = createProgram(backend, /* alloc */ {
+      baseTexture: texture, unlit: true, alphaMode: 'BLEND', doubleSided: backend.options.doubleSided,
+    });
+  }
+  if (!sceneByLayer.get(backend)._rasterGeometry) sceneByLayer.get(backend)._rasterGeometry = createGeometry(device);
+  const { coords } = tile;
+  const crs = backend._map.options.crs;
+  const origin = crs.project(sceneByLayer.get(backend).location);
+  const metres = Math.cos(sceneByLayer.get(backend).location.lat * radians);
+  const scale = crs.scale(coords.z);
+  const point = rasterPoint;
+  point.x = coords.x * TILE_SIZE; point.y = coords.y * TILE_SIZE;
+  const corner = crs.transformation.untransform(point, scale);
+  point.x = (coords.x + 1) * TILE_SIZE; point.y = (coords.y + 1) * TILE_SIZE;
+  const opposite = crs.transformation.untransform(point, scale);
+  const sizeX = (opposite.x - corner.x) * metres;
+  const sizeZ = -(opposite.y - corner.y) * metres;
+  tile.texture = texture;
+  tile.mesh = /* alloc */ {
+    position: /* alloc */ [(corner.x - origin.x) * metres, 0, -(corner.y - origin.y) * metres],
+    rotation: /* alloc */ [0, 0, 0],
+    scale: /* alloc */ [sizeX, 1, sizeZ],
+    worldMatrix: /* alloc */ [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    children: /* alloc */ [], visible: true, device, geometry: sceneByLayer.get(backend)._rasterGeometry,
+    program: sceneByLayer.get(backend)._rasterProgram, texture,
+    opacity: backend.options.opacity, id: nextId.value++,
+    renderOrder: backend.options.zIndex || 0, tile, fadeDuration: 250, ground: true,
+    _rasterSource: backend,
+  };
+  setParent(tile.mesh, sceneByLayer.get(backend).root);
+}

package/src/raster/finishAttachment.js

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

@@ -0,0 +1,61 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { blobParts } from '../globals/blobParts.js';
+
+import { update } from "../scene/update.js";
+import { registerTerrainTile } from "./registerTerrainTile.js";
+import { pruneRasterTiles } from "./pruneRasterTiles.js";
+import { pumpRasterTiles } from './pumpRasterTiles.js';
+import { createRasterMesh } from './createRasterMesh.js';
+import { getZxy } from '../archives/getZxy.js';
+
+export async function finishRasterTile(backend, tile) {
+  try {
+    await sceneByLayer.get(backend).ready;
+    const result = await getZxy(backend.options.archive,
+      tile.coords.z, tile.coords.x, tile.coords.y, tile.request.signal
+    );
+    if (tile.request.signal.aborted) {
+      result?.image?.close();
+      return;
+    }
+    if (!result) throw /* alloc */ new Error(`Tile ${tile.coords.z}/${tile.coords.x}/${tile.coords.y} is not in the offline archive`);
+    try {
+      if (result.image) tile.image = result.image;
+      else {
+        blobParts[0] = result.data;
+        const blob = /* alloc */ new Blob(blobParts);
+        blobParts[0] = null;
+        tile.image = await createImageBitmap(blob);
+      }
+    } catch {
+      blobParts[0] = null;
+      throw /* alloc */ new Error(`Unable to decode tile ${tile.coords.z}/${tile.coords.x}/${tile.coords.y}`);
+    }
+    if (tile.request.signal.aborted) {
+      tile.image.close();
+      tile.image = null;
+      return;
+    }
+    createRasterMesh(backend, tile);
+    tile.loadedAt = performance.now();
+    tile.done = true;
+    sceneByLayer.get(backend)._rasterVersion = (sceneByLayer.get(backend)._rasterVersion || 0) + 1;
+    registerTerrainTile(backend, tile.coords, tile);
+    backend.fire('tileload', /* alloc */ { tile, coords: tile.coords });
+    update(backend);
+  } catch (error) {
+    if (tile.request.signal.aborted) return;
+    tile.error = error.message;
+    sceneByLayer.get(backend)._rasterVersion = (sceneByLayer.get(backend)._rasterVersion || 0) + 1;
+    backend.fire('tileerror', /* alloc */ { tile, coords: tile.coords, error });
+    backend.fire('error', /* alloc */ { error, coords: tile.coords });
+  } finally {
+    sceneByLayer.get(backend)._loadingTiles--;
+    if (backend._map) {
+      pumpRasterTiles(backend);
+      pruneRasterTiles(backend);
+      if (!sceneByLayer.get(backend)._loadingTiles) backend.fire('load');
+      update(backend);
+    }
+  }
+}

package/src/raster/getRasterEvents.js

@@ -0,0 +1,6 @@
+import { updateRasterTiles } from "./updateRasterTiles.js";
+
+export function getRasterEvents(layer) {
+  const update = updateRasterTiles.bind(null, layer);
+  return /* alloc */ { moveend: update, zoomend: update, rotate: update, pitch: update, resize: update };
+}

package/src/raster/getRasterTileSize.js

@@ -0,0 +1,7 @@
+import { L } from '../globals/L.js';
+import { TILE_SIZE } from '../globals/TILE_SIZE.js';
+
+
+export function getRasterTileSize() {
+  return /* alloc */ new L.Point(TILE_SIZE, TILE_SIZE);
+}

package/src/raster/initRaster.js

@@ -0,0 +1,33 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { isLoading } from './isLoading.js';
+import { getRasterEvents } from './getRasterEvents.js';
+import { readyRaster } from './readyRaster.js';
+import { reportError } from './reportError.js';
+import { emptyNode } from '../scene/emptyNode.js';
+import { read } from '../archives/read.js';
+import { getHeader } from '../archives/getHeader.js';
+import { getZxy } from '../archives/getZxy.js';
+import { onPMTileAdd } from './onPMTileAdd.js';
+import { onPMTileRemove } from './onPMTileRemove.js';
+import { getRasterTileSize } from './getRasterTileSize.js';
+import { setPMTileOpacity } from './setPMTileOpacity.js';
+import { setPMTileZIndex } from './setPMTileZIndex.js';
+
+export function initRaster(layer, options) {
+  sceneByLayer.get(layer).kind = 'raster';
+  options = /* alloc */ { ariaLabel: 'PMTiles raster', maxZoom: 18, opacity: 1, zIndex: 0, ...options };
+  L.Util.setOptions(layer, options);
+  sceneByLayer.get(layer).root = emptyNode();
+  sceneByLayer.get(layer)._areas = /* alloc */ new Map();
+  sceneByLayer.get(layer)._rasterTiles = /* alloc */ new Map();
+  sceneByLayer.get(layer)._loadingTiles = 0;
+  sceneByLayer.get(layer)._added = Promise.withResolvers();
+  sceneByLayer.get(layer).url = /* alloc */ new URL(options.url, document.baseURI).href;
+  sceneByLayer.get(layer)._directories = /* alloc */ new Map();
+  sceneByLayer.get(layer).ready = Promise.resolve(layer.options.archive || layer)
+    .then(readyRaster.bind(null, layer))
+    .catch(reportError.bind(null, layer));
+}

package/src/raster/isLoading.js

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

package/src/raster/loadRasterTile.js

@@ -0,0 +1,13 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { finishRasterTile } from './finishRasterTile.js';
+
+export function loadRasterTile(backend, tile) {
+  tile.started = true;
+  const first = sceneByLayer.get(backend)._loadingTiles === 0;
+  sceneByLayer.get(backend)._loadingTiles++;
+  backend.fire('tileloadstart', /* alloc */ { tile, coords: tile.coords });
+  if (first) backend.fire('loading');
+  return finishRasterTile(backend, tile);
+}

package/src/raster/onPMTileAdd.js

@@ -0,0 +1,13 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { finishAttachment } from './finishAttachment.js';
+import { updateAttachedTiles } from './updateAttachedTiles.js';
+import { attach } from '../scene/attach.js';
+
+export function onPMTileAdd(backend, map) {
+  if (!sceneByLayer.get(backend).location) sceneByLayer.get(backend).location = map.getCenter();
+  const attached = attach(backend, map);
+  finishAttachment(backend, map, attached);
+  updateAttachedTiles(backend, map, attached);
+}

package/src/raster/onPMTileRemove.js

@@ -0,0 +1,11 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { releaseRasterTiles } from './releaseRasterTiles.js';
+import { onRemove3DLayer } from '../scene/onRemove3DLayer.js';
+
+export function onPMTileRemove(backend, map) {
+  releaseRasterTiles(backend);
+  sceneByLayer.get(backend)._terrain3D = null;
+  onRemove3DLayer(backend, map);
+}

package/src/raster/pruneRasterTiles.js

@@ -0,0 +1,40 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { releaseRasterTile } from './releaseRasterTile.js';
+
+export function pruneRasterTiles(backend) {
+  const wanted = sceneByLayer.get(backend)._wantedRasterTiles;
+  const now = performance.now();
+  if (sceneByLayer.get(backend)._pruneVersion === sceneByLayer.get(backend)._rasterVersion && sceneByLayer.get(backend)._pruneWanted === wanted &&
+    now < sceneByLayer.get(backend)._pruneAfter) return Number.isFinite(sceneByLayer.get(backend)._pruneAfter);
+  sceneByLayer.get(backend)._pruneVersion = sceneByLayer.get(backend)._rasterVersion;
+  sceneByLayer.get(backend)._pruneWanted = wanted;
+  sceneByLayer.get(backend)._pruneAfter = Infinity;
+  const pending = /* alloc */ [];
+  let key, tile, parts, overlaps, coords, zoom;
+  for (key of wanted) {
+    tile = sceneByLayer.get(backend)._rasterTiles.get(key);
+    if (tile?.done && now - tile.loadedAt < 250) {
+      sceneByLayer.get(backend)._pruneAfter = Math.min(sceneByLayer.get(backend)._pruneAfter, tile.loadedAt + 250);
+    }
+    if (!tile?.done || now - tile.loadedAt < 250) {
+      parts = key.split('/');
+      pending.push(/* alloc */ { z: Number(parts[0]), x: Number(parts[1]), y: Number(parts[2]) });
+    }
+  }
+  for ([key, tile] of sceneByLayer.get(backend)._rasterTiles) {
+    if (wanted.has(key)) continue;
+    overlaps = false;
+    for (coords of pending) {
+      zoom = Math.min(coords.z, tile.coords.z);
+      if (Math.floor(coords.x / 2 ** (coords.z - zoom)) === Math.floor(tile.coords.x / 2 ** (tile.coords.z - zoom)) &&
+        Math.floor(coords.y / 2 ** (coords.z - zoom)) === Math.floor(tile.coords.y / 2 ** (tile.coords.z - zoom))) {
+        overlaps = true;
+        break;
+      }
+    }
+    if (!overlaps) releaseRasterTile(backend, tile);
+  }
+  return Number.isFinite(sceneByLayer.get(backend)._pruneAfter);
+}

package/src/raster/pumpRasterTiles.js

@@ -0,0 +1,26 @@
+import { TILE_SIZE } from '../globals/TILE_SIZE.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+
+import { comparePendingTiles } from './comparePendingTiles.js';
+import { loadRasterTile } from './loadRasterTile.js';
+
+export function pumpRasterTiles(backend) {
+  const map = backend._map;
+  if (!map) return;
+  const center = map.project(map.getCenter(), 0).divideBy(TILE_SIZE);
+  const pending = /* alloc */ [];
+  let tile, coords;
+  for (tile of sceneByLayer.get(backend)._rasterTiles.values()) {
+    if (tile.started || tile.request.signal.aborted) continue;
+    ({ coords } = tile);
+    pending.push(/* alloc */ { tile, distance: Math.hypot((coords.x + 0.5) / 2 ** coords.z - center.x,
+      (coords.y + 0.5) / 2 ** coords.z - center.y) });
+  }
+  pending.sort(comparePendingTiles);
+  for ({ tile } of pending) {
+    if (sceneByLayer.get(backend)._loadingTiles >= 4) break;
+    loadRasterTile(backend, tile);
+  }
+}

package/src/raster/rasterTileRange.js

@@ -0,0 +1,23 @@
+import { TILE_SIZE } from '../globals/TILE_SIZE.js';
+import { TILE_RADIUS } from '../globals/TILE_RADIUS.js';
+import { archiveNorthWest } from '../globals/archiveNorthWest.js';
+import { archiveSouthEast } from '../globals/archiveSouthEast.js';
+
+export function rasterTileRange(map, header, zoom) {
+  const bounds = map.getBounds();
+  const northwest = map.project(bounds.getNorthWest(), zoom).divideBy(TILE_SIZE).floor();
+  const southeast = map.project(bounds.getSouthEast(), zoom).divideBy(TILE_SIZE).floor();
+  archiveNorthWest[0] = header.maxLat; archiveNorthWest[1] = header.minLon;
+  archiveSouthEast[0] = header.minLat; archiveSouthEast[1] = header.maxLon;
+  const archiveMin = header.maxLat === undefined || header.minLon === undefined
+    ? null : map.project(archiveNorthWest, zoom).divideBy(TILE_SIZE).floor();
+  const archiveMax = header.minLat === undefined || header.maxLon === undefined
+    ? null : map.project(archiveSouthEast, zoom).divideBy(TILE_SIZE).floor();
+  const center = map.project(map.getCenter(), zoom).divideBy(TILE_SIZE).floor();
+  return /* alloc */ {
+    minX: Math.max(0, northwest.x, archiveMin?.x ?? 0, center.x - TILE_RADIUS),
+    maxX: Math.min(2 ** zoom - 1, southeast.x, archiveMax?.x ?? 2 ** zoom - 1, center.x + TILE_RADIUS),
+    minY: Math.max(0, northwest.y, archiveMin?.y ?? 0, center.y - TILE_RADIUS),
+    maxY: Math.min(2 ** zoom - 1, southeast.y, archiveMax?.y ?? 2 ** zoom - 1, center.y + TILE_RADIUS),
+  };
+}