leaflet-city-mapper 0.0.1 → 0.0.3

package/src/scene/model.js

@@ -1,204 +0,0 @@
-import { decodeModel, readAccessor, nodeMatrix, vertexNormals, textureSampler } from '../utils/model.js';
-import { emptyNode, setParent } from '../utils/scene.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' });
-  }));
-  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:         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 = backend._createProgram(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,
-            id: L.Layer.types['3d']._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 backend._removeProgram(resource);
-      }
-      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);
-}

package/src/scene/picking.js

@@ -1,150 +0,0 @@
-import { intersectMeshes } from '../utils/picking.js';
-import { traverse, updateWorldMatrix, updateCamera } from '../utils/scene.js';
-
-/** Raycasting, hover/click highlight and tooltips. */
-/**
- * Finds the objects under a mouse or pointer event, nearest first.
- *
- * @param {MouseEvent} event
- * @param {Object[]} [objects] Defaults to this layer's root children, not all map layers.
- * @param {boolean} [recursive] Also test the descendants of `objects`.
- * @returns {Object[]} Nearest hit per mesh: object, shared-world point/distance and triangle faceIndex.
- */
-export function raycast(backend, event, objects = backend.root.children, recursive = true) {
-  if (!backend.renderer) {
-    return [];
-  }
-  const rect = backend._map.getContainer().getBoundingClientRect();
-  updateWorldMatrix(backend.scene);
-  updateCamera(backend.camera);
-  // Unproject the mouse (-1..1) into a world-space ray from the camera.
-  const inverseCamera       = new DOMMatrix(backend.camera.projectionViewMatrix).inverse();
-  const inverseCameraValues = inverseCamera.toFloat64Array();
-  if (![...inverseCameraValues].every(Number.isFinite)) {
-    throw new Error('Singular 3D transform');
-  }
-  backend.raycaster.origin[0] = backend.camera.position[0];
-  backend.raycaster.origin[1] = backend.camera.position[1];
-  backend.raycaster.origin[2] = backend.camera.position[2];
-  const unprojected = new DOMPoint(
-    ((event.clientX - rect.left) / rect.width) * 2 - 1,
-    -((event.clientY - rect.top) / rect.height) * 2 + 1,
-    0,
-    1
-  ).matrixTransform(inverseCamera);
-  const end = [
-    unprojected.x / unprojected.w,
-    unprojected.y / unprojected.w,
-    unprojected.z / unprojected.w
-  ];
-  backend.raycaster.direction[0] = end[0] - backend.raycaster.origin[0];
-  backend.raycaster.direction[1] = end[1] - backend.raycaster.origin[1];
-  backend.raycaster.direction[2] = end[2] - backend.raycaster.origin[2];
-  const rayLength = Math.hypot(...backend.raycaster.direction) || 1;
-  backend.raycaster.direction[0] /= rayLength;
-  backend.raycaster.direction[1] /= rayLength;
-  backend.raycaster.direction[2] /= rayLength;
-  const meshes = [];
-  for (const object of objects) {
-    if (recursive) traverse(object, mesh => { if
-      (mesh.geometry && mesh.visible) meshes.push(mesh);
-    });
-    else if (object.geometry && object.visible) meshes.push(object);
-  }
-  return intersectMeshes(backend.raycaster, meshes, backend.renderer.uniformData?.[55]);
-}
-
-/**
- * Translate a geometry hit into a configured model or batched source feature.
- * Sorted half-open face ranges permit binary search without a feature per triangle.
- * @returns {PickedFeature|null}
- */
-export function findFeature(backend, event) {
-  if (!backend.root || !backend.camera) return null;
-  for (const hit of backend.raycast(event, backend.root.children, Boolean(backend.model))) {
-    if (backend.model) {
-      let object = hit.object;
-      while (object && object !== backend.model) object = object.parent;
-      if (object === backend.model) {
-        return {
-          id: backend.model.id, properties: backend.model.extras,
-          model: backend.model, mesh: hit.object, point: hit.point
-        };
-      }
-    }
-    const ranges = hit.object.extras?.featureFaces;
-    if (!ranges) continue;
-    let low = 0, high = ranges.length - 1;
-    while (low <= high) {
-      const middle = (low + high) >> 1;
-      const range = ranges[middle];
-      if (hit.faceIndex < range.faceStart) high = middle - 1;
-      else if (hit.faceIndex >= range.faceEnd) low = middle + 1;
-      else return { ...range, mesh: hit.object, point: hit.point };
-    }
-  }
-  return null;
-}
-
-/** Highlight a source vertex range in the shader; vertex colors stay untouched. */
-export function setHighlight(backend, feature) {
-  if (feature?.model) feature = null;
-  if (backend.highlightedFeature?.mesh === feature?.mesh &&
-    backend.highlightedFeature?.vertexStart === feature?.vertexStart) return;
-  if (backend.highlightedFeature) backend.highlightedFeature.mesh.highlight = null;
-  backend.highlightedFeature = feature;
-  if (feature) feature.mesh.highlight = [feature.vertexStart, feature.vertexEnd];
-  backend.update();
-}
-
-/** Update tooltip content/position and arbitrate cursor ownership across shared layers. */
-export function showFeature(backend, feature, event) {
-  const tooltip = backend._tooltip;
-  if (!tooltip) return;
-  if (feature) {
-    tooltip.replaceChildren(backend.options.tooltipContent(feature));
-    tooltip.hidden = false;
-    const rect = backend.container.getBoundingClientRect();
-    const x = event.clientX - rect.left, y = event.clientY - rect.top;
-    tooltip.style.left = `${x + tooltip.offsetWidth + 16 > rect.width ? x - tooltip.offsetWidth - 12 : x + 12}px`;
-    tooltip.style.top = `${y + tooltip.offsetHeight + 16 > rect.height ? y - tooltip.offsetHeight - 12 : y + 12}px`;
-  } else {
-    tooltip.hidden = true;
-  }
-  const shared = backend._shared;
-  if (shared) {
-    const visible = [...shared._layers].some(layer => layer._tooltip && !layer._tooltip.hidden);
-    if (visible) {
-      if (shared._cursor === undefined) shared._cursor = backend.container.style.cursor;
-      backend.container.style.cursor = 'pointer';
-    } else if (shared._cursor !== undefined) {
-      backend.container.style.cursor = shared._cursor;
-      delete shared._cursor;
-    }
-  }
-}
-
-/** Hover is transient; featurehover also reports misses with feature:null. */
-export function onPointerMove(backend, event) {
-  backend.hoveredFeature = backend._findFeature(event);
-  backend._setHighlight(backend.hoveredFeature);
-  backend._showFeature(backend.hoveredFeature, event);
-  backend.fire('featurehover', { feature: backend.hoveredFeature, originalEvent: event });
-}
-
-/** Emit click without moving the map or pinning the tooltip. */
-export function onClick(backend, event) {
-  const feature = backend._findFeature(event);
-  backend.hoveredFeature = feature;
-  backend._setHighlight(feature);
-  backend._showFeature(feature, event);
-  backend.fire('featureclick', { feature, originalEvent: event });
-}
-
-/** Clear hover, highlight and tooltip without retaining a selected feature. */
-export function onPointerLeave(backend) {
-  backend.hoveredFeature = null;
-  backend._setHighlight(null);
-  backend._showFeature(null);
-  backend.fire('featurehover', { feature: null });
-}

package/src/scene/pmtiles.js

@@ -1,94 +0,0 @@
-import { decodeHeader, decodeDirectory, decompress, tileId } from '../utils/pmtiles.js';
-
-/**
- * PMTiles v3 range reader.
- * Supports uncompressed/gzip sections. Other compression methods fail explicitly.
- * Specification: https://github.com/protomaps/PMTiles/blob/main/spec/v3/spec.md
- */
-/** Read exactly one archive range; reject changed archives rather than mix revisions. */
-export async function read(backend, offset, length, signal) {
-  signal?.throwIfAborted();
-  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) ||
-    offset < 0 || length <= 0 || !Number.isSafeInteger(offset + length)) {
-    throw new Error('Invalid PMTiles byte range');
-  }
-  const response = await fetch(backend.url, {
-    headers: { Range: `bytes=${offset}-${offset + length - 1}` }, signal,
-  });
-  if (!response.ok) throw new Error(`Unable to read PMTiles: HTTP ${response.status}`);
-  const etag = response.headers.get('ETag');
-  if (backend._etag && etag !== backend._etag) {
-    throw new Error('PMTiles archive changed; recreate the layer');
-  }
-  if (etag) {
-    backend._etag = etag;
-  }
-  let data = await response.arrayBuffer();
-  if (response.status === 200) {
-    data = data.slice(offset, offset + length);
-  } else if (response.status !== 206 || !response.headers.get('Content-Range')?.startsWith(`bytes ${offset}-${offset + length - 1}/`)) {
-    throw new Error('Invalid PMTiles range response');
-  }
-  if (data.byteLength !== length) {
-    throw new Error('Truncated PMTiles range');
-  }
-  return data;
-}
-
-/** Cache header initialization; failures remain visible to all callers. */
-export function getHeader(backend) {
-  return backend._header ||= backend._read(0, 127).then(decodeHeader);
-}
-
-/** Nearest directory entry at/before the Hilbert ID, then follow leaf pointers. */
-export async function getZxy(backend, z, x, y, signal) {
-  const id = tileId(z, x, y);
-  signal?.throwIfAborted();
-  const header = await backend.getHeader();
-  signal?.throwIfAborted();
-  if (z < header.minZoom || z > header.maxZoom) return;
-  let offset = header.rootDirectoryOffset, length = header.rootDirectoryLength;
-  const visited = new Set();
-  for (let depth = 0; depth < 4; depth++) {
-    if (visited.has(offset)) {
-      throw new Error('Cyclic PMTiles directory');
-    }
-    visited.add(offset);
-    const key = `${offset}:${length}`;
-    if (!backend._directories.has(key)) {
-      if (backend._directories.size >= 32) {
-        backend._directories.delete(backend._directories.keys().next().value);
-      }
-      const pending = backend._read(offset, length)
-        .then(data => decompress(data, header.internalCompression))
-        .then(decodeDirectory)
-        .catch(error => {
-          if (backend._directories.get(key) === pending) backend._directories.delete(key);
-          throw error;
-        });
-      backend._directories.set(key, pending);
-    }
-    const entries = await backend._directories.get(key);
-    signal?.throwIfAborted();
-    let low = 0,
-       high = entries.length - 1;
-    while (low <= high) {
-      const mid = (low + high) >> 1;
-      if (entries[mid].tileId <= id) low = mid + 1;
-      else high = mid - 1;
-    }
-    const entry = entries[high];
-    if (!entry) return;
-    if (entry.runLength) {
-      if (id - entry.tileId >= entry.runLength) return;
-      if (entry.offset + entry.length > header.tileDataLength) throw new Error('PMTiles tile outside data section');
-      const data = await decompress(await backend._read(header.tileDataOffset + entry.offset, entry.length, signal), header.tileCompression);
-      signal?.throwIfAborted();
-      return { data };
-    }
-    if (entry.offset + entry.length > header.leafDirectoryLength) throw new Error('PMTiles directory outside leaf section');
-    offset = header.leafDirectoryOffset + entry.offset;
-    length = entry.length;
-  }
-  throw new Error('PMTiles directory depth exceeds four levels');
-}