leaflet-city-mapper 0.0.3 → 0.0.4

package/src/models/readAccessorValues.js

@@ -1,16 +1,20 @@
+import { readAccessorValue } from './readAccessorValue.js';
+
 export function readAccessorValues(description, Type, size, data, accessorCount, indices, viewIndex, offset, count, stride) {
   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');
-  let i, values, output;
+    (count - 1) * stride + size * bytes + offset > view.byteLength) throw /* alloc */ new Error('glTF accessor outside buffer view');
+  const input = /* alloc */ new DataView(buffer);
+  let i, j, at, output;
   for (i = 0; i < count; i++) {
-    values = new Type(buffer.slice((view.byteOffset || 0) + offset + i * stride,
-      (view.byteOffset || 0) + offset + i * stride + size * bytes));
     output = indices ? indices[i] : i;
-    if (indices && output >= accessorCount) throw new Error('Invalid sparse glTF index');
-    data.set(values, output * size);
+    if (indices && output >= accessorCount) throw /* alloc */ new Error('Invalid sparse glTF index');
+    for (j = 0; j < size; j++) {
+      at = (view.byteOffset || 0) + offset + i * stride + j * bytes;
+      data[output * size + j] = readAccessorValue(input, Type, at);
+    }
   }
 }

package/src/models/readModelAttributes.js

@@ -0,0 +1,20 @@
+import { geometrySemantics } from '../globals/geometrySemantics.js';
+import { readAccessor } from './readAccessor.js';
+
+export function readModelAttributes(description, primitive) {
+  const attributes = /* alloc */ {};
+  let semantic, name;
+  for ([semantic, name] of geometrySemantics) {
+    if (primitive.attributes[semantic] !== undefined) {
+      attributes[name] = readAccessor(description, primitive.attributes[semantic]);
+    }
+  }
+  if (!attributes.position) throw /* alloc */ new Error('glTF mesh has no positions');
+  const vertexCount = attributes.position.data.length / 3;
+  if (attributes.position.size !== 3 || vertexCount < 3) throw /* alloc */ new Error('Invalid glTF vertex attributes');
+  let attribute;
+  for (attribute of Object.values(attributes)) {
+    if (attribute.data.length / attribute.size !== vertexCount) throw /* alloc */ new Error('Invalid glTF vertex attributes');
+  }
+  return /* alloc */ { attributes, vertexCount };
+}

package/src/models/readModelIndices.js

@@ -0,0 +1,16 @@
+import { readAccessor } from './readAccessor.js';
+
+export function readModelIndices(description, primitive, attributes, vertexCount) {
+  if (primitive.indices !== undefined) {
+    const index = readAccessor(description, primitive.indices);
+    attributes.index = /* alloc */ { size: 1, data: index.indices };
+    if (!(index.indices instanceof Uint8Array || index.indices instanceof Uint16Array ||
+      index.indices instanceof Uint32Array) || index.size !== 1 || index.indices.length % 3) {
+      throw /* alloc */ new Error('Invalid glTF triangle indices');
+    }
+    let value;
+    for (value of index.indices) if (value >= vertexCount) throw /* alloc */ new Error('Invalid glTF triangle indices');
+  } else if (vertexCount % 3) {
+    throw /* alloc */ new Error('Incomplete glTF triangle');
+  }
+}

package/src/models/readSparseAccessor.js

@@ -0,0 +1,19 @@
+import { types } from '../globals/types.js';
+import { readAccessorValues } from './readAccessorValues.js';
+
+export function readSparseAccessor(description, spec, Type, size, data) {
+  const sparse = spec.sparse, Index = types[sparse.indices.componentType];
+  if (Index !== Uint8Array && Index !== Uint16Array && Index !== Uint32Array) {
+    throw /* alloc */ 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 /* alloc */ new Error('Invalid sparse glTF indices');
+  }
+  const indices = /* alloc */ new Index(description.buffers[view.buffer].binary.slice(
+    offset, offset + sparse.count * Index.BYTES_PER_ELEMENT));
+  readAccessorValues(description, Type, size, data, spec.count, indices, sparse.values.bufferView,
+    sparse.values.byteOffset || 0, sparse.count, 0);
+}

package/src/models/releaseModelResources.js

@@ -0,0 +1,10 @@
+export function releaseModelResources(context) {
+  let resource, attribute;
+  for (resource of context.resources) {
+    if (resource.attributes) {
+      for (attribute of Object.values(resource.attributes)) attribute.buffer.destroy();
+    } else {
+      resource.pipelineCache.clear();
+    }
+  }
+}

package/src/models/textureFor.js

@@ -1,24 +1,27 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { textureSampler } from './textureSampler.js';
 
 export function textureFor(context, reference, color = false) {
   const { backend, description, images, textures } = context;
   if (!reference) return null;
   if ((reference.texCoord || 0) !== 0 || reference.extensions) {
-    throw new Error('Model textures currently require untransformed TEXCOORD_0 UVs');
+    throw /* alloc */ new Error('Model textures currently require untransformed TEXCOORD_0 UVs');
   }
-  const device = backend.renderer.device;
+  const device = sceneByLayer.get(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 sampler = description.samplers?.[texture.sampler];
     const image = images[texture.source];
     const format = color ? 'rgba8unorm-srgb' : 'rgba8unorm';
     const samplerOptions = textureSampler(sampler);
-    textures.set(key, {
+    textures.set(key, /* alloc */ {
       device,
-      texture: device.createTexture({
-        size: [image.width, image.height],
+      texture: device.createTexture(/* alloc */ {
+        size: /* alloc */ [image.width, image.height],
         format,
         usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
       }),

package/src/models/textureSampler.js

@@ -1,10 +1,10 @@
 /** 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',
+  return /* alloc */ {
+    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/picking/findFeature.js

@@ -1,3 +1,6 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { raycast } from './raycast.js';
 
 /**
@@ -7,20 +10,20 @@ import { raycast } from './raycast.js';
  */
 
 export function findFeature(backend, event) {
-  if (!backend.root || !backend.camera) {
+  if (!sceneByLayer.get(backend).root || !sceneByLayer.get(backend).camera) {
     return null;
   }
   let hit, object, ranges, low, high, middle, range;
-  for (hit of raycast(backend, event, backend.root.children, Boolean(backend.model))) {
-    if (backend.model) {
+  for (hit of raycast(backend, event, sceneByLayer.get(backend).root.children, Boolean(sceneByLayer.get(backend).model))) {
+    if (sceneByLayer.get(backend).model) {
       object = hit.object;
-      while (object && object !== backend.model) {
+      while (object && object !== sceneByLayer.get(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
+      if (object === sceneByLayer.get(backend).model) {
+        return /* alloc */ {
+          id: sceneByLayer.get(backend).model.id, properties: sceneByLayer.get(backend).model.extras,
+          model: sceneByLayer.get(backend).model, mesh: hit.object, point: hit.point
         };
       }
     }
@@ -37,7 +40,7 @@ export function findFeature(backend, event) {
       } else if (hit.faceIndex >= range.faceEnd) {
         low = middle + 1;
       } else {
-        return {
+        return /* alloc */ {
           ...range,
           mesh: hit.object,
           point: hit.point

package/src/picking/hit.js

@@ -1,7 +1,7 @@
-import { CELL } from '../constants/CELL.js';
-import { collider } from '../collision/collider.js';
-import { computeBounds } from '../geometry/computeBounds.js';
-import { horizontalRay } from '../collision/horizontalRay.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+
 import { traverse } from '../scene/traverse.js';
 import { updateWorldMatrix } from '../scene/updateWorldMatrix.js';
 import { shouldSkipOther } from './shouldSkipOther.js';
@@ -11,13 +11,14 @@ import { hitMesh } from './hitMesh.js';
 // the unit (dx, dz); knee and chest rays, so arches and tree crowns above the head let the walker through.
 // ponytail: traffic vehicles and boats move on the GPU and are not obstacles.
 
-export function hit(layer, x, y, z, dx, dz, reach) {
-  updateWorldMatrix(layer.scene);
-  const data = { x, y, z, dx, dz, reach, best: reach, found: null };
+export function hit(layer, x, y, z, dx, dz, reach, data) {
+  updateWorldMatrix(sceneByLayer.get(layer).scene);
+  data.x = x, data.y = y, data.z = z, data.dx = dx, data.dz = dz, data.reach = reach;
+  data.best = reach, data.found = false;
   let other;
-  for (other of layer._shared._layers) {
+  for (other of sceneByLayer.get(sceneByLayer.get(layer)._shared)._layers) {
     if (shouldSkipOther(other, layer)) continue;
-    traverse(other.root, hitMesh, data);
+    traverse(sceneByLayer.get(other).root, hitMesh, data);
   }
-  return data.found;
+  return data.found ? data.normal : null;
 }

package/src/picking/hitColliderCell.js

@@ -0,0 +1,19 @@
+import { horizontalRay } from '../collision/horizontalRay.js';
+
+export function hitColliderCell(cell, c, data, ox, oy, oz) {
+  const { dx, dz, seen } = data;
+  let t, height, d;
+  for (t of cell) {
+    if (seen.has(t) || dx * c.nrm[t * 2] + dz * c.nrm[t * 2 + 1] >= 0) continue;
+    seen.add(t);
+    for (height = 0.4; height < 2; height += 1.1) {
+      d = horizontalRay(c.tri, t, ox, oy + height, oz, dx, dz);
+      if (d >= 0 && d < data.best) {
+        data.best = d;
+        data.found = true;
+        data.normal[0] = c.nrm[t * 2];
+        data.normal[1] = c.nrm[t * 2 + 1];
+      }
+    }
+  }
+}

package/src/picking/hitMesh.js

@@ -1,7 +1,9 @@
+import { CELL } from '../globals/CELL.js';
+
 import { computeBounds } from '../geometry/computeBounds.js';
 import { collider } from '../collision/collider.js';
-import { CELL } from '../constants/CELL.js';
-import { horizontalRay } from '../collision/horizontalRay.js';
+
+import { hitColliderCell } from './hitColliderCell.js';
 
 export function hitMesh(mesh, data) {
   if (!mesh.visible) return true;
@@ -12,19 +14,13 @@ export function hitMesh(mesh, data) {
   if (Math.hypot(m[0] * k[0] + m[4] * k[1] + m[8] * k[2] + m[12] - x, m[2] * k[0] + m[6] * k[1] + m[10] * k[2] + m[14] - z) >
     radius * Math.hypot(m[0], m[1], m[2]) + reach) return;
   const c = collider(mesh), ox = x - m[12] + c.origin[0], oy = y - m[13] + c.origin[1], oz = z - m[14] + c.origin[2];
-  const seen = new Set();
-  let ix, iz, t, height, d;
+  const seen = data.seen;
+  seen.clear();
+  let ix, iz, cell;
   for (ix = Math.floor(Math.min(ox, ox + dx * reach) / CELL); ix <= Math.floor(Math.max(ox, ox + dx * reach) / CELL); ix++)
-    for (iz = Math.floor(Math.min(oz, oz + dz * reach) / CELL); iz <= Math.floor(Math.max(oz, oz + dz * reach) / CELL); iz++)
-      for (t of c.cells.get(ix + ',' + iz) || []) {
-        if (seen.has(t) || dx * c.nrm[t * 2] + dz * c.nrm[t * 2 + 1] >= 0) continue;
-        seen.add(t);
-        for (height of [0.4, 1.5]) {
-          d = horizontalRay(c.tri, t, ox, oy + height, oz, dx, dz);
-          if (d >= 0 && d < data.best) {
-            data.best = d;
-            data.found = [c.nrm[t * 2], c.nrm[t * 2 + 1]];
-          }
-        }
-      }
+    for (iz = Math.floor(Math.min(oz, oz + dz * reach) / CELL); iz <= Math.floor(Math.max(oz, oz + dz * reach) / CELL); iz++) {
+      cell = c.cells.get(ix + ',' + iz);
+      if (!cell) continue;
+      hitColliderCell(cell, c, data, ox, oy, oz);
+    }
 }

package/src/picking/onClick.js

@@ -1,3 +1,6 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { findFeature } from './findFeature.js';
 import { setHighlight } from './setHighlight.js';
 import { showFeature } from './showFeature.js';
@@ -6,8 +9,8 @@ import { showFeature } from './showFeature.js';
 
 export function onClick(layer, event) {
   const feature = findFeature(layer, event);
-  layer.hoveredFeature = feature;
+  sceneByLayer.get(layer).hoveredFeature = feature;
   setHighlight(layer, feature);
   showFeature(layer, feature, event);
-  layer.fire('featureclick', { feature, originalEvent: event });
+  layer.fire('featureclick', /* alloc */ { feature, originalEvent: event });
 }

package/src/picking/onPointerLeave.js

@@ -1,11 +1,14 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { setHighlight } from './setHighlight.js';
 import { showFeature } from './showFeature.js';
 
 /** Clear hover, highlight and tooltip without retaining a selected feature. */
 
 export function onPointerLeave(layer) {
-  layer.hoveredFeature = null;
+  sceneByLayer.get(layer).hoveredFeature = null;
   setHighlight(layer, null);
   showFeature(layer, null);
-  layer.fire('featurehover', { feature: null });
+  layer.fire('featurehover', /* alloc */ { feature: null });
 }

package/src/picking/onPointerMove.js

@@ -1,3 +1,6 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { findFeature } from './findFeature.js';
 import { setHighlight } from './setHighlight.js';
 import { showFeature } from './showFeature.js';
@@ -5,11 +8,11 @@ import { showFeature } from './showFeature.js';
 /** Hover is transient; featurehover also reports misses with feature:null. */
 
 export function onPointerMove(layer, event) {
-  layer.hoveredFeature = findFeature(layer, event);
-  setHighlight(layer, layer.hoveredFeature);
-  showFeature(layer, layer.hoveredFeature, event);
-  layer.fire('featurehover', {
-    feature: layer.hoveredFeature,
+  sceneByLayer.get(layer).hoveredFeature = findFeature(layer, event);
+  setHighlight(layer, sceneByLayer.get(layer).hoveredFeature);
+  showFeature(layer, sceneByLayer.get(layer).hoveredFeature, event);
+  layer.fire('featurehover', /* alloc */ {
+    feature: sceneByLayer.get(layer).hoveredFeature,
     originalEvent: event
   });
 }

package/src/picking/raycast.js

@@ -1,8 +1,14 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { trafficByLayer } from '../globals/trafficByLayer.js';
+
+
 import { intersectMeshes } from '../collision/intersectMeshes.js';
 import { traverse } from '../scene/traverse.js';
 import { updateCamera } from '../scene/updateCamera.js';
 import { updateWorldMatrix } from '../scene/updateWorldMatrix.js';
 import { collectVisibleMesh } from './collectVisibleMesh.js';
+import { placeTraffic } from '../traffic/placeTraffic.js';
+import { validateCameraInverse } from './validateCameraInverse.js';
 
 /** Raycasting, hover/click highlight and tooltips. */
 /**
@@ -14,46 +20,47 @@ import { collectVisibleMesh } from './collectVisibleMesh.js';
  * @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 [];
+export function raycast(backend, event, objects = sceneByLayer.get(backend).root.children, recursive = true) {
+  if (!sceneByLayer.get(backend).renderer) {
+    return /* alloc */ [];
   }
-  backend._beforeRaycast?.();
+  const traffic = trafficByLayer.get(backend);
+  if (traffic) placeTraffic(traffic);
   const rect = backend._map.getContainer().getBoundingClientRect();
-  updateWorldMatrix(backend.scene);
-  updateCamera(backend.camera);
+  updateWorldMatrix(sceneByLayer.get(backend).scene);
+  updateCamera(sceneByLayer.get(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();
-  let value, object;
-  for (value of inverseCameraValues) {
-    if (!Number.isFinite(value)) 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 = [];
+  const inverseCamera = sceneByLayer.get(backend).raycaster.inverse;
+  const matrix = sceneByLayer.get(backend).camera.projectionViewMatrix;
+  inverseCamera.m11 = matrix[0], inverseCamera.m12 = matrix[1], inverseCamera.m13 = matrix[2], inverseCamera.m14 = matrix[3];
+  inverseCamera.m21 = matrix[4], inverseCamera.m22 = matrix[5], inverseCamera.m23 = matrix[6], inverseCamera.m24 = matrix[7];
+  inverseCamera.m31 = matrix[8], inverseCamera.m32 = matrix[9], inverseCamera.m33 = matrix[10], inverseCamera.m34 = matrix[11];
+  inverseCamera.m41 = matrix[12], inverseCamera.m42 = matrix[13], inverseCamera.m43 = matrix[14], inverseCamera.m44 = matrix[15];
+  inverseCamera.invertSelf();
+  const x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
+  const y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+  const endX = inverseCamera.m11 * x + inverseCamera.m21 * y + inverseCamera.m41;
+  const endY = inverseCamera.m12 * x + inverseCamera.m22 * y + inverseCamera.m42;
+  const endZ = inverseCamera.m13 * x + inverseCamera.m23 * y + inverseCamera.m43;
+  const endW = inverseCamera.m14 * x + inverseCamera.m24 * y + inverseCamera.m44;
+  let object;
+  validateCameraInverse(inverseCamera);
+  sceneByLayer.get(backend).raycaster.origin[0] = sceneByLayer.get(backend).camera.position[0];
+  sceneByLayer.get(backend).raycaster.origin[1] = sceneByLayer.get(backend).camera.position[1];
+  sceneByLayer.get(backend).raycaster.origin[2] = sceneByLayer.get(backend).camera.position[2];
+  sceneByLayer.get(backend).raycaster.direction[0] = endX / endW - sceneByLayer.get(backend).raycaster.origin[0];
+  sceneByLayer.get(backend).raycaster.direction[1] = endY / endW - sceneByLayer.get(backend).raycaster.origin[1];
+  sceneByLayer.get(backend).raycaster.direction[2] = endZ / endW - sceneByLayer.get(backend).raycaster.origin[2];
+  const direction = sceneByLayer.get(backend).raycaster.direction;
+  const rayLength = Math.hypot(direction[0], direction[1], direction[2]) || 1;
+  sceneByLayer.get(backend).raycaster.direction[0] /= rayLength;
+  sceneByLayer.get(backend).raycaster.direction[1] /= rayLength;
+  sceneByLayer.get(backend).raycaster.direction[2] /= rayLength;
+  const meshes = sceneByLayer.get(backend).raycaster.meshes;
+  meshes.length = 0;
   for (object of objects) {
     if (recursive) traverse(object, collectVisibleMesh, meshes);
     else if (object.geometry && object.visible && object._appearance !== 0) meshes.push(object);
   }
-  return intersectMeshes(backend.raycaster, meshes, backend.renderer.uniformData?.[55]);
+  return intersectMeshes(sceneByLayer.get(backend).raycaster, meshes, sceneByLayer.get(backend).renderer.uniformData?.[55]);
 }

package/src/picking/setHighlight.js

@@ -1,13 +1,20 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { update } from '../scene/update.js';
 
 /** 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];
+  if (sceneByLayer.get(backend).highlightedFeature?.mesh === feature?.mesh &&
+    sceneByLayer.get(backend).highlightedFeature?.vertexStart === feature?.vertexStart) return;
+  if (sceneByLayer.get(backend).highlightedFeature) sceneByLayer.get(backend).highlightedFeature.mesh.highlight = null;
+  sceneByLayer.get(backend).highlightedFeature = feature;
+  if (feature) {
+    feature.mesh.highlightRange[0] = feature.vertexStart;
+    feature.mesh.highlightRange[1] = feature.vertexEnd;
+    feature.mesh.highlight = feature.mesh.highlightRange;
+  }
   update(backend);
 }

package/src/picking/shouldSkipOther.js

@@ -1,3 +1,6 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 export function shouldSkipOther(other, layer) {
-  return other === layer || other._type === 'terrain' || other._type === 'traffic';
+  return other === layer || sceneByLayer.get(other)._type === 'terrain' || sceneByLayer.get(other)._type === 'traffic';
 }

package/src/picking/showFeature.js

@@ -1,34 +1,37 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 /** Update tooltip content/position and arbitrate cursor ownership across shared layers. */
 
 export function showFeature(backend, feature, event) {
-  const tooltip = backend._tooltip;
+  const tooltip = sceneByLayer.get(backend)._tooltip;
   if (!tooltip) return;
   if (feature) {
     tooltip.replaceChildren(backend.options.tooltip(feature));
     tooltip.hidden = false;
-    const rect = backend.container.getBoundingClientRect();
+    const rect = sceneByLayer.get(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;
+  const shared = sceneByLayer.get(backend)._shared;
   let layer;
   if (shared) {
     let visible = false;
-    for (layer of shared._layers) {
-      if (layer._tooltip && !layer._tooltip.hidden) {
+    for (layer of sceneByLayer.get(shared)._layers) {
+      if (sceneByLayer.get(layer)._tooltip && !sceneByLayer.get(layer)._tooltip.hidden) {
         visible = true;
         break;
       }
     }
     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;
+      if (sceneByLayer.get(shared)._cursor === undefined) sceneByLayer.get(shared)._cursor = sceneByLayer.get(backend).container.style.cursor;
+      sceneByLayer.get(backend).container.style.cursor = 'pointer';
+    } else if (sceneByLayer.get(shared)._cursor !== undefined) {
+      sceneByLayer.get(backend).container.style.cursor = sceneByLayer.get(shared)._cursor;
+      delete sceneByLayer.get(shared)._cursor;
     }
   }
 }

package/src/picking/validateCameraInverse.js

@@ -0,0 +1,8 @@
+export function validateCameraInverse(matrix) {
+  let column, row;
+  for (column = 1; column <= 4; column++) {
+    for (row = 1; row <= 4; row++) {
+      if (!Number.isFinite(matrix[`m${column}${row}`])) throw /* alloc */ new Error('Singular 3D transform');
+    }
+  }
+}