leaflet-city-mapper 0.0.1 → 0.0.3

package/src/utils/geometry.js

@@ -1,256 +0,0 @@
-/**
- * HSL inputs are linear-space to preserve the original building styling.
- * Numeric/CSS/RGB inputs are already sRGB; CSS alpha is not used for extrusion.
- * @param {number|string|Object} value 0xRRGGBB, CSS color, {r,g,b}, or {h,s,l} in 0..1.
- * @returns {Object} sRGB {r,g,b} components in 0..1.
- */
-export function parseColor(value) {
-  if (value && typeof value === 'object' && 'h' in value) {
-    const { h, s, l } = value;
-    const a = s * Math.min(l, 1 - l);
-    const channel = n => {
-      const k = (n + h * 12) % 12;
-      return l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1));
-    };
-    const toSRGB = value => value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055;
-    return { r: toSRGB(channel(0)), g: toSRGB(channel(8)), b: toSRGB(channel(4)) };
-  }
-  if (value && typeof value === 'object' && 'r' in value) return value;
-  if (typeof value === 'number') return {
-    r: (value >> 16 & 255) / 255, g: (value >> 8 & 255) / 255, b: (value & 255) / 255,
-  };
-  if (typeof value !== 'string' || !CSS.supports('color', value)) throw new Error('Invalid 3D color');
-  const context = document.createElement('canvas').getContext('2d');
-  context.fillStyle = value;
-  context.fillRect(0, 0, 1, 1);
-  const [r, g, b] = context.getImageData(0, 0, 1, 1).data;
-  return { r: r / 255, g: g / 255, b: b / 255 };
-}
-
-/**
- * Paints the vertices `[start, end)` of a mesh and marks its color buffer dirty.
- * @param {Object} mesh Layer-created mesh with a color attribute.
- * @param {number} start Inclusive vertex index, not an offset into the RGB array.
- * @param {number} end Exclusive vertex index.
- * @param {Object} color sRGB {r,g,b}, typically from parseColor().
- */
-export function setVertexColor(mesh, start, end, color) {
-  for (let i = start; i < end; i++) {
-    mesh.geometry.attributes.color.data.set([color.r, color.g, color.b], i * 3);
-  }
-  mesh.geometry.attributes.color.needsUpdate = true;
-}
-
-/**
- * Triangulates a polygon given as `{x, y}` points.
- * Rings omit the repeated closing point; winding is normalized internally.
- * Vertex indices remain relative to the original inputs after duplicate/collinear
- * cleanup. Hole bridges duplicate endpoints, not source vertices.
- * @param {Object[]} contour Outer boundary.
- * @param {Object[][]} [holes] Interior boundaries.
- *
- * @returns {number[][]} Triangles as indices in `[...contour, ...holes.flat()]`.
- */
-export function triangulate(contour, holes = []) {
-  const points = [contour, ...holes].flat();
-  if (points.some(p => !Number.isFinite(p.x) || !Number.isFinite(p.y))) throw new Error('Invalid polygon coordinates');
-  // Translate near the origin to avoid cancellation with geographic coordinates.
-  const vertices = points.map((p, index) => ({ x: p.x - contour[0].x, y: p.y - contour[0].y, index }));
-  const cross = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
-  const equal = (a, b) => a.x === b.x && a.y === b.y;
-  // Remove zero-area corners before connecting holes; keep original vertex indices.
-  const clean = ring => {
-    let changed = true;
-    while (changed && ring.length > 3) {
-      changed = false;
-      for (let i = 0; i < ring.length; i++) {
-        const a = ring[(i + ring.length - 1) % ring.length], b = ring[i], c = ring[(i + 1) % ring.length];
-        if (equal(a, b) || Math.abs(cross(a, b, c)) < 1e-10) {
-          ring.splice(i, 1); changed = true; break;
-        }
-      }
-    }
-    if (ring.length < 3) throw new Error('Degenerate polygon ring');
-    return ring;
-  };
-  let offset = 0;
-  const rings = [contour, ...holes].map((path, index) => {
-    const ring = clean(vertices.slice(offset, offset += path.length));
-    if (isClockWise(ring) !== Boolean(index)) ring.reverse();
-    return ring;
-  });
-  const inside = (point, ring) => {
-    let result = false;
-    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
-      const a = ring[i], b = ring[j];
-      if ((a.y > point.y) !== (b.y > point.y) &&
-        point.x < (b.x - a.x) * (point.y - a.y) / (b.y - a.y) + a.x) result = !result;
-    }
-    return result;
-  };
-  const intersects = (a, b, c, d) => {
-    if (equal(a, c) || equal(a, d) || equal(b, c) || equal(b, d)) return false;
-    const abC = cross(a, b, c), abD = cross(a, b, d), cdA = cross(c, d, a), cdB = cross(c, d, b);
-    const on = (p, q, r) => Math.min(p.x, q.x) <= r.x && r.x <= Math.max(p.x, q.x) &&
-      Math.min(p.y, q.y) <= r.y && r.y <= Math.max(p.y, q.y);
-    return abC * abD < 0 && cdA * cdB < 0 ||
-      abC === 0 && on(a, b, c) || abD === 0 && on(a, b, d) ||
-      cdA === 0 && on(c, d, a) || cdB === 0 && on(c, d, b);
-  };
-  let polygon = rings[0].slice();
-  // A bridge must stay inside the outer boundary, outside every hole, and cross no edge.
-  // ponytail: quadratic ear clipping for building footprints; use spatial indexing for large rings.
-  for (const hole of rings.slice(1).sort((a, b) => Math.min(...a.map(p => p.x)) - Math.min(...b.map(p => p.x)))) {
-    let bridge, distance = Infinity;
-    for (let h = 0; h < hole.length; h++) for (let p = 0; p < polygon.length; p++) {
-      const a = hole[h], b = polygon[p], d = (a.x - b.x) ** 2 + (a.y - b.y) ** 2;
-      if (d >= distance) continue;
-      const mid = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
-      if (!inside(mid, rings[0]) || rings.slice(1).some(r => inside(mid, r))) continue;
-      if ([polygon, ...rings.slice(1)].some(r => r.some((c, i) => intersects(a, b, c, r[(i + 1) % r.length])))) continue;
-      bridge = [h, p]; distance = d;
-    }
-    if (!bridge) throw new Error('Unable to connect polygon hole');
-    const [h, p] = bridge;
-    polygon = [...polygon.slice(0, p + 1), ...hole.slice(h), ...hole.slice(0, h + 1),
-    polygon[p], ...polygon.slice(p + 1)];
-  }
-  // Clip a convex corner only when no other vertex is inside/on its triangle.
-  const result = [];
-  while (polygon.length > 3) {
-    let clipped = false;
-    for (let i = 0; i < polygon.length; i++) {
-      const a = polygon[(i + polygon.length - 1) % polygon.length], b = polygon[i], c = polygon[(i + 1) % polygon.length];
-      if (cross(a, b, c) <= 1e-10) continue;
-      if (polygon.some(p => !equal(p, a) && !equal(p, b) && !equal(p, c) &&
-        cross(a, b, p) >= 0 && cross(b, c, p) >= 0 && cross(c, a, p) >= 0)) continue;
-      result.push([a.index, b.index, c.index]); polygon.splice(i, 1); clipped = true; break;
-    }
-    if (!clipped) throw new Error('Unable to triangulate polygon: invalid or self-intersecting rings');
-  }
-  if (cross(...polygon) > 1e-10) result.push(polygon.map(p => p.index));
-  const area = ring => Math.abs(ring.reduce((sum, p, i) => {
-    const q = ring[(i + 1) % ring.length]; return sum + p.x * q.y - q.x * p.y;
-  }, 0)) / 2;
-  // Reject incomplete coverage instead of silently emitting a partial roof.
-  const expected = area(rings[0]) - rings.slice(1).reduce((sum, ring) => sum + area(ring), 0);
-  const actual = result.reduce((sum, triangle) => sum + cross(...triangle.map(i => vertices[i])) / 2, 0);
-  if (expected <= 0 || Math.abs(actual - expected) > Math.max(1e-7, expected * 1e-8)) throw new Error('Polygon triangulation area mismatch');
-  return result;
-}
-
-/**
- * @returns {boolean} Whether the `{x, y}` points are in clockwise order.
- */
-export function isClockWise(points) {
-  let area = 0;
-  for (let i = 0; i < points.length; i++) {
-    const a = points[i], b = points[(i + 1) % points.length];
-    area += a.x * b.y - b.x * a.y;
-  }
-  return area < 0;
-}
-
-/** Low-poly tree, sharing the source block's buffers, picking and terrain offset. */
-export function treeGeometry(point, style, addTriangle) {
-  const { top, bottom = 0, trunkRadius, crownRadius, crownBottom, crownShape = 'round' } = style;
-  if (![trunkRadius, crownRadius, crownBottom].every(Number.isFinite) ||
-    trunkRadius <= 0 || crownRadius < trunkRadius || crownBottom <= bottom || crownBottom >= top ||
-    !['round', 'cone'].includes(crownShape)) {
-      throw new Error('Invalid tree dimensions or crown shape');
-    }
-  const trunk = parseColor(style.trunkColor ?? 0x72513a);
-  const crown = parseColor(style.color ?? 0x4f823b);
-  const ring = radius => Array.from({ length: 8 }, (_, i) => ({
-    x: point.x + Math.cos(i * Math.PI / 4) * radius,
-    y: point.y + Math.sin(i * Math.PI / 4) * radius,
-    ground: point.ground,
-  }));
-  const surface = (lowRadius, low, highRadius, high, color) => {
-    const lower = ring(lowRadius), upper = ring(highRadius);
-    for (let i = 0; i < 8; i++) {
-      const next = (i + 1) % 8;
-      const angle = (i + 0.5) * Math.PI / 4;
-      const slope = (lowRadius - highRadius) / (high - low);
-      const length = Math.hypot(1, slope);
-      const nx = Math.cos(angle) / length, ny = slope / length, nz = -Math.sin(angle) / length;
-      if (lowRadius) addTriangle(lower[i], low, lower[next], low, upper[next], high, nx, ny, nz, color);
-      if (highRadius) addTriangle(lower[i], low, upper[next], high, upper[i], high, nx, ny, nz, color);
-    }
-  };
-  surface(trunkRadius, bottom, trunkRadius, crownBottom + (top - crownBottom) * 0.25, trunk);
-  if (crownShape === 'cone') {
-    const base = ring(crownRadius);
-    for (let i = 0; i < 8; i++) addTriangle(point, crownBottom, base[i], crownBottom,
-      base[(i + 1) % 8], crownBottom, 0, -1, 0, crown);
-    surface(crownRadius, crownBottom, 0, top, crown);
-  } else {
-    const profile = [[0, 0], [0.35, 0.8], [0.6, 1], [0.85, 0.7], [1, 0]];
-    for (let i = 1; i < profile.length; i++) {
-      const [low, lr] = profile[i - 1], [high, hr] = profile[i];
-      surface(lr * crownRadius, crownBottom + low * (top - crownBottom),
-        hr * crownRadius, crownBottom + high * (top - crownBottom), crown);
-    }
-  }
-}
-
-/** Three crossed emitter discs; illumination itself is evaluated on receiving surfaces. */
-export function lightGeometry(point, style, addTriangle) {
-  if (!Number.isFinite(style.lightRadius) || style.lightRadius <= 0) throw new Error('Invalid light radius');
-  const color = parseColor(style.color);
-  const quad = (a, b, c, d, height, normal) => {
-    addTriangle(a, height, b, height, c, height, ...normal, color);
-    addTriangle(a, height, c, height, d, height, ...normal, color);
-  };
-  const r = 0.65;
-  const emitter = (u, v, axis) => ({
-    x: point.x + (axis === 2 ? 0 : u * r),
-    y: point.y + (axis === 1 ? 0 : axis === 2 ? u * r : v * r),
-    ground: point.ground + (axis === 0 ? 0 : v * r), uv: [u, v],
-  });
-  for (let axis = 0; axis < 3; axis++) {
-    quad(emitter(-1, -1, axis), emitter(1, -1, axis), emitter(1, 1, axis), emitter(-1, 1, axis),
-      style.top, axis === 0 ? [0, 1, 0] : axis === 1 ? [0, 0, 1] : [1, 0, 0]);
-  }
-}
-
-/** Schematic support and lamp head; wall-mounted fixtures do not get an invented pole. */
-export function lampPostGeometry(point, style, addTriangle) {
-  const color = parseColor(0x50565a), radius = style.poleRadius;
-  if (!Number.isFinite(radius) || radius <= 0) throw new Error('Invalid lamp pole radius');
-  const ring = r => Array.from({ length: 6 }, (_, i) => ({
-    x: point.x + Math.cos(i * Math.PI / 3) * r,
-    y: point.y + Math.sin(i * Math.PI / 3) * r, ground: point.ground, uv: [3, 3],
-  }));
-  const center = { ...point, uv: [3, 3] };
-  for (const [r, low, high] of [[radius, 0, style.top], [radius * 2.5, style.top - 0.25, style.top + 0.15]]) {
-    const points = ring(r);
-    for (let i = 0; i < 6; i++) {
-      const a = points[i], b = points[(i + 1) % 6], angle = (i + 0.5) * Math.PI / 3;
-      const nx = Math.cos(angle), nz = -Math.sin(angle);
-      addTriangle(a, low, b, low, b, high, nx, 0, nz, color);
-      addTriangle(a, low, b, high, a, high, nx, 0, nz, color);
-      addTriangle(center, high, a, high, b, high, 0, 1, 0, color);
-      addTriangle(center, low, b, low, a, low, 0, -1, 0, color);
-    }
-  }
-}
-
-/** 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/lighting.js

@@ -1,51 +0,0 @@
-/** Pack world-space point lights into the shader's spatial grid. */
-export function lightGrid(packed, maxBytes) {
-  const count = packed.reduce((sum, values) => sum + values.length / 8, 0), cellSize = 32;
-  let data = new Float32Array(8);
-  if (count) {
-    let minX = Infinity, minZ = Infinity, maxX = -Infinity, maxZ = -Infinity;
-    for (const values of packed) for (let i = 0; i < values.length; i += 8) {
-      minX = Math.min(minX, values[i] - values[i + 3]); maxX = Math.max(maxX, values[i] + values[i + 3]);
-      minZ = Math.min(minZ, values[i + 2] - values[i + 3]); maxZ = Math.max(maxZ, values[i + 2] + values[i + 3]);
-    }
-    const columns = Math.ceil((maxX - minX) / cellSize) + 1, rows = Math.ceil((maxZ - minZ) / cellSize) + 1;
-    const each = callback => {
-      for (const values of packed) for (let i = 0; i < values.length; i += 8) {
-        const radius = values[i + 3], x = values[i] - minX, z = values[i + 2] - minZ;
-        for (let y = Math.floor((z - radius) / cellSize); y <= Math.floor((z + radius) / cellSize); y++) {
-          for (let c = Math.floor((x - radius) / cellSize); c <= Math.floor((x + radius) / cellSize); c++) callback(y * columns + c, values, i);
-        }
-      }
-    };
-    // Counting sort: count the lights of each cell, then fill each cell's slice.
-    const counts = new Uint32Array(columns * rows), next = new Uint32Array(columns * rows);
-    each(key => counts[key]++);
-    const entries = counts.reduce((sum, value) => sum + value, 0);
-    const length = (2 + columns * rows + entries * 2) * 4;
-    if (length * 4 > maxBytes) throw new Error('Streetlight grid exceeds GPU storage limit');
-    data = new Float32Array(length);
-    data.set([minX, minZ, cellSize, columns, rows, count, 0, 0]);
-    let offset = 2 + columns * rows;
-    for (let key = 0; key < counts.length; key++) if (counts[key]) {
-      data[(2 + key) * 4] = next[key] = offset;
-      data[(2 + key) * 4 + 1] = counts[key];
-      offset += counts[key] * 2;
-    }
-    each((key, values, i) => {
-      for (let j = 0, o = next[key] * 4; j < 8; j++) data[o + j] = values[i + j];
-      next[key] += 2;
-    });
-  }
-  return { data, count };
-}
-
-/** World-space [x, y, z, radius, r, g, b, intensity] for one mesh's point lights. */
-export function worldLights(lights, m) {
-  const values = new Float32Array(lights.length * 8);
-  lights.forEach(({ position: [x, y, z], radius, color, flux }, i) => {
-    const w = m[3] * x + m[7] * y + m[11] * z + m[15];
-    values.set([(m[0] * x + m[4] * y + m[8] * z + m[12]) / w, (m[1] * x + m[5] * y + m[9] * z + m[13]) / w,
-      (m[2] * x + m[6] * y + m[10] * z + m[14]) / w, radius, ...color, flux / (4 * Math.PI) * 0.03], i * 8);
-  });
-  return values;
-}

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

@@ -1,119 +0,0 @@
-import { computeBounds } from './geometry.js';
-
-/** Nearest triangle hit per mesh, sorted by world-space distance. */
-export function intersectMeshes(ray, meshes, night = 0) {
-  const hits = [],
-             a = [0, 0, 0],
-             b = [0, 0, 0],
-             c = [0, 0, 0],
-           sub = (a, b) => a.map((v, i) => v - b[i]),
-         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]],
-          dot  = (a, b) => a.reduce((sum, v, i) => sum + v * b[i], 0);
-  for (const mesh of meshes) {
-    // Test in mesh-local space; compare distances only after returning to shared world space.
-    const inverse       = new DOMMatrix(mesh.worldMatrix).inverse();
-    const inverseValues = inverse.toFloat64Array();
-    if (![...inverseValues].every(Number.isFinite)) {
-      throw new Error('Singular 3D transform');
-    }
-    const localOrigin    = new DOMPoint(...ray.origin, 1).matrixTransform(inverse);
-    const origin         = [
-      localOrigin.x / localOrigin.w,
-      localOrigin.y / localOrigin.w,
-      localOrigin.z / localOrigin.w
-    ];
-    const localDirection  = new DOMPoint(...ray.direction, 0).matrixTransform(inverse);
-    const direction       = [
-      localDirection.x,
-      localDirection.y,
-      localDirection.z
-    ];
-    const directionLength = Math.hypot(...direction) || 1;
-    direction[0] /= directionLength; direction[1] /= directionLength; direction[2] /= directionLength;
-    // AABB slab test reuses the same local ray as the triangle test.
-    if (!mesh.geometry.bounds) {
-      computeBounds(mesh.geometry);
-    }
-    let near = 0, far = Infinity;
-    for (let i = 0; i < 3; i++) {
-      if (Math.abs(direction[i]) < 1e-12) {
-        if (origin[i] < mesh.geometry.bounds.min[i] || origin[i] > mesh.geometry.bounds.max[i]) {
-          far = -Infinity;
-          break;
-        }
-      } else {
-        const a = (mesh.geometry.bounds.min[i] - origin[i]) / direction[i],
-              b = (mesh.geometry.bounds.max[i] - origin[i]) / direction[i];
-        near = Math.max(near, Math.min(a, b));
-        far = Math.min(far, Math.max(a, b));
-      }
-    }
-    if (far < near) {
-      continue;
-    }
-    const { position, index } = mesh.geometry.attributes;
-    let closest = Infinity, faceIndex;
-    for (let i = 0; i < (index?.count || position.count); i += 3) {
-      const ai = (index ? index.data[i] : i) * position.size;
-      const bi = (index ? index.data[i + 1] : i + 1) * position.size;
-      const ci = (index ? index.data[i + 2] : i + 2) * position.size;
-      a[0] = position.data[ai];
-      a[1] = position.data[ai + 1];
-      a[2] = position.data[ai + 2];
-      b[0] = position.data[bi];
-      b[1] = position.data[bi + 1];
-      b[2] = position.data[bi + 2];
-      c[0] = position.data[ci];
-      c[1] = position.data[ci + 1];
-      c[2] = position.data[ci + 2];
-      // Moller-Trumbore: barycentric triangle coordinates and local ray distance.
-      const e = sub(b, a),
-            f = sub(c, a),
-            p = cross(direction, f),
-            det = dot(e, p);
-      if (mesh.program.cullFace !== null ? det < 1e-9 : Math.abs(det) < 1e-9) {
-        continue;
-      }
-      const t = sub(origin, a),
-            u = dot(t, p) / det;
-      if (u < 0 || u > 1) {
-        continue;
-      }
-      const q = cross(t, e),
-            v = dot(direction, q) / det;
-      if (v < 0 || u + v > 1) {
-        continue;
-      }
-      if (mesh.program.nightLight) {
-        const uv = mesh.geometry.attributes.uv.data;
-        const ids = index ? [index.data[i], index.data[i + 1], index.data[i + 2]] : [i, i + 1, i + 2];
-        const x = uv[ids[0] * 2] * (1 - u - v) + uv[ids[1] * 2] * u + uv[ids[2] * 2] * v;
-        const y = uv[ids[0] * 2 + 1] * (1 - u - v) + uv[ids[1] * 2 + 1] * u + uv[ids[2] * 2 + 1] * v;
-        if (x <= 2 && (!night || x * x + y * y > 0.9)) continue;
-      }
-      const distance = dot(f, q) / det;
-      if (distance > 0 && distance < closest) {
-        closest = distance; faceIndex = i / 3;
-      }
-    }
-    if (faceIndex === undefined) continue;
-    const point = new DOMPoint(
-      direction[0] * closest + origin[0],
-      direction[1] * closest + origin[1],
-      direction[2] * closest + origin[2],
-      1
-    ).matrixTransform(new DOMMatrix(mesh.worldMatrix));
-    const worldPoint = [point.x / point.w, point.y / point.w, point.z / point.w];
-    hits.push({
-      faceIndex,
-      object:     mesh,
-      point:      worldPoint,
-      distance:   Math.hypot(
-        worldPoint[0] - ray.origin[0],
-        worldPoint[1] - ray.origin[1],
-        worldPoint[2] - ray.origin[2]
-      )
-    });
-  }
-  return hits.sort((a, b) => a.distance - b.distance);
-}

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;
-}