leaflet-city-mapper 0.0.2 → 0.0.4

package/src/utils/bridgeElevation.js

@@ -1,18 +0,0 @@
-/** Height inside a bridge deck, or null outside its triangles. */
-export function bridgeElevation(point, bridges) {
-  // Bridges bucketed by 64 DEM pixels.
-  for (const bridge of bridges?.get(`${Math.floor(point.x / 64)}/${Math.floor(point.y / 64)}`) || []) {
-    if (point.x < bridge.min[0] || point.x > bridge.max[0] || point.y < bridge.min[1] || point.y > bridge.max[1]) {
-      continue;
-    }
-    for (const [a, b, c] of bridge.triangles) {
-      const d = (b[1] - c[1]) * (a[0] - c[0]) + (c[0] - b[0]) * (a[1] - c[1]);
-      const u = ((b[1] - c[1]) * (point.x - c[0]) + (c[0] - b[0]) * (point.y - c[1])) / d;
-      const v = ((c[1] - a[1]) * (point.x - c[0]) + (a[0] - c[0]) * (point.y - c[1])) / d;
-      if (u >= 0 && v >= 0 && u + v <= 1) {
-        return u * a[2] + v * b[2] + (1 - u - v) * c[2];
-      }
-    }
-  }
-  return null;
-}

package/src/utils/build.js

@@ -1,20 +0,0 @@
-
-export const build = parts => {
-  const position = [], normal = [], color = [];
-  const triangle = (a, b, c, tint) => {
-    const u = b.map((v, i) => v - a[i]), v = c.map((w, i) => w - a[i]);
-    const n = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]], length = Math.hypot(...n);
-    for (const point of [a, b, c]) { position.push(...point); normal.push(...n.map(w => w / length)); color.push(...tint); }
-  };
-  for (const [ring, bottom, top, tint, topRing = ring] of parts) {
-    const low = ring.map(([x, z]) => [x, bottom, z]), high = topRing.map(([x, z]) => [x, top, z]);
-    for (let i = 0; i < ring.length; i++) {
-      const j = (i + 1) % ring.length;
-      triangle(low[i], low[j], high[j], tint); triangle(low[i], high[j], high[i], tint);
-    }
-    for (let i = 1; i < ring.length - 1; i++) {
-      triangle(high[0], high[i], high[i + 1], tint); triangle(low[0], low[i + 1], low[i], tint);
-    }
-  }
-  return { position, normal, color };
-};

package/src/utils/cameraControls.js

@@ -1,287 +0,0 @@
-function editable(target) {
-  return target.closest?.('input,textarea,select,[contenteditable="true"]');
-}
-
-function dragCamera(map, element, accept, sensitivity = [0.8, 0.5], orbit = false) {
-  let drag, moved = false;
-  const end = event => {
-    if (!drag) return;
-    if (event?.pointerId !== undefined && event.pointerId !== drag.id) return;
-    const finished = drag;
-    drag = null;
-    if (element.hasPointerCapture?.(finished.id)) element.releasePointerCapture(finished.id);
-    if (finished.dragging && map.getContainer()._leaflet_id) map.dragging.enable();
-    element.style.cursor = finished.cursor;
-  };
-  const down = event => {
-    if (drag || !accept(event) || editable(event.target)) return;
-    event.preventDefault();
-    event.stopPropagation();
-    moved = false;
-    const rect = map.getContainer().getBoundingClientRect();
-    drag = { id: event.pointerId, x: event.clientX, y: event.clientY, cursor: element.style.cursor,
-      cx: rect.left + rect.width / 2, cy: rect.top + rect.height / 2, dragging: map.dragging?.enabled() };
-    map.dragging?.disable();
-    element.focus?.({ preventScroll: true });
-    element.setPointerCapture(event.pointerId);
-    element.style.cursor = 'grabbing';
-  };
-  const move = event => {
-    if (!drag || drag.id !== event.pointerId) return;
-    const x = event.clientX - drag.x, y = event.clientY - drag.y;
-    if (Math.hypot(x, y) < 3 && !moved) return;
-    map._stopPitchBearingAnimation();
-    moved = true;
-    event.preventDefault();
-    let bearing = x * sensitivity[0];
-    if (orbit) {
-      if (Math.abs(drag.cy - drag.y) > 100) {
-        const angle = Math.atan2(event.clientY - drag.cy, event.clientX - drag.cx) -
-          Math.atan2(event.clientY - drag.cy, drag.x - drag.cx);
-        bearing = Math.atan2(Math.sin(angle), Math.cos(angle)) * 180 / Math.PI;
-      } else bearing *= event.clientY < drag.cy ? 1 : -1;
-    }
-    map._setPitchAndBearing(map.getPitch() - y * sensitivity[1], map.getBearing() + bearing);
-    drag.x = event.clientX; drag.y = event.clientY;
-  };
-  const click = event => { if (moved) { event.preventDefault(); event.stopPropagation(); moved = false; } };
-  const context = event => {
-    if (drag || moved) { event.preventDefault(); event.stopPropagation(); }
-  };
-  element.addEventListener('pointerdown', down, true);
-  element.addEventListener('pointermove', move);
-  element.addEventListener('pointerup', end);
-  element.addEventListener('pointercancel', end);
-  element.addEventListener('lostpointercapture', end);
-  element.addEventListener('click', click, true);
-  element.addEventListener('contextmenu', context);
-  window.addEventListener('blur', end);
-  return () => {
-    end();
-    element.removeEventListener('pointerdown', down, true);
-    element.removeEventListener('pointermove', move);
-    element.removeEventListener('pointerup', end);
-    element.removeEventListener('pointercancel', end);
-    element.removeEventListener('lostpointercapture', end);
-    element.removeEventListener('click', click, true);
-    element.removeEventListener('contextmenu', context);
-    window.removeEventListener('blur', end);
-  };
-}
-
-L.Control.Rotate = L.Control.extend({
-  options: { position: 'topleft', closeOnZeroBearing: true, visualizePitch: true },
-  onAdd(map) {
-    const container = L.DomUtil.create('div', 'leaflet-control-rotate leaflet-bar');
-    const button = L.DomUtil.create('a', 'leaflet-control-rotate-toggle', container);
-    button.href = '#';
-    button.setAttribute('role', 'button');
-    button.title = this.options.visualizePitch ? 'Reset bearing and pitch' : 'Reset bearing to north';
-    button.setAttribute('aria-label', button.title);
-    button.style.cssText = 'cursor:grab;touch-action:none';
-    const arrow = L.DomUtil.create('span', 'leaflet-control-rotate-arrow', button);
-    arrow.setAttribute('aria-hidden', 'true');
-    arrow.style.cssText = 'display:block;width:100%;height:100%;pointer-events:none;background: no-repeat center / 29px 29px';
-    arrow.style.backgroundImage = 'url("data:image/svg+xml,%3Csvg xmlns=%27http://www.w3.org/2000/svg%27 viewBox=%270 0 29 29%27%3E%3Cpath fill=%27%23333%27 d=%27M10.5 14 14.5 6 18.5 14Z%27/%3E%3Cpath fill=%27%23ccc%27 d=%27M10.5 16 14.5 24 18.5 16Z%27/%3E%3C/svg%3E")';
-    button.onclick = event => {
-      event.preventDefault();
-      if (this.options.visualizePitch) map.resetNorthPitch();
-      else map.resetNorth();
-      if (event.detail) map.getContainer().focus({ preventScroll: true });
-    };
-    button.onkeydown = event => {
-      const step = event.shiftKey ? 15 : 5;
-      if (event.key === 'ArrowLeft') map.setBearing(map.getBearing() - step);
-      else if (event.key === 'ArrowRight') map.setBearing(map.getBearing() + step);
-      else if (event.key === 'ArrowUp' && this.options.visualizePitch) map.setPitch(map.getPitch() + step);
-      else if (event.key === 'ArrowDown' && this.options.visualizePitch) map.setPitch(map.getPitch() - step);
-      else if (event.key === 'Home' || event.key === ' ') button.click();
-      else return;
-      event.preventDefault();
-      event.stopPropagation();
-    };
-    this._refresh = () => {
-      const pitch = this.options.visualizePitch ? map.getPitch() : 0;
-      arrow.style.transform = `scale(${1 / Math.sqrt(Math.cos(pitch * Math.PI / 180))}) rotateX(${pitch}deg) rotate(${map.getBearing()}deg)`;
-      button.setAttribute('aria-description', `Bearing ${Math.round(map.getBearing())} degrees, pitch ${Math.round(map.getPitch())} degrees. Arrow keys adjust the camera; Home resets it.`);
-      // Do not hide a focused control, even when the caller opts into auto-hiding.
-      container.style.display = this.options.closeOnZeroBearing && !map.getBearing() && !pitch &&
-        !container.contains(document.activeElement) ? 'none' : '';
-    };
-    map.on('rotate pitch', this._refresh);
-    this._refresh();
-    this._endDrag = dragCamera(map, button, event => event.button === 0,
-      [0.8, this.options.visualizePitch ? 0.5 : 0]);
-    button.addEventListener('focusout', this._refresh);
-    L.DomEvent.on(button, 'dblclick contextmenu', L.DomEvent.stop);
-    L.DomEvent.disableClickPropagation(container);
-    L.DomEvent.disableScrollPropagation(container);
-    return container;
-  },
-  onRemove(map) {
-    map.off('rotate pitch', this._refresh);
-    this._endDrag();
-  },
-});
-if (L.control) L.control.rotate = options => new L.Control.Rotate(options);
-
-const ShiftRotate = L.Handler.extend({
-  addHooks() {
-    this._wheel = event => {
-      if (!event.shiftKey || editable(event.target) || event.target.closest('.leaflet-control')) return;
-      event.preventDefault(); event.stopImmediatePropagation();
-      this._map.setBearing(this._map.getBearing() + Math.sign(event.deltaY) * 5);
-    };
-    this._map.getContainer().addEventListener('wheel', this._wheel, { passive: false, capture: true });
-  },
-  removeHooks() { this._map.getContainer().removeEventListener('wheel', this._wheel, true); },
-});
-const PitchDrag = L.Handler.extend({
-  addHooks() {
-    this._end = dragCamera(this._map, this._map.getContainer(), event =>
-      !event.target.closest('.leaflet-control,.leaflet-marker-icon,.leaflet-popup') &&
-      (event.button === 2 || event.button === 0 && event.ctrlKey), [0.8, 0.5], true);
-  },
-  removeHooks() {
-    this._end();
-  },
-});
-const Compass = L.Handler.extend({
-  addHooks() {
-    const generation = this._generation = (this._generation || 0) + 1;
-    this._orientation = event => {
-      const bearing = Number.isFinite(event.webkitCompassHeading) ? -event.webkitCompassHeading : event.alpha;
-      const orientation = event.absolute ? 0 : (screen.orientation?.angle ?? window.orientation ?? 0);
-      if (Number.isFinite(bearing)) this._map.setBearing(bearing - orientation);
-    };
-    const permission = window.DeviceOrientationEvent?.requestPermission;
-    new Promise(resolve => resolve(permission ? permission.call(window.DeviceOrientationEvent) : 'granted')).then(result => {
-      if (!this.enabled() || this._generation !== generation) return;
-      if (!window.DeviceOrientationEvent || result !== 'granted') throw new Error('Device compass permission unavailable or denied');
-      window.addEventListener('deviceorientation', this._orientation);
-      window.addEventListener('deviceorientationabsolute', this._orientation);
-    }).catch(error => {
-      this.disable();
-      this._map.fire('error', { error });
-    });
-  },
-  removeHooks() {
-    this._generation++;
-    window.removeEventListener('deviceorientation', this._orientation);
-    window.removeEventListener('deviceorientationabsolute', this._orientation);
-  },
-});
-
-const ContainerResize = L.Handler.extend({
-  addHooks() {
-    this._observer = new ResizeObserver(() => this._map.invalidateSize());
-    this._observer.observe(this._map.getContainer());
-  },
-  removeHooks() { this._observer.disconnect(); },
-});
-
-export function cameraControls(map) {
-  map.addHandler('trackContainerMutation', ContainerResize);
-  if (!map.options.rotate) return;
-  map.addHandler('shiftKeyRotate', ShiftRotate);
-  map.addHandler('pitchDrag', PitchDrag);
-  map.addHandler('compassBearing', Compass);
-  // Two optional touch modes share one pinch/pan recognizer with Leaflet's zoom setting.
-  const TouchMode = L.Handler.extend({
-    addHooks() { map.fire('cameratouchchange'); },
-    removeHooks() { map.fire('cameratouchchange'); },
-  });
-  map.addHandler('touchRotate', TouchMode);
-  map.addHandler('touchPitch', TouchMode);
-  const container = map.getContainer();
-  let touch, nativeZoom;
-  const start = event => {
-    if (event.touches.length !== 2 || event.target.closest('.leaflet-control')) return;
-    if (!map.touchRotate.enabled() && !map.touchPitch.enabled()) return;
-    const [a, b] = event.touches;
-    if (Math.hypot(b.clientX - a.clientX, b.clientY - a.clientY) < 1) return;
-    map._stopPitchBearingAnimation();
-    const middle = new L.Point((a.clientX + b.clientX) / 2, (a.clientY + b.clientY) / 2)
-      .subtract(new L.Point(container.getBoundingClientRect().left, container.getBoundingClientRect().top));
-    touch = { angle: Math.atan2(b.clientY - a.clientY, b.clientX - a.clientX),
-      distance: Math.hypot(b.clientX - a.clientX, b.clientY - a.clientY), middle,
-      anchor: map.containerPointToLatLng(middle), zoom: map.getZoom(),
-      bearing: map.getBearing(), pitch: map.getPitch(), zooming: map.touchZoom?.enabled(),
-      dragging: map.dragging?.enabled() };
-    map.dragging?.disable();
-    event.preventDefault(); event.stopImmediatePropagation();
-  };
-  const move = event => {
-    if (!touch || event.touches.length !== 2) return;
-    const [a, b] = event.touches;
-    const angle = Math.atan2(b.clientY - a.clientY, b.clientX - a.clientX);
-    const middle = new L.Point((a.clientX + b.clientX) / 2, (a.clientY + b.clientY) / 2)
-      .subtract(new L.Point(container.getBoundingClientRect().left, container.getBoundingClientRect().top));
-    const delta = Math.atan2(Math.sin(angle - touch.angle), Math.cos(angle - touch.angle)) * 180 / Math.PI;
-    map._setPitchAndBearing(map.touchPitch.enabled() ? touch.pitch - (middle.y - touch.middle.y) * 0.25 : touch.pitch,
-      map.touchRotate.enabled() ? touch.bearing + delta : touch.bearing);
-    const distance = Math.hypot(b.clientX - a.clientX, b.clientY - a.clientY);
-    if (distance < 1) return;
-    const zoom = touch.zooming ? Math.max(map.getMinZoom(), Math.min(map.getMaxZoom(),
-      touch.zoom + Math.log2(distance / touch.distance))) : touch.zoom;
-    map.setView(map.getCenter(), zoom, { animate: false });
-    if (map.options.touchZoom !== 'center') {
-      const projected = map.project(touch.anchor).subtract(map.project(map.containerPointToLatLng(middle)));
-      map.setView(map.unproject(map.project(map.getCenter()).add(projected)), map.getZoom(), { animate: false });
-    }
-    event.preventDefault(); event.stopImmediatePropagation();
-  };
-  const end = event => {
-    if (!touch) return;
-    if (event?.touches?.length >= 2) return;
-    if (touch.dragging && container._leaflet_id) map.dragging.enable();
-    const snap = touch.snap;
-    map.options.zoomSnap = snap;
-    if (touch.zooming && snap && container._leaflet_id) {
-      map.setZoom(Math.round(map.getZoom() / snap) * snap, { animate: false });
-    }
-    touch = null;
-  };
-  const change = () => {
-    const active = map.touchRotate.enabled() || map.touchPitch.enabled();
-    if (active && nativeZoom === undefined) {
-      nativeZoom = map.touchZoom?.enabled();
-      map.touchZoom?.disable();
-    } else if (!active && nativeZoom !== undefined) {
-      end();
-      if (nativeZoom && container._leaflet_id) map.touchZoom.enable();
-      nativeZoom = undefined;
-    }
-  };
-  // Preserve the zoom-enabled setting before handing pinch recognition over.
-  change();
-  const startTouch = event => {
-    if (touch) return;
-    start(event);
-    if (touch) {
-      if (nativeZoom !== undefined) touch.zooming = nativeZoom;
-      touch.snap = map.options.zoomSnap;
-      map.options.zoomSnap = 0;
-    }
-  };
-  container.addEventListener('touchstart', startTouch, { capture: true, passive: false });
-  container.addEventListener('touchmove', move, { capture: true, passive: false });
-  container.addEventListener('touchend', end, true);
-  container.addEventListener('touchcancel', end, true);
-  window.addEventListener('blur', end);
-  map.on('cameratouchchange', change);
-  if (map.options.rotateControl) {
-    map.rotateControl = new L.Control.Rotate(typeof map.options.rotateControl === 'object' ? map.options.rotateControl : {});
-    map.rotateControl.addTo(map);
-  }
-  map.once('unload', () => {
-    end();
-    container.removeEventListener('touchstart', startTouch, true);
-    container.removeEventListener('touchmove', move, true);
-    container.removeEventListener('touchend', end, true);
-    container.removeEventListener('touchcancel', end, true);
-    window.removeEventListener('blur', end);
-    map.off('cameratouchchange', change);
-    map.rotateControl?.remove();
-  });
-}

package/src/utils/collider.js

@@ -1,62 +0,0 @@
-import { CELL } from './CELL.js';
-import { colliders } from './colliders.js';
-
-
-export function collider(mesh) {
-  let c = colliders.get(mesh.geometry);
-  if (c) return c;
-  const m = mesh.worldMatrix, { position: { data: p }, index, normal, uv } = mesh.geometry.attributes;
-
-  const count = index ? index.count : p.length / 3, tri = [], nrm = [], cells = new Map(), v = [];
-
-  for (let i = 0; i < count; i += 3) {
-    const first = index ? index.data[i] : i;
-    // Streetlight halos (uv.x <= 2, see scene/picking.js) are light, not matter.
-    if (mesh.program.nightLight && uv && uv.data[first * 2] <= 2) {
-      continue;
-    }
-    for (let k = 0; k < 3; k++) {
-      const j = (index ? index.data[i + k] : i + k) * 3, x = p[j], y = p[j + 1], z = p[j + 2];
-      v[k * 3] = m[0] * x + m[4] * y + m[8] * z + m[12];
-      v[k * 3 + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
-      v[k * 3 + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
-    }
-    const ex = v[3] - v[0], ey = v[4] - v[1], ez = v[5] - v[2], fx = v[6] - v[0], fy = v[7] - v[1], fz = v[8] - v[2];
-
-    let nx = ey * fz - ez * fy, nz = ex * fy - ey * fx;
-
-    const ny = ez * fx - ex * fz, length = Math.hypot(nx, ny, nz);
-
-    if (!length || Math.abs(ny) > 0.9 * length) {
-      continue;
-    }
-
-    if (normal) {
-      // The stored normal tells the outside, whatever the winding.
-      const j = first * 3, a = normal.data;
-      if ((m[0] * a[j] + m[4] * a[j + 1] + m[8] * a[j + 2]) * nx + (m[2] * a[j] + m[6] * a[j + 1] + m[10] * a[j + 2]) * nz < 0) { nx = -nx; nz = -nz; }
-    }
-
-    const h = Math.hypot(nx, nz), t = nrm.length / 2;
-
-    tri.push(...v);
-    nrm.push(nx / h, nz / h);
-
-    for (let ix = Math.floor(Math.min(v[0], v[3], v[6]) / CELL); ix <= Math.floor(Math.max(v[0], v[3], v[6]) / CELL); ix++)
-      for (let iz = Math.floor(Math.min(v[2], v[5], v[8]) / CELL); iz <= Math.floor(Math.max(v[2], v[5], v[8]) / CELL); iz++) {
-        const key = ix + ',' + iz;
-        if (!cells.has(key)) {
-          cells.set(key, []);
-        }
-        cells.get(key).push(t);
-      }
-  }
-  c = {
-    tri: Float32Array.from(tri),
-    nrm: Float32Array.from(nrm),
-    cells,
-    origin: [m[12], m[13], m[14]]
-  };
-  colliders.set(mesh.geometry, c);
-  return c;
-}

package/src/utils/colliders.js

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

package/src/utils/computeBounds.js

@@ -1,17 +0,0 @@
-/** Cache local AABB and center for ray picking and transparent mesh sorting. */
-
-export function computeBounds(geometry) {
-  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity], data = geometry.attributes.position.data;
-  for (let i = 0; i < data.length; i++) {
-    min[i % 3] = Math.min(min[i % 3], data[i]);
-    max[i % 3] = Math.max(max[i % 3], data[i]);
-  }
-  const center = min.map((v, i) => (v + max[i]) / 2);
-  let radius = 0;
-  for (let i = 0; i < data.length; i += 3) {
-    radius = Math.max(radius, Math.hypot(
-      data[i] - center[0], data[i + 1] - center[1], data[i + 2] - center[2]
-    ));
-  }
-  geometry.bounds = { min, max, center, radius };
-}

package/src/utils/conformModelToTerrain.js

@@ -1,69 +0,0 @@
-import { computeBounds } from './computeBounds.js';
-import { getElevation } from './getElevation.js';
-import { update } from './update.js';
-import { updateWorldMatrix } from './updateWorldMatrix.js';
-import { vertexNormals } from './vertexNormals.js';
-
-const HEIGHT = 8;
-
-export function conformModelToTerrain(layer, terrain) {
-  if (!layer.model) return;
-  const meshes = [];
-  const visit = node => {
-    if (node.geometry?.attributes.position) meshes.push(node);
-    for (const child of node.children) visit(child);
-  };
-  visit(layer.model);
-  if (!terrain?._terrainReady || !layer.options.terrainConform) {
-    for (const mesh of meshes) {
-      const positions = mesh.geometry._terrainBasePositions;
-      if (!positions) continue;
-      const geometry = mesh.geometry, position = geometry.attributes.position;
-      position.data.set(positions);
-      mesh.device.queue.writeBuffer(position.buffer, 0, positions);
-      const normals = geometry._terrainBaseNormals;
-      if (normals) {
-        geometry.attributes.normal.data.set(normals);
-        mesh.device.queue.writeBuffer(geometry.attributes.normal.buffer, 0, normals);
-      }
-      computeBounds(geometry);
-    }
-    return;
-  }
-
-  updateWorldMatrix(layer.root);
-  const map = layer._map, crs = map.options.crs;
-  const origin = crs.project(layer._shared._sceneOrigin);
-  const metres = Math.cos(layer._shared._sceneOrigin.lat * Math.PI / 180);
-  const pixelScale = crs.scale(terrain._terrainZoom);
-
-  for (const mesh of meshes) {
-    const geometry = mesh.geometry, attribute = geometry.attributes.position;
-    geometry._terrainBasePositions ||= attribute.data.slice();
-    const normal = geometry.attributes.normal;
-    geometry._terrainBaseNormals ||= normal.data.slice();
-    attribute.data.set(geometry._terrainBasePositions);
-    const world = mesh.worldMatrix, inverse = new DOMMatrix(world).inverse().toFloat64Array();
-    for (let i = 0; i < attribute.data.length; i += 3) {
-      const x = attribute.data[i], y = attribute.data[i + 1], z = attribute.data[i + 2];
-      const worldY = world[1] * x + world[5] * y + world[9] * z + world[13];
-      const weight = Math.max(0, Math.min(1, 1 - (worldY - layer.root.position[1]) / HEIGHT));
-      if (!weight) continue;
-      const worldX = world[0] * x + world[4] * y + world[8] * z + world[12];
-      const worldZ = world[2] * x + world[6] * y + world[10] * z + world[14];
-      const point = crs.transformation.transform(new L.Point(
-        origin.x + worldX / metres, origin.y - worldZ / metres), pixelScale);
-      const elevation = getElevation(terrain, point);
-      if (!Number.isFinite(elevation)) continue;
-      const offset = (elevation - worldY) * weight;
-      attribute.data[i] += inverse[4] * offset;
-      attribute.data[i + 1] += inverse[5] * offset;
-      attribute.data[i + 2] += inverse[6] * offset;
-    }
-    mesh.device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-    normal.data.set(vertexNormals(attribute.data, geometry.attributes.index?.data));
-    mesh.device.queue.writeBuffer(normal.buffer, 0, normal.data);
-    computeBounds(geometry);
-  }
-  update(layer);
-}

package/src/utils/createMesh.js

@@ -1,31 +0,0 @@
-import { emptyNode } from './emptyNode.js';
-import { createProgram } from './createProgram.js';
-import { setParent } from './setParent.js';
-import { update } from './update.js';
-
-/**
- * Add a non-indexed, vertex-coloured mesh from flat vec3 arrays `{ position, normal, color }` in layer-local metres.
- * `usage` adds GPUBufferUsage flags to the vertex buffers (e.g. STORAGE for compute passes).
- * A supplied `program` shares compiled shaders and pipelines across compatible meshes.
- */
-
-export function createMesh(backend, data, material = {}, usage = 0, program) {
-  const { device } = backend.renderer, attributes = {};
-  for (const [name, values] of Object.entries(data)) {
-    const array = new Float32Array(values);
-    const size = name === 'uv' ? 2 : 3;
-    const buffer = device.createBuffer({ size: Math.max(4, array.byteLength), usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST | usage });
-    device.queue.writeBuffer(buffer, 0, array);
-    attributes[name] = { size, data: array, count: array.length / size, buffer };
-  }
-  const mesh = {
-    ...emptyNode(),
-    device,
-    geometry: { device, attributes, drawRange: { start: 0, count: attributes.position.count } },
-    program: program || createProgram(backend, { vertexColors: true, doubleSided: true, ...material }),
-    id: L.Layer._nextId++, renderOrder: 0, extras: {},
-  };
-  setParent(mesh, backend.root);
-  update(backend);
-  return mesh;
-}

package/src/utils/createProgram.js

@@ -1,92 +0,0 @@
-import { materialShaders } from './materialShaders.js';
-import { elevationWGSL } from './elevationWGSL.js';
-
-
-export function createProgram(backend, material = {}) {
-  const shaders = materialShaders(
-    material,
-    !!backend.options.nightSparkle,
-    material.terrain ? elevationWGSL : ''
-  );
-  const vertex = backend.renderer.device.createShaderModule({ code: shaders.vertex });
-  const fragment = backend.renderer.device.createShaderModule({ code: shaders.fragment });
-  Promise.all([
-    vertex.getCompilationInfo(),
-    fragment.getCompilationInfo()
-  ]).then(infos => {
-    const errors = infos.flatMap(info => info.messages).filter(message => message.type === 'error');
-    if (errors.length) {
-      backend.fire('error', {
-        error: new Error(`Unable to compile Layer3D WGSL: ${errors.map(error => error.message).join('\n')}`),
-      });
-    }
-  }).catch(error => backend.fire('error', { error }));
-  const vertexBuffers = [
-    { arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }] },
-    { arrayStride: 12, attributes: [{ shaderLocation: 1, offset: 0, format: 'float32x3' }] },
-    material.vertexColors ? { arrayStride: 12, attributes: [{ shaderLocation: 2, offset: 0, format: 'float32x3' }] } : null,
-    shaders.textured ? { arrayStride: 8, attributes: [{ shaderLocation: 3, offset: 0, format: 'float32x2' }] } : null,
-  ];
-  const bindGroupEntries = [{
-    binding: 0,
-    visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
-    buffer: { type: 'uniform', hasDynamicOffset: true },
-  }, {
-    binding: 1,
-    visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
-    buffer: { type: 'uniform' },
-  }];
-  if (shaders.hasTerrain) {
-    bindGroupEntries.push({
-      binding: 2,
-      visibility: GPUShaderStage.VERTEX,
-      texture: { sampleType: 'unfilterable-float', viewDimension: '2d' },
-    });
-  }
-  for (const texture of shaders.bindings) {
-    bindGroupEntries.push({
-      binding: texture.texture,
-      visibility: GPUShaderStage.FRAGMENT,
-      texture: { sampleType: 'float', viewDimension: '2d' },
-    });
-    bindGroupEntries.push({
-      binding: texture.sampler,
-      visibility: GPUShaderStage.FRAGMENT,
-      sampler: { type: 'filtering' },
-    });
-  }
-  const bindGroupLayout = backend.renderer.device.createBindGroupLayout({ entries: bindGroupEntries });
-  const pipelineLayout = backend.renderer.device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout, backend.renderer.sunlight.layout] });
-  return {
-    device: backend.renderer.device,
-    vertex,
-    fragment,
-    bindings: shaders.bindings,
-    vertexBuffers,
-    bindGroupLayout,
-    pipelineLayout,
-    pipelineCache: new Map(),
-    cullMode: material.doubleSided ? 'none' : 'back',
-    transparent: material.alphaMode === 'BLEND',
-    depthWrite: material.depthWrite ?? material.alphaMode !== 'BLEND',
-    depthTest: material.depthTest !== false,
-    terrain: material.terrain,
-    nightLight: Boolean(material.nightLight),
-    nightSparkle: !!backend.options.nightSparkle,
-    uniforms: {
-      baseColor: { value: material.color || [1, 1, 1] },
-      metallic: { value: material.metallic ?? 0 },
-      roughness: { value: material.roughness ?? 0.85 },
-      opacity: { value: material.opacity ?? 1 },
-      alphaCutoff: { value: material.alphaCutoff ?? 0.5 },
-      occlusionStrength: { value: material.occlusionStrength ?? 1 },
-      emissive: { value: material.emissive || [0, 0, 0] },
-      ...(material.baseTexture ? { baseTexture: { value: material.baseTexture } } : {}),
-      ...(material.metalTexture ? { metalTexture: { value: material.metalTexture } } : {}),
-      ...(material.emissiveTexture ? { emissiveTexture: { value: material.emissiveTexture } } : {}),
-      ...(material.occlusionTexture ? { occlusionTexture: { value: material.occlusionTexture } } : {}),
-      ...(material.roofTexture ? { roofTexture: { value: null } } : {}),
-    },
-    _layerMaterial: material,
-  };
-}

package/src/utils/decodeDirectory.js

@@ -1,40 +0,0 @@
-/** Decode delta/varint directory columns, rejecting malformed entries. */
-
-export function decodeDirectory(data) {
-  const bytes = new Uint8Array(data);
-  let cursor = 0;
-  const varint = () => {
-    let value = 0;
-    for (let factor = 1; factor <= 2 ** 49; factor *= 128) {
-      if (cursor >= bytes.length) throw new Error('Truncated PMTiles directory');
-      const byte = bytes[cursor++];
-      value += (byte & 127) * factor;
-      if (!Number.isSafeInteger(value)) throw new Error('Invalid PMTiles directory integer');
-      if (byte < 128) return value;
-    }
-    throw new Error('Invalid PMTiles directory integer');
-  };
-  const count = varint();
-  if (count > (bytes.length - cursor) / 4) throw new Error('Invalid PMTiles directory count');
-  const entries = [];
-  let tileId = 0;
-  for (let i = 0; i < count; i++) {
-    tileId += varint();
-    if (!Number.isSafeInteger(tileId) || (i && tileId <= entries[i - 1].tileId)) {
-      throw new Error('Invalid PMTiles directory tile IDs');
-    }
-    entries.push({ tileId });
-  }
-  for (const entry of entries) entry.runLength = varint();
-  for (const entry of entries) {
-    entry.length = varint();
-    if (!entry.length) throw new Error('Invalid PMTiles directory length');
-  }
-  entries.forEach((entry, i) => {
-    const value = varint();
-    if (!value && !i) throw new Error('Invalid PMTiles directory offset');
-    entry.offset = value ? value - 1 : entries[i - 1].offset + entries[i - 1].length;
-  });
-  if (cursor !== bytes.length) throw new Error('Trailing PMTiles directory data');
-  return entries;
-}

package/src/utils/decodeHeader.js

@@ -1,15 +0,0 @@
-/** Decode the PMTiles v3 header. */
-
-export function decodeHeader(data) {
-  if (data.byteLength < 127 || new TextDecoder().decode(new Uint8Array(data, 0, 7)) !== 'PMTiles' ||
-    new Uint8Array(data)[7] !== 3) throw new Error('Expected a PMTiles v3 archive');
-  const view = new DataView(data);
-  const header = {};
-  ['rootDirectoryOffset', 'rootDirectoryLength', 'jsonMetadataOffset', 'jsonMetadataLength', 'leafDirectoryOffset', 'leafDirectoryLength', 'tileDataOffset', 'tileDataLength', 'numAddressedTiles', 'numTileEntries', 'numTileContents'].forEach((name, i) => { header[name] = Number(view.getBigUint64(8 + i * 8, true)); });
-  ['clustered', 'internalCompression', 'tileCompression', 'tileType', 'minZoom', 'maxZoom'].forEach((name, i) => { header[name] = view.getUint8(96 + i); });
-  ['minLon', 'minLat', 'maxLon', 'maxLat'].forEach((name, i) => { header[name] = view.getInt32(102 + i * 4, true) / 1e7; });
-  header.centerZoom = view.getUint8(118);
-  header.centerLon = view.getInt32(119, true) / 1e7;
-  header.centerLat = view.getInt32(123, true) / 1e7;
-  return header;
-}