leaflet-city-mapper 0.0.2 → 0.0.3

package/src/utils/intersectMeshes.js

@@ -1,121 +0,0 @@
-import { computeBounds } from "./computeBounds.js";
-
-const sub = (a, b) => a.map((v, i) => v - b[i]);
-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]];
-const dot = (a, b) => a.reduce((sum, v, i) => sum + v * b[i], 0);
-
-/** 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];
-  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.cullMode === 'none' || mesh.program.cullFace === null
-        ? Math.abs(det) < 1e-9 : 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/isClockWise.js

@@ -1,12 +0,0 @@
-/**
- * @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;
-}

package/src/utils/lampPostGeometry.js

@@ -1,26 +0,0 @@
-import { parseColor } from "./parseColor.js";
-
-/** 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);
-    }
-  }
-}

package/src/utils/lightGeometry.js

@@ -1,22 +0,0 @@
-import { parseColor } from "./parseColor.js";
-
-/** 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]);
-  }
-}

package/src/utils/lightGrid.js

@@ -1,50 +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 };
-}

package/src/utils/loadModel.js

@@ -1,217 +0,0 @@
-import { decodeModel } from './decodeModel.js';
-import { emptyNode } from './emptyNode.js';
-import { nodeMatrix } from './nodeMatrix.js';
-import { readAccessor } from './readAccessor.js';
-import { setParent } from './setParent.js';
-import { textureSampler } from './textureSampler.js';
-import { vertexNormals } from './vertexNormals.js';
-import { createProgram } from './createProgram.js';
-import { conformModelToTerrain } from './conformModelToTerrain.js';
-
-/** glTF/GLB model loading. */
-/** Load the configured GLB/glTF (static triangles) under `root`; GPU resources need attachment. */
-
-export async function loadModel(backend) {
-  await backend._added.promise;
-  const url = new URL(backend.modelUrl, document.baseURI).href;
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Unable to load model: HTTP ${response.status}`);
-  }
-  const data = await response.arrayBuffer();
-  const description = decodeModel(data);
-  const directory = new URL('.', url).href;
-  await Promise.all((description.buffers || []).map(async (buffer) => {
-    if (buffer.binary) {
-      return;
-    }
-    const response = await fetch(new URL(buffer.uri, directory).href);
-    if (!response.ok) {
-      throw new Error(`Unable to load model buffer: HTTP ${response.status}`);
-    }
-    buffer.binary = await response.arrayBuffer();
-  }));
-  await backend._added.promise;
-  const images = await Promise.all((description.images || []).map(async (image) => {
-    let blob;
-    if (image.bufferView !== undefined) {
-      const view = description.bufferViews[image.bufferView];
-      const buffer = description.buffers[view.buffer].binary;
-      blob = new Blob([buffer.slice(view.byteOffset || 0, (view.byteOffset || 0) + view.byteLength)],
-        { type: image.mimeType });
-    } else {
-      const response = await fetch(new URL(image.uri, directory).href);
-      if (!response.ok) throw new Error(`Unable to load model texture: HTTP ${response.status}`);
-      blob = await response.blob();
-    }
-    // Preserve straight alpha and raw samples; GPU sRGB formats do color decoding.
-    return createImageBitmap(blob, { premultiplyAlpha: 'none', colorSpaceConversion: 'none' });
-  }));
-  await backend._map?._terrain3D?._terrainPromise;
-  const textures = new Map();
-  const textureFor = (reference, color = false) => {
-    if (!reference) return null;
-    if ((reference.texCoord || 0) !== 0 || reference.extensions) {
-      throw new Error('Model textures currently require untransformed TEXCOORD_0 UVs');
-    }
-    const device = backend.renderer.device;
-    // A glTF image may serve both color and data maps: those cannot share a GPU format.
-    const key = `${reference.index}:${color}`;
-    if (!textures.has(key)) {
-      const texture = description.textures[reference.index];
-      const sampler = description.samplers?.[texture.sampler] || {};
-      const image = images[texture.source];
-      const format = color ? 'rgba8unorm-srgb' : 'rgba8unorm';
-      const samplerOptions = textureSampler(sampler);
-      textures.set(key, {
-        device,
-        texture: device.createTexture({
-          size: [image.width, image.height],
-          format,
-          usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-        }),
-        sampler: device.createSampler(samplerOptions),
-        samplerOptions,
-        format,
-        srgb: color,
-        image,
-        flipY: false,
-        uploaded: null,
-      });
-    }
-    return textures.get(key);
-  };
-  // Convert glTF materials directly to the shader's retained CPU styles.
-  const materials = (description.materials || []).map(material => {
-    const pbr = material.pbrMetallicRoughness || {};
-    return {
-      color: (pbr.baseColorFactor || [1, 1, 1, 1]).slice(0, 3),
-      opacity: pbr.baseColorFactor?.[3] ?? 1,
-      metallic: pbr.metallicFactor ?? 1,
-      roughness: pbr.roughnessFactor ?? 1,
-      baseTexture: textureFor(pbr.baseColorTexture, true),
-      metalTexture: textureFor(pbr.metallicRoughnessTexture),
-      emissiveTexture: textureFor(material.emissiveTexture, true),
-      occlusionTexture: textureFor(material.occlusionTexture),
-      emissive: material.emissiveFactor || [0, 0, 0],
-      occlusionStrength: material.occlusionTexture?.strength ?? 1,
-      alphaMode: backend.options.alphaMode || material.alphaMode || 'OPAQUE',
-      alphaCutoff: material.alphaCutoff ?? 0.5,
-      doubleSided: material.doubleSided,
-    };
-  });
-  let nodes;
-  {
-    // Track only the recursion path: shared mesh references are valid, cycles are not.
-    const active = new Set(), resources = [];
-    const node = index => {
-      if (active.has(index)) throw new Error('Cyclic glTF nodes');
-      const spec = description.nodes[index];
-      if (!spec) throw new Error('Invalid glTF node');
-      active.add(index);
-      const group = {
-        ...emptyNode(),
-        name: spec.name
-      };
-      group.matrix = nodeMatrix(spec);
-      if (spec.mesh !== undefined) {
-        for (const primitive of description.meshes[spec.mesh].primitives) {
-          const attributes = {};
-          for (const [semantic, name] of [['POSITION', 'position'], ['NORMAL', 'normal'], ['TEXCOORD_0', 'uv']]) {
-            if (primitive.attributes[semantic] !== undefined) attributes[name] = readAccessor(description, primitive.attributes[semantic]);
-          }
-          if (!attributes.position) throw new Error('glTF mesh has no positions');
-          const vertexCount = attributes.position.data.length / 3;
-          if (attributes.position.size !== 3 || vertexCount < 3 ||
-            Object.values(attributes).some(attribute => attribute.data.length / attribute.size !== vertexCount)) throw new Error('Invalid glTF vertex attributes');
-          if (primitive.indices !== undefined) {
-            const index = readAccessor(description, primitive.indices);
-            attributes.index = { size: 1, data: index.indices };
-            if (![Uint8Array, Uint16Array, Uint32Array].some(Type => index.indices instanceof Type) ||
-              index.size !== 1 || index.indices.length % 3 || [...index.indices].some(i => i >= vertexCount)) throw new Error('Invalid glTF triangle indices');
-          }
-          if (!attributes.index && vertexCount % 3) throw new Error('Incomplete glTF triangle');
-          if (!attributes.normal) {
-            const normals = vertexNormals(attributes.position.data, attributes.index?.data);
-            attributes.normal = { size: 3, data: normals };
-          }
-          const style = materials[primitive.material] || { color: [1, 1, 1], metallic: 1 };
-          if ([style.baseTexture, style.metalTexture, style.emissiveTexture, style.occlusionTexture].some(Boolean) && !attributes.uv) {
-            throw new Error('Textured model mesh requires UV coordinates');
-          }
-          const program = createProgram(backend, style);
-          resources.push(program);
-          const device = backend.renderer.device;
-          if (attributes.index?.data instanceof Uint8Array) {
-            attributes.index.data = Uint16Array.from(attributes.index.data);
-          }
-          for (const [name, attribute] of Object.entries(attributes)) {
-            attribute.size ||= 1;
-            attribute.count = attribute.data.length / attribute.size;
-            attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
-            attribute.buffer = device.createBuffer({
-              size: Math.max(4, attribute.data.byteLength),
-              usage: name === 'index'
-                ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
-                : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-            });
-            device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-          }
-          const geometry = {
-            device,
-            attributes,
-            drawRange: { start: 0, count: attributes.index?.count || attributes.position.count },
-          };
-          resources.push(geometry);
-          const mesh = {
-            ...emptyNode(),
-            device,
-            geometry,
-            program,
-            fadeDuration: 250,
-            id: L.Layer._nextId++,
-            renderOrder: 0
-          };
-          mesh.name = description.meshes[spec.mesh].name; mesh.extras = spec.extras || {};
-          setParent(mesh, group);
-        }
-      }
-      for (const child of spec.children || []) setParent(node(child), group);
-      active.delete(index);
-      return group;
-    };
-    const scene = description.scenes?.[description.scene || 0];
-    if (!scene) throw new Error('Missing glTF scene');
-    try {
-      nodes = scene.nodes.map(node);
-    } catch (error) {
-      // Parsing can fail after earlier primitives allocated buffers/programs.
-      for (const resource of resources) {
-        if (resource.attributes) {
-          for (const attribute of Object.values(resource.attributes)) attribute.buffer.destroy();
-        } else {
-          resource.pipelineCache.clear();
-        }
-      }
-      throw error;
-    }
-  }
-  const model = {
-    ...emptyNode(),
-    id: url,
-    extras: description.extras || {},
-  };
-  if (!nodes.length) throw new Error('Expected a glTF model with a non-empty scene');
-  for (const node of nodes) setParent(node, model);
-  backend.model = model;
-  if (backend.options.rotation) {
-    const [x, y = x, z = x] = backend.options.rotation;
-    backend.model.rotation[0] = x; backend.model.rotation[1] = y; backend.model.rotation[2] = z;
-  }
-  if (backend.options.scale) {
-    const [x, y = x, z = x] = backend.options.scale;
-    backend.model.scale[0] = x; backend.model.scale[1] = y; backend.model.scale[2] = z;
-  }
-  setParent(backend.model, backend.root);
-  conformModelToTerrain(backend, backend._map?._terrain3D);
-}

package/src/utils/loadTerrain.js

@@ -1,65 +0,0 @@
-import { addBridges } from './addBridges.js';
-import { conformModelToTerrain } from './conformModelToTerrain.js';
-import { getElevation } from './getElevation.js';
-import { setTerrainHeight } from './setTerrainHeight.js';
-import { update } from './update.js';
-
-
-export async function loadTerrain(backend) {
-  if (backend._terrainLoading || !backend._map) return;
-  backend._terrainLoading = true;
-  backend._terrainReady = false;
-  const controller = backend._terrainController = new AbortController();
-  try {
-    if (!backend.terrainSource) throw new Error('Terrain layer requires a PMTiles elevation archive');
-    const archive = backend._terrainArchive = new L.Layer({ source: { type: 'pmtiles', url: backend.terrainSource } });
-    await archive.ready;
-    const header = archive.header;
-    if (header.tileType !== 0 || header.minZoom !== header.maxZoom) {
-      throw new Error('Expected a single-zoom Float32 PMTiles terrain archive');
-    }
-    backend._terrainZoom = header.maxZoom;
-    const map = backend._map;
-    const northwest = map.project([header.maxLat, header.minLon], backend._terrainZoom).divideBy(256).floor();
-    const southeast = map.project([header.minLat, header.maxLon], backend._terrainZoom).divideBy(256).floor();
-    backend._terrainBounds = new L.Bounds(northwest, southeast);
-    const tiles = [];
-    for (let x = northwest.x; x <= southeast.x; x++) {
-      for (let y = northwest.y; y <= southeast.y; y++) tiles.push({ z: backend._terrainZoom, x, y });
-    }
-    const center = map.project(map.getCenter(), backend._terrainZoom).divideBy(256);
-    tiles.sort((a, b) => Math.hypot(a.x + 0.5 - center.x, a.y + 0.5 - center.y) -
-      Math.hypot(b.x + 0.5 - center.x, b.y + 0.5 - center.y));
-    let next = 0;
-    await Promise.all(Array.from({ length: Math.min(4, tiles.length) }, async () => {
-      while (next < tiles.length) {
-        controller.signal.throwIfAborted();
-        const coords = tiles[next++];
-        const result = await archive.getZxy(coords.z, coords.x, coords.y, controller.signal);
-        if (!result || result.data.byteLength !== 256 * 256 * 4) {
-          throw new Error(`Missing or invalid Float32 terrain tile ${coords.z}/${coords.x}/${coords.y}`);
-        }
-        backend._terrainTiles.set(`${coords.x}/${coords.y}`, new Float32Array(result.data));
-      }
-    }));
-    const bridges = backend.options.bridges && await fetch(backend.options.bridges, { signal: controller.signal })
-      .then(response => { if (!response.ok) throw new Error(`Bridges: HTTP ${response.status}`); return response.json(); });
-    if (controller.signal.aborted || backend._map !== map) return;
-    backend._terrainReady = true;
-    backend._terrainOriginElevation = getElevation(backend, backend.location) ?? 0;
-    for (const layer of Object.values(map._layers)) {
-      setTerrainHeight(layer);
-      conformModelToTerrain(layer, backend);
-    }
-    if (bridges) addBridges(backend, bridges);
-    map.fire('terrainchange');
-    update(backend);
-    backend.fire('terrainready');
-    return true;
-  } catch (error) {
-    if (!controller.signal.aborted) backend.fire('error', { error });
-    return false;
-  } finally {
-    backend._terrainLoading = false;
-  }
-}