leaflet-city-mapper 0.0.1 → 0.0.2

package/src/utils/rasterTiles.js

@@ -0,0 +1,285 @@
+import { addRasterTile } from './addRasterTile.js';
+import { createProgram } from './createProgram.js';
+import { destroyTexture } from './destroyTexture.js';
+import { removeRasterTile } from './removeRasterTile.js';
+import { setParent } from './setParent.js';
+import { update } from './update.js';
+
+const TILE_SIZE = 256;
+// ponytail: cap horizon views at 169 tiles; raise the radius if extreme pitches need more.
+const TILE_RADIUS = 6;
+
+export function updateRasterTiles(backend) {
+  const map = backend._map;
+  if (!map || !backend._shared || !backend.header) return;
+
+  const zoom = Math.max(backend.header.minZoom ?? 0, Math.min(
+    Math.round(map.getZoom()),
+    backend.options.maxZoom,
+    backend.options.maxNativeZoom
+  ));
+  backend._tileZoom = 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();
+  const archiveNorthWest = backend.header.maxLat === undefined || backend.header.minLon === undefined
+    ? new L.Point(0, 0)
+    : map.project([backend.header.maxLat, backend.header.minLon], zoom).divideBy(TILE_SIZE).floor();
+  const archiveSouthEast = backend.header.minLat === undefined || backend.header.maxLon === undefined
+    ? new L.Point(2 ** zoom - 1, 2 ** zoom - 1)
+    : map.project([backend.header.minLat, backend.header.maxLon], zoom).divideBy(TILE_SIZE).floor();
+  const center = map.project(map.getCenter(), zoom).divideBy(TILE_SIZE).floor();
+  const wanted = new Map();
+  for (let x = Math.max(0, northWest.x, archiveNorthWest.x, center.x - TILE_RADIUS);
+    x <= Math.min(2 ** zoom - 1, southEast.x, archiveSouthEast.x, center.x + TILE_RADIUS); x++) {
+    for (let y = Math.max(0, northWest.y, archiveNorthWest.y, center.y - TILE_RADIUS);
+      y <= Math.min(2 ** zoom - 1, southEast.y, archiveSouthEast.y, center.y + TILE_RADIUS); y++) {
+      wanted.set(`${zoom}/${x}/${y}`, { z: zoom, x, y });
+    }
+  }
+  backend._wantedRasterTiles = new Set(wanted.keys());
+  const coverage = new Map();
+  const parentZoom = Math.max(backend.header.minZoom ?? 0, zoom - 2), factor = 2 ** (zoom - parentZoom);
+  if (parentZoom < zoom) {
+    for (const [key, coords] of wanted) {
+      if (backend._rasterTiles.get(key)?.done) continue;
+      const parent = { z: parentZoom, x: Math.floor(coords.x / factor), y: Math.floor(coords.y / factor) };
+      coverage.set(`${parent.z}/${parent.x}/${parent.y}`, parent);
+    }
+  }
+  const required = new Map([...coverage, ...wanted]);
+  for (const [key, tile] of backend._rasterTiles) {
+    if (!required.has(key) && !tile.done) releaseRasterTile(backend, tile);
+  }
+  for (const [key, coords] of required) {
+    if (backend._rasterTiles.has(key)) continue;
+    const tile = { coords, request: new AbortController(), done: false };
+    backend._rasterTiles.set(key, tile);
+  }
+  pumpRasterTiles(backend);
+  pruneRasterTiles(backend);
+}
+
+function pumpRasterTiles(backend) {
+  const map = backend._map;
+  if (!map) return;
+  const center = map.project(map.getCenter(), 0).divideBy(TILE_SIZE);
+  const pending = [...backend._rasterTiles.values()].filter(tile => !tile.started && !tile.request.signal.aborted);
+  const distance = ({ coords }) => Math.hypot((coords.x + 0.5) / 2 ** coords.z - center.x,
+    (coords.y + 0.5) / 2 ** coords.z - center.y);
+  pending.sort((a, b) => a.coords.z - b.coords.z || distance(a) - distance(b));
+  for (const tile of pending) {
+    if (backend._loadingTiles >= 4) break;
+    loadRasterTile(backend, tile);
+  }
+}
+
+export function releaseRasterTiles(backend) {
+  for (const tile of backend._rasterTiles.values()) releaseRasterTile(backend, tile);
+  backend._rasterProgram?.pipelineCache.clear();
+  backend._rasterProgram = null;
+  if (backend._rasterGeometry) {
+    for (const attribute of Object.values(backend._rasterGeometry.attributes)) {
+      destroyTexture(backend, attribute.buffer);
+    }
+    backend._rasterGeometry = null;
+  }
+}
+
+export function setRasterTerrain(backend, terrain) {
+  if (backend._terrain3D === terrain) return;
+  for (const tile of backend._rasterTiles.values()) {
+    if(backend._terrain3D) removeRasterTile(backend._terrain3D, tile);
+    if (tile.mesh) {
+      tile.mesh.visible = true;
+      setParent(tile.mesh, backend.root);
+    }
+  }
+  backend._terrain3D = terrain || null;
+  if (terrain) {
+    for (const tile of backend._rasterTiles.values()) {
+      if (tile.done) registerTerrainTile(backend, tile.coords, tile);
+    }
+  }
+}
+
+export function registerTerrainTile(backend, coords, tile) {
+  if (backend._terrain3D && tile.done && !tile.request.signal.aborted &&
+    backend._rasterTiles.get(`${coords.z}/${coords.x}/${coords.y}`) === tile) {
+    addRasterTile(backend._terrain3D, backend, coords, tile)
+      .catch(error => backend.fire('tileerror', { tile, coords, error }));
+  }
+}
+
+export function setRasterOpacity(backend, opacity) {
+  for (const tile of backend._rasterTiles.values()) {
+    if (tile.mesh) tile.mesh.opacity = opacity;
+    const terrainMesh = backend._terrain3D?._rasterTiles.get(tile);
+    if (terrainMesh) terrainMesh.opacity = opacity;
+  }
+  update(backend);
+}
+
+export function setRasterZIndex(backend, zIndex) {
+  for (const tile of backend._rasterTiles.values()) {
+    if (tile.mesh) tile.mesh.renderOrder = zIndex;
+    const terrainMesh = backend._terrain3D?._rasterTiles.get(tile);
+    if (terrainMesh) terrainMesh.renderOrder = zIndex;
+  }
+  update(backend);
+}
+
+export function getRasterTileSize() {
+  return new L.Point(TILE_SIZE, TILE_SIZE);
+}
+
+function loadRasterTile(backend, tile) {
+  tile.started = true;
+  const first = backend._loadingTiles === 0;
+  backend._loadingTiles++;
+  backend.fire('tileloadstart', { tile, coords: tile.coords });
+  if (first) backend.fire('loading');
+  return Promise.resolve(backend.ready).then(() => backend.options.archive.getZxy(
+    tile.coords.z, tile.coords.x, tile.coords.y, tile.request.signal
+  )).then(async result => {
+    if (tile.request.signal.aborted) return;
+    if (!result) throw new Error(`Tile ${tile.coords.z}/${tile.coords.x}/${tile.coords.y} is not in the offline archive`);
+    try {
+      tile.image = await createImageBitmap(new Blob([result.data]));
+    } catch {
+      throw 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;
+    backend._rasterVersion = (backend._rasterVersion || 0) + 1;
+    registerTerrainTile(backend, tile.coords, tile);
+    backend.fire('tileload', { tile, coords: tile.coords });
+    update(backend);
+  }).catch(error => {
+    if (tile.request.signal.aborted) return;
+    tile.error = error.message;
+    backend._rasterVersion = (backend._rasterVersion || 0) + 1;
+    backend.fire('tileerror', { tile, coords: tile.coords, error });
+    backend.fire('error', { error, coords: tile.coords });
+  }).finally(() => {
+    backend._loadingTiles--;
+    if (backend._map) {
+      pumpRasterTiles(backend);
+      pruneRasterTiles(backend);
+      if (!backend._loadingTiles) backend.fire('load');
+      update(backend);
+    }
+  });
+}
+
+function createRasterMesh(backend, tile) {
+  const device = backend.renderer.device;
+  const texture = {
+    device,
+    texture: device.createTexture({
+      size: [tile.image.width, tile.image.height],
+      format: 'rgba8unorm',
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+    }),
+    sampler: device.createSampler({ addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge',
+      magFilter: 'linear', minFilter: 'linear' }),
+    image: tile.image, format: 'rgba8unorm', srgb: false, uploaded: null,
+  };
+  if (!backend._rasterProgram) {
+    backend._rasterProgram = createProgram(backend, {
+      baseTexture: texture, unlit: true, alphaMode: 'BLEND',
+    });
+  }
+  if (!backend._rasterGeometry) backend._rasterGeometry = createGeometry(device);
+  const { coords } = tile;
+  const crs = backend._map.options.crs;
+  const origin = crs.project(backend.location);
+  const metres = Math.cos(backend.location.lat * Math.PI / 180);
+  const scale = crs.scale(coords.z);
+  const corner = crs.transformation.untransform(new L.Point(coords.x * TILE_SIZE, coords.y * TILE_SIZE), scale);
+  const opposite = crs.transformation.untransform(new L.Point((coords.x + 1) * TILE_SIZE, (coords.y + 1) * TILE_SIZE), scale);
+  const sizeX = (opposite.x - corner.x) * metres;
+  const sizeZ = -(opposite.y - corner.y) * metres;
+  tile.texture = texture;
+  tile.mesh = {
+    position: [(corner.x - origin.x) * metres, 0, -(corner.y - origin.y) * metres],
+    rotation: [0, 0, 0],
+    scale: [sizeX, 1, sizeZ],
+    worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    children: [], visible: true, device, geometry: backend._rasterGeometry,
+    program: backend._rasterProgram, texture,
+    opacity: backend.options.opacity, id: L.Layer._nextId++,
+    renderOrder: backend.options.zIndex || 0, tile, fadeDuration: 250, ground: true,
+  };
+  setParent(tile.mesh, backend.root);
+}
+
+function createGeometry(device) {
+  const attributes = {
+    position: { size: 3, data: new Float32Array([0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1]) },
+    normal: { size: 3, data: new Float32Array([0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0]) },
+    uv: { size: 2, data: new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]) },
+    index: { data: new Uint16Array([0, 2, 1, 1, 2, 3]) },
+  };
+  for (const [name, attribute] of Object.entries(attributes)) {
+    attribute.count = attribute.data.length / (attribute.size || 1);
+    attribute.indexFormat = 'uint16';
+    attribute.buffer = device.createBuffer({
+      size: attribute.data.byteLength,
+      usage: name === 'index' ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+        : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+  }
+  return { device, attributes, drawRange: { start: 0, count: attributes.index.count } };
+}
+
+function releaseRasterTile(backend, tile) {
+  const key = `${tile.coords.z}/${tile.coords.x}/${tile.coords.y}`;
+  if (backend._rasterTiles.get(key) !== tile) return;
+  backend._rasterTiles.delete(key);
+  backend._rasterVersion = (backend._rasterVersion || 0) + 1;
+  tile.request.abort();
+  if(backend._terrain3D) removeRasterTile(backend._terrain3D, tile);
+  if (tile.mesh) setParent(tile.mesh, null);
+  if (tile.texture) destroyTexture(backend, tile.texture.texture);
+  tile.image?.close();
+  backend.fire('tileunload', { tile, coords: tile.coords });
+  update(backend);
+}
+
+export function pruneRasterTiles(backend) {
+  const wanted = backend._wantedRasterTiles;
+  const now = performance.now();
+  if (backend._pruneVersion === backend._rasterVersion && backend._pruneWanted === wanted &&
+    now < backend._pruneAfter) return Number.isFinite(backend._pruneAfter);
+  backend._pruneVersion = backend._rasterVersion;
+  backend._pruneWanted = wanted;
+  backend._pruneAfter = Infinity;
+  const pending = [...wanted].filter(key => {
+    const tile = backend._rasterTiles.get(key);
+    if (tile?.done && now - tile.loadedAt < 250) {
+      backend._pruneAfter = Math.min(backend._pruneAfter, tile.loadedAt + 250);
+    }
+    return !tile?.done || now - tile.loadedAt < 250;
+  }).map(key => {
+    const [z, x, y] = key.split('/').map(Number);
+    return { z, x, y };
+  });
+  for (const [key, tile] of backend._rasterTiles) {
+    if (wanted.has(key)) continue;
+    const overlaps = pending.some(coords => {
+      const zoom = Math.min(coords.z, tile.coords.z);
+      return 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));
+    });
+    if (!overlaps) releaseRasterTile(backend, tile);
+  }
+  return Number.isFinite(backend._pruneAfter);
+}

package/src/utils/raycast.js

@@ -0,0 +1,60 @@
+import { intersectMeshes } from './intersectMeshes.js';
+import { traverse } from './traverse.js';
+import { updateCamera } from './updateCamera.js';
+import { updateWorldMatrix } from './updateWorldMatrix.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 = backend.root.children, recursive = true) {
+  if (!backend.renderer) {
+    return [];
+  }
+  backend._beforeRaycast?.();
+  const rect = backend._map.getContainer().getBoundingClientRect();
+  updateWorldMatrix(backend.scene);
+  updateCamera(backend.camera);
+  // Unproject the mouse (-1..1) into a world-space ray from the camera.
+  const inverseCamera = new DOMMatrix(backend.camera.projectionViewMatrix).inverse();
+  const inverseCameraValues = inverseCamera.toFloat64Array();
+  if (![...inverseCameraValues].every(Number.isFinite)) {
+    throw new Error('Singular 3D transform');
+  }
+  backend.raycaster.origin[0] = backend.camera.position[0];
+  backend.raycaster.origin[1] = backend.camera.position[1];
+  backend.raycaster.origin[2] = backend.camera.position[2];
+  const unprojected = new DOMPoint(
+    ((event.clientX - rect.left) / rect.width) * 2 - 1,
+    -((event.clientY - rect.top) / rect.height) * 2 + 1,
+    0,
+    1
+  ).matrixTransform(inverseCamera);
+  const end = [
+    unprojected.x / unprojected.w,
+    unprojected.y / unprojected.w,
+    unprojected.z / unprojected.w
+  ];
+  backend.raycaster.direction[0] = end[0] - backend.raycaster.origin[0];
+  backend.raycaster.direction[1] = end[1] - backend.raycaster.origin[1];
+  backend.raycaster.direction[2] = end[2] - backend.raycaster.origin[2];
+  const rayLength = Math.hypot(...backend.raycaster.direction) || 1;
+  backend.raycaster.direction[0] /= rayLength;
+  backend.raycaster.direction[1] /= rayLength;
+  backend.raycaster.direction[2] /= rayLength;
+  const meshes = [];
+  for (const object of objects) {
+    if (recursive) traverse(object, mesh => {
+      if (!mesh.visible) return true;
+      if (mesh.geometry && mesh._appearance !== 0) meshes.push(mesh);
+    });
+    else if (object.geometry && object.visible && object._appearance !== 0) meshes.push(object);
+  }
+  return intersectMeshes(backend.raycaster, meshes, backend.renderer.uniformData?.[55]);
+}

package/src/utils/read.js

@@ -0,0 +1,29 @@
+export async function read(backend, offset, length, signal) {
+  signal?.throwIfAborted();
+  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) ||
+    offset < 0 || length <= 0 || !Number.isSafeInteger(offset + length)) {
+    throw new Error('Invalid PMTiles byte range');
+  }
+  const response = await fetch(backend.url, {
+    headers: { Range: `bytes=${offset}-${offset + length - 1}` }, signal,
+  });
+  if (!response.ok) {
+    throw new Error(`Unable to read PMTiles: HTTP ${response.status}`);
+  }
+  const etag = response.headers.get('ETag');
+  if (backend._etag && etag !== backend._etag) {
+    throw new Error('PMTiles archive changed; recreate the layer');
+  }
+  if (etag) backend._etag = etag;
+  let data = await response.arrayBuffer();
+  if (response.status === 200) {
+    data = data.slice(offset, offset + length);
+  } else if (response.status !== 206 ||
+    !response.headers.get('Content-Range')?.startsWith(`bytes ${offset}-${offset + length - 1}/`)) {
+    throw new Error('Invalid PMTiles range response');
+  }
+  if (data.byteLength !== length) {
+    throw new Error('Truncated PMTiles range');
+  }
+  return data;
+}

package/src/utils/readAccessor.js

@@ -0,0 +1,68 @@
+import { types } from "./types.js";
+import { sizes } from "./sizes.js";
+
+/** Decode packed, interleaved, normalized or sparse glTF accessor data. */
+
+export function readAccessor(description, index) {
+  const spec = description.accessors[index], Type = types[spec.componentType], size = sizes[spec.type];
+  if (!Type || !size || !Number.isInteger(spec.count) || spec.count < 0) {
+    throw new Error('Invalid glTF accessor');
+  }
+  const data = new Type(spec.count * size);
+  // The destination callback is sequential for base data and sparse-indexed for overrides.
+  const read = (viewIndex, offset, count, stride, output) => {
+    const view = description.bufferViews[viewIndex], bytes = Type.BYTES_PER_ELEMENT;
+    const buffer = description.buffers[view.buffer].binary;
+    stride ||= size * bytes;
+    if (!buffer || stride < size * bytes || offset < 0 ||
+      (view.byteOffset || 0) + view.byteLength > buffer.byteLength ||
+      (count - 1) * stride + size * bytes + offset > view.byteLength) throw new Error('glTF accessor outside buffer view');
+    for (let i = 0; i < count; i++) {
+      const values = new Type(buffer.slice((view.byteOffset || 0) + offset + i * stride,
+        (view.byteOffset || 0) + offset + i * stride + size * bytes));
+      data.set(values, output(i) * size);
+    }
+  };
+  if (spec.bufferView !== undefined) {
+    read(
+      spec.bufferView,
+      spec.byteOffset || 0,
+      spec.count,
+      description.bufferViews[spec.bufferView].byteStride,
+      i => i
+    );
+  }
+  if (spec.sparse) {
+    const sparse = spec.sparse, Index = types[sparse.indices.componentType];
+    if (![Uint8Array, Uint16Array, Uint32Array].includes(Index)) {
+      throw new Error('Invalid sparse glTF indices');
+    }
+    const view = description.bufferViews[sparse.indices.bufferView];
+    const offset = (view.byteOffset || 0) + (sparse.indices.byteOffset || 0);
+    if (sparse.count > spec.count || (sparse.indices.byteOffset || 0) + sparse.count * Index.BYTES_PER_ELEMENT > view.byteLength) {
+      throw new Error('Invalid sparse glTF indices');
+    }
+    const indices = new Index(description.buffers[view.buffer].binary.slice(offset, offset + sparse.count * Index.BYTES_PER_ELEMENT));
+    read(
+      sparse.values.bufferView,
+      sparse.values.byteOffset || 0,
+      sparse.count,
+      0,
+      i => {
+        if (indices[i] >= spec.count) throw new Error('Invalid sparse glTF index');
+        return indices[i];
+      }
+    );
+  }
+  if (spec.componentType === 5126) {
+    return { data, size };
+  }
+  const normalized = new Float32Array(data.length);
+  // Normalization is a glTF accessor rule, not sRGB conversion; indices stay integers.
+  for (let i = 0; i < data.length; i++) {
+    normalized[i] = spec.normalized
+      ? Math.max(-1, data[i] / (Type === Int8Array ? 127 : Type === Int16Array ? 32767 : Type === Uint8Array ? 255 : Type === Uint32Array ? 4294967295 : 65535))
+      : data[i];
+  }
+  return { data: normalized, size, indices: data };
+}

package/src/utils/releaseArea.js

@@ -0,0 +1,34 @@
+import { setHighlight } from './setHighlight.js';
+import { showFeature } from './showFeature.js';
+import { setParent } from './setParent.js';
+import { update } from './update.js';
+
+/** Cancel pending work and dispose this block's GPU data, including any hover highlight. */
+
+export function releaseArea(backend, area) {
+  area.request.abort();
+  if (area.mesh) {
+    if (backend.highlightedFeature?.mesh === area.mesh) {
+      setHighlight(backend, null);
+      backend.hoveredFeature = null;
+      showFeature(backend, null);
+    }
+    setParent(area.mesh, null);
+    update(backend);
+    const geometry = area.mesh.geometry;
+    for (const attribute of Object.values(geometry.attributes)) attribute.buffer.destroy();
+    area.mesh.program.pipelineCache.clear();
+  }
+}
+/** Emit a snapshot for consumers; ready does not wait for all neighborhood tasks. */
+
+export function updateStatus(backend, enabled = true) {
+  const progress = { enabled, loaded: 0, skipped: 0, pending: 0, errors: [] };
+  for (const area of backend._areas.values()) {
+    if (area.error) progress.errors.push(area.error);
+    else if (!area.done) progress.pending++;
+    progress.loaded += area.buildings ?? 0;
+    progress.skipped += area.skipped ?? 0;
+  }
+  backend.fire('progress', progress);
+}

package/src/utils/removeRasterTile.js

@@ -0,0 +1,13 @@
+import { destroyTexture } from './destroyTexture.js';
+import { setParent } from './setParent.js';
+import { update } from './update.js';
+
+export function removeRasterTile(layer, tile) {
+  layer._terrainRequest?.abort();
+  const mesh = layer._rasterTiles.get(tile);
+  if (!mesh) return;
+  setParent(mesh, null);
+  update(layer);
+  if (mesh.texture !== tile.texture) destroyTexture(layer, mesh.texture.texture);
+  layer._rasterTiles.delete(tile);
+}