leaflet-city-mapper 0.0.1 → 0.0.2

package/src/utils/model.js

@@ -1,178 +0,0 @@
-const types = {
-  5120: Int8Array,
-  5121: Uint8Array,
-  5122: Int16Array,
-  5123: Uint16Array,
-  5125: Uint32Array,
-  5126: Float32Array,
-};
-const sizes = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4 };
-
-/** Decode a static glTF JSON document or GLB v2 container. */
-export function decodeModel(data) {
-  const view = new DataView(data),
-     decoder = new TextDecoder();
-  let description;
-  if (view.getUint32(0, true) === 0x46546c67) {
-    // Decode GLB v2 chunks; unknown types are skipped.
-    if (view.getUint32(4, true) !== 2 || view.getUint32(8, true) !== data.byteLength) {
-      throw new Error('Invalid GLB header');
-    }
-    let binary;
-    for (let offset = 12; offset < data.byteLength;) {
-      if (offset + 8 > data.byteLength) {
-        throw new Error('Truncated GLB chunk');
-      }
-      const length = view.getUint32(offset, true), type = view.getUint32(offset + 4, true);
-      offset += 8;
-      if (offset + length > data.byteLength) {
-        throw new Error('Truncated GLB data');
-      }
-      const chunk = data.slice(offset, offset + length);
-      if (type === 0x4e4f534a) {
-        description = JSON.parse(decoder.decode(chunk));
-      }
-      if (type === 0x004e4942) {
-        binary = chunk;
-      }
-      offset += length;
-    }
-    if (!description) {
-      throw new Error('Missing GLB JSON');
-    }
-    if (binary) {
-      description.buffers[0].binary = binary;
-    }
-  } else {
-    description = JSON.parse(decoder.decode(data));
-  }
-  if (description.skins?.length || description.animations?.length || description.extensionsRequired?.length || description.meshes?.some(mesh => mesh.primitives.some(primitive => primitive.targets || (primitive.mode !== undefined && primitive.mode !== 4)))) {
-    throw new Error('Layer3D supports static triangle glTF models without required extensions');
-  }
-  return description;
-}
-
-/** 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 };
-}
-
-/** glTF quaternion/translation/scale to a column-major matrix. */
-export function nodeMatrix(spec) {
-  if (spec.matrix) return Array.from(spec.matrix);
-  // glTF stores quaternions [x,y,z,w]; convert directly to a scaled column-major matrix.
-  const [x, y, z, w] = spec.rotation || [0, 0, 0, 1],
-        [sx, sy, sz] = spec.scale    || [1, 1, 1];
-  return [
-    (1 - 2 * (y * y + z * z)) * sx,
-    2 * (x * y + z * w) * sx,
-    2 * (x * z - y * w) * sx,
-    0,
-    2 * (x * y - z * w) * sy,
-    (1 - 2 * (x * x + z * z)) * sy,
-    2 * (y * z + x * w) * sy, 0,
-    2 * (x * z + y * w) * sz,
-    2 * (y * z - x * w) * sz,
-    (1 - 2 * (x * x + y * y)) * sz,
-    0,
-    ...(spec.translation || [0, 0, 0]),
-    1,
-  ];
-}
-
-/** Area-weighted vertex normals, for indexed or non-indexed triangles. */
-export function vertexNormals(p, indices) {
-  // Accumulate area-weighted face normals for shared vertices, then normalize.
-  const normals = new Float32Array(p.length);
-  for (let i = 0; i < (indices?.length || p.length / 3); i += 3) {
-    const a = indices ? indices[i] : i,
-          b = indices ? indices[i + 1] : i + 1,
-          c = indices ? indices[i + 2] : i + 2;
-    const u = [0, 1, 2].map(j => p[b * 3 + j] - p[a * 3 + j]), v = [0, 1, 2].map(j => p[c * 3 + j] - p[a * 3 + j]);
-    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]];
-    for (const index of [a, b, c]) {
-      for (let j = 0; j < 3; j++) {
-        normals[index * 3 + j] += n[j];
-      }
-    }
-  }
-  for (let i = 0; i < normals.length; i += 3) {
-    const length = Math.hypot(...normals.subarray(i, i + 3)) || 1;
-    for (let j = 0; j < 3; j++) {
-      normals[i + j] /= length;
-    }
-  }
-  return normals;
-}
-
-/** Translate glTF sampler constants into WebGPU sampler options. */
-export function textureSampler(sampler) {
-  return {
-    addressModeU: sampler.wrapS === 33071 ? 'clamp-to-edge' : sampler.wrapS === 33648 ? 'mirror-repeat' : 'repeat',
-    addressModeV: sampler.wrapT === 33071 ? 'clamp-to-edge' : sampler.wrapT === 33648 ? 'mirror-repeat' : 'repeat',
-    magFilter: sampler.magFilter === 9728 ? 'nearest' : 'linear',
-    minFilter: sampler.minFilter === 9728 || sampler.minFilter === 9984 || sampler.minFilter === 9986 ? 'nearest' : 'linear',
-  };
-}

package/src/utils/pmtiles.js

@@ -1,79 +0,0 @@
-export async function decompress(data, compression) {
-  if (compression === 1) return data;
-  if (compression !== 2) throw new Error(`Unsupported PMTiles compression: ${compression}`);
-  return new Response(new Blob([data]).stream().pipeThrough(new DecompressionStream('gzip'))).arrayBuffer();
-}
-
-/** 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;
-}
-
-/** Cumulative Hilbert ID for an archive tile. */
-export function tileId(z, x, y) {
-  if (![z, x, y].every(Number.isInteger) || z < 0 || z > 26 ||
-    x < 0 || y < 0 || x >= 2 ** z || y >= 2 ** z) throw new Error('Invalid PMTiles tile coordinates');
-  let id = (4 ** z - 1) / 3;
-  const n = 2 ** z;
-  // Same cumulative Hilbert ordering used by build/pmtiles.js.
-  for (let s = n / 2; s >= 1; s /= 2) {
-    const rx = (x & s) ? 1 : 0,
-          ry = (y & s) ? 1 : 0;
-    id += s * s * ((3 * rx) ^ ry);
-    if (!ry) {
-      if (rx) { x = n - 1 - x; y = n - 1 - y; }
-      [x, y] = [y, x];
-    }
-  }
-  return id;
-}
-
-/** 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/scene.js

@@ -1,102 +0,0 @@
-/** A fresh, empty scene-graph node. */
-export const emptyNode = () => ({
-  position: [0, 0, 0],
-  rotation: [0, 0, 0],
-  scale: [1, 1, 1],
-  worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-  children: [],
-  visible: true,
-});
-
-/** Reparent/detach scene data without drawing or disposing GPU resources. */
-export function setParent(node, parent) {
-  if (node.parent) node.parent.children.splice(node.parent.children.indexOf(node), 1);
-  node.parent = parent;
-  if (parent) parent.children.push(node);
-}
-
-/** Depth-first walk; a truthy callback result skips that node's descendants. */
-export function traverse(node, callback) {
-  if (callback(node)) return;
-  for (const child of node.children) traverse(child, callback);
-}
-
-/** Compose parent*local matrices; a node.matrix overrides its position/rotation/scale. */
-export function updateWorldMatrix(node) {
-  const parent = node.parent;
-  const parentVersion = parent?._worldMatrixVersion || 0;
-  const matrixMode = Boolean(node.matrix);
-  let changed = node._worldParent !== parent || node._parentWorldVersion !== parentVersion ||
-    node._worldMatrixMode !== matrixMode;
-  if (node.matrix) {
-    const state = node._matrixState ||= new Float64Array(16);
-    for (let i = 0; i < 16; i++) {
-      if (state[i] !== node.matrix[i]) changed = true;
-      state[i] = node.matrix[i];
-    }
-  } else {
-    const state = node._transformState ||= new Float64Array(9);
-    for (let i = 0; i < 9; i++) {
-      const value = i < 3 ? node.position[i] : i < 6 ? node.rotation[i - 3] : node.scale[i - 6];
-      if (state[i] !== value) changed = true;
-      state[i] = value;
-    }
-  }
-  if (!changed) {
-    for (const child of node.children) updateWorldMatrix(child);
-    return;
-  }
-  let local;
-  if (node.matrix) local = node.matrix;
-  else {
-    const degrees = 180 / Math.PI;
-    const matrix = new DOMMatrix().translate(...node.position);
-    // Node rotations use YXZ, as did the previous renderer.
-    matrix.rotateAxisAngleSelf(0, 1, 0, node.rotation[1] * degrees);
-    matrix.rotateAxisAngleSelf(1, 0, 0, node.rotation[0] * degrees);
-    matrix.rotateAxisAngleSelf(0, 0, 1, node.rotation[2] * degrees);
-    local = matrix.scale(...node.scale).toFloat64Array();
-  }
-  const world = parent
-    ? new DOMMatrix(parent.worldMatrix).multiply(new DOMMatrix(local)).toFloat64Array()
-    : local;
-  for (let i = 0; i < 16; i++) node.worldMatrix[i] = world[i];
-  node._worldParent = parent;
-  node._parentWorldVersion = parentVersion;
-  node._worldMatrixMode = matrixMode;
-  node._worldMatrixVersion = (node._worldMatrixVersion || 0) + 1;
-  for (const child of node.children) updateWorldMatrix(child);
-}
-
-/** Orthonormal view basis plus perspective matrices, refreshed before projecting/drawing. */
-export function updateCamera(camera) {
-  const z       = camera.position.map((v, i) => v - camera.target[i]);
-  const zLength = Math.hypot(...z) || 1;
-  const cross   = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
-  for (let i = 0; i < 3; i++) {
-    z[i] /= zLength;
-  }
-  const x = cross(camera.up, z), xLength = Math.hypot(...x) || 1;
-  for (let i = 0; i < 3; i++) {
-    x[i] /= xLength;
-  }
-  const y = cross(z, x);
-  const view = new DOMMatrix([x[0], x[1], x[2], 0, y[0], y[1], y[2], 0, z[0], z[1], z[2], 0, ...camera.position, 1]).inverse().toFloat64Array();
-  if (![...view].every(Number.isFinite)) {
-    throw new Error('Singular 3D transform');
-  }
-  for (let i = 0; i < 16; i++) {
-    camera.viewMatrix[i] = view[i];
-  }
-  const f = 1 / Math.tan(camera.fov * Math.PI / 360),
-        n = camera.near,
-        r = camera.far;
-  const projection = [f / camera.aspect, 0, 0, 0, 0, f, 0, 0, 0, 0, r / (n - r), -1, 0, 0, r * n / (n - r), 0];
-  for (let i = 0; i < 16; i++) {
-    camera.projectionMatrix[i] = projection[i];
-  }
-  const projectionView = new DOMMatrix(camera.projectionMatrix).multiply(new DOMMatrix(camera.viewMatrix)).toFloat64Array();
-  for (let i = 0; i < 16; i++) {
-    camera.projectionViewMatrix[i] = projectionView[i];
-  }
-}

package/src/utils/sun.js

@@ -1,71 +0,0 @@
-// Solar centre, without atmospheric refraction.
-export function solarPosition(date, lat, lng) {
-  const time = new Date(date).getTime();
-  if (!Number.isFinite(time) || !Number.isFinite(lat) || Math.abs(lat) > 90 ||
-    !Number.isFinite(lng) || Math.abs(lng) > 180) throw new Error('Invalid solar date or location');
-  const rad = Math.PI / 180, d = time / 86400000 - 10957.5;
-  const mean = (357.5291 + 0.98560028 * d) * rad;
-  const longitude = mean + (1.9148 * Math.sin(mean) + 0.02 * Math.sin(2 * mean) +
-    0.0003 * Math.sin(3 * mean) + 102.9372 + 180) * rad;
-  const obliquity = 23.4397 * rad;
-  const declination = Math.asin(Math.sin(longitude) * Math.sin(obliquity));
-  const ascension = Math.atan2(Math.sin(longitude) * Math.cos(obliquity), Math.cos(longitude));
-  return horizontalPosition(d, lat, lng, ascension, declination);
-}
-
-function horizontalPosition(d, lat, lng, ascension, declination) {
-  const rad = Math.PI / 180;
-  const hourAngle = (280.16 + 360.9856235 * d + lng) * rad - ascension;
-  const latitude = lat * rad;
-  const altitude = Math.asin(Math.sin(latitude) * Math.sin(declination) +
-    Math.cos(latitude) * Math.cos(declination) * Math.cos(hourAngle));
-  const southAzimuth = Math.atan2(Math.sin(hourAngle),
-    Math.cos(hourAngle) * Math.sin(latitude) - Math.tan(declination) * Math.cos(latitude));
-  const azimuth = (southAzimuth / rad + 180 + 360) % 360;
-  return { altitude: altitude / rad, azimuth,
-    direction: [Math.sin(azimuth * rad) * Math.cos(altitude), Math.sin(altitude),
-      -Math.cos(azimuth * rad) * Math.cos(altitude)] };
-}
-
-// Low-precision geocentric lunar orbit; no parallax or atmospheric refraction.
-export function moonPosition(date, lat, lng) {
-  solarPosition(date, lat, lng);
-  const rad = Math.PI / 180, d = new Date(date).getTime() / 86400000 - 10957.5;
-  const anomaly = (134.963 + 13.064993 * d) * rad;
-  const longitude = (218.316 + 13.176396 * d + 6.289 * Math.sin(anomaly)) * rad;
-  const latitude = 5.128 * Math.sin((93.272 + 13.229350 * d) * rad) * rad;
-  const obliquity = 23.4397 * rad;
-  const x = Math.cos(latitude) * Math.cos(longitude);
-  const y = Math.cos(latitude) * Math.sin(longitude) * Math.cos(obliquity) - Math.sin(latitude) * Math.sin(obliquity);
-  const z = Math.cos(latitude) * Math.sin(longitude) * Math.sin(obliquity) + Math.sin(latitude) * Math.cos(obliquity);
-  return horizontalPosition(d, lat, lng, Math.atan2(y, x), Math.asin(z));
-}
-
-export function atmosphere(altitude) {
-  if (!Number.isFinite(altitude)) throw new Error('Invalid solar altitude');
-  const stops = [
-    [-18, [3, 7, 20], [17, 28, 54], [0.025, 0.04, 0.09]],
-    [-6, [37, 53, 84], [182, 106, 86], [0.12, 0.10, 0.14]],
-    [0, [101, 131, 171], [246, 170, 115], [0.38, 0.24, 0.18]],
-    [10, [74, 147, 208], [197, 221, 237], [0.80, 0.75, 0.68]],
-    [25, [53, 144, 213], [223, 238, 250], [1, 1, 1]],
-  ];
-  const upper = stops.findIndex(stop => stop[0] >= altitude);
-  const b = stops[upper < 0 ? stops.length - 1 : upper], a = stops[Math.max(0, upper - 1)];
-  const t = a === b || upper < 0 ? 1 : (altitude - a[0]) / (b[0] - a[0]);
-  const mix = index => a[index].map((value, i) => value + (b[index][i] - value) * t);
-  const rgb = values => `rgb(${values.map(Math.round).join(', ')})`;
-  return { background: `linear-gradient(${rgb(mix(1))}, ${rgb(mix(2))})`, tint: mix(3) };
-}
-
-/** Perspective projection of a celestial direction; null when behind the camera. */
-export function projectCelestialBody(direction, size, pitch, bearing) {
-  const [x, y, z] = direction;
-  const right = x * Math.cos(bearing) - z * Math.sin(bearing);
-  const up = -x * Math.sin(bearing) * Math.cos(pitch) + y * Math.sin(pitch) - z * Math.cos(bearing) * Math.cos(pitch);
-  const forward = -x * Math.sin(bearing) * Math.sin(pitch) - y * Math.cos(pitch) - z * Math.cos(bearing) * Math.sin(pitch);
-  if (forward <= 0) return null;
-  const left = size.x / 2 + size.y * 1.5 * right / forward;
-  const top = size.y / 2 - size.y * 1.5 * up / forward;
-  return { left, top };
-}

package/src/utils/terrain.js

@@ -1,78 +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;
-}
-
-/** Bilinear DEM sampling, with the original first-valid-neighbour no-data rule. */
-export function terrainElevation(point, tiles) {
-  const x = point.x - 0.5, y = point.y - 0.5;
-  const x0 = Math.floor(x), y0 = Math.floor(y);
-  const fx = x - x0, fy = y - y0;
-  const sample = (px, py) => {
-    const tileX = Math.floor(px / 256), tileY = Math.floor(py / 256);
-    const tile = tiles.get(`${tileX}/${tileY}`);
-    if (!tile) return null;
-    const elevation = tile[(py - tileY * 256) * 256 + px - tileX * 256];
-    return Number.isFinite(elevation) && elevation > -1000 ? elevation : null;
-  };
-  const values = [sample(x0, y0), sample(x0 + 1, y0), sample(x0, y0 + 1), sample(x0 + 1, y0 + 1)];
-  const valid = values.map((value, i) => Number.isFinite(value) ? i : -1).filter(i => i >= 0);
-  if (!valid.length) return null;
-  if (valid.length < 4) return values[valid[0]];
-  return (values[0] * (1 - fx) + values[1] * fx) * (1 - fy) +
-    (values[2] * (1 - fx) + values[3] * fx) * fy;
-}
-
-/** Unit tile grid; the vertex shader supplies the elevation. */
-export function terrainGrid(divisions) {
-  const positions = [], normals = [], uvs = [], indices = [];
-  for (let row = 0; row <= divisions; row++) {
-    for (let column = 0; column <= divisions; column++) {
-      positions.push(column / divisions, 0, row / divisions);
-      normals.push(0, 1, 0);
-      uvs.push(column / divisions, row / divisions);
-      if (row < divisions && column < divisions) {
-        const a = row * (divisions + 1) + column;
-        const b = a + 1, c = a + divisions + 1, d = c + 1;
-        indices.push(a, c, b, b, c, d);
-      }
-    }
-  }
-  return {
-    position: { size: 3, data: new Float32Array(positions) },
-    normal:   { size: 3, data: new Float32Array(normals) },
-    uv:       { size: 2, data: new Float32Array(uvs) },
-    index:    { data: new Uint16Array(indices) },
-  };
-}
-
-/** Float32 DEM atlas; missing samples retain the shader no-data sentinel. */
-export function terrainAtlas(tiles, bounds) {
-  const columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
-  const elevations = new Float32Array(columns * rows * 65536).fill(-1e9);
-  let low = Infinity, high = -Infinity;
-  for (const [key, values] of tiles) {
-    const [x, y] = key.split('/').map(Number);
-    const start = (y - bounds.min.y) * 256 * columns * 256 + (x - bounds.min.x) * 256;
-    for (let row = 0; row < 256; row++) {
-      for (let column = 0; column < 256; column++) {
-        const value = values[row * 256 + column];
-        if (!Number.isFinite(value) || value <= -1000) continue;
-        elevations[start + row * columns * 256 + column] = value;
-        low = Math.min(low, value);
-        high = Math.max(high, value);
-      }
-    }
-  }
-  return { elevations, low, high };
-}