leaflet-city-mapper 0.1.0 → 0.1.1

package/src/collision/insideWalker.js

@@ -1,52 +1,52 @@
-import { kindByLayer } from '../weakmaps/kindByLayer.js';
-import { layersByLayer } from '../weakmaps/layersByLayer.js';
-import { rootByLayer } from '../weakmaps/rootByLayer.js';
-import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
-import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
-import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
-import { insideMesh } from './insideMesh.js';
-import { trafficCollision } from './trafficCollision.js';
-import { local } from '../projections/walkerLocalPosition.js';
-
-/**
- * Check the walker's body heights against scene geometry and current traffic bounds, excluding terrain.
- *
- * @param {Object} context Walk control state and reusable collision scratch.
- *
- * @returns {boolean} Whether the walker overlaps traffic or is enclosed by a mesh.
- */
-export function insideWalker(context) {
-  const { layer, local: localBuffer, hitData } = context;
-  const shared = sharedByLayer.get(layer);
-  if (!shared || !layersByLayer.get(shared)) return false;
-  updateWorldMatrix(sceneByLayer.get(layer));
-  const root = rootByLayer.get(layer);
-  const feet = local.call(context, localBuffer);
-  const x = root.position[0] + feet[0] * root.scale[0];
-  const y = root.position[1] + feet[1] * root.scale[1];
-  const z = root.position[2] + feet[2] * root.scale[2];
-  const layers = layersByLayer.get(shared);
-  let other, node, child, nodes;
-  for (other of layers) {
-    if (other === layer || kindByLayer.get(other) === 'terrain') continue;
-    if (kindByLayer.get(other) === 'traffic') {
-      hitData.best = 0;
-      hitData.found = false;
-      if (trafficCollision(other, x, y, z, 0, 0, 0, hitData)) return true;
-      continue;
-    }
-    nodes = hitData.nodes;
-    nodes.length = 0;
-    if (rootByLayer.get(other)) nodes.push(rootByLayer.get(other));
-    while (nodes.length) {
-      node = nodes.pop();
-      if (!node.visible) continue;
-      if (node.geometry && (
-        insideMesh(node, x, y + 0.45 * root.scale[1], z, hitData.seen, hitData.intersections) ||
-        insideMesh(node, x, y + 1.35 * root.scale[1], z, hitData.seen, hitData.intersections)
-      )) return true;
-      for (child of node.children) nodes.push(child);
-    }
-  }
-  return false;
-}
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
+import { insideMesh } from './insideMesh.js';
+import { trafficCollision } from './trafficCollision.js';
+import { local } from '../projections/walkerLocalPosition.js';
+
+/**
+ * Check the walker's body heights against scene geometry and current traffic bounds, excluding terrain.
+ *
+ * @param {Object} context Walk control state and reusable collision scratch.
+ *
+ * @returns {boolean} Whether the walker overlaps traffic or is enclosed by a mesh.
+ */
+export function insideWalker(context) {
+  const { layer, local: localBuffer, hitData } = context;
+  const shared = sharedByLayer.get(layer);
+  if (!shared || !layersByLayer.get(shared)) return false;
+  updateWorldMatrix(sceneByLayer.get(layer));
+  const root = rootByLayer.get(layer);
+  const feet = local.call(context, localBuffer);
+  const x = root.position[0] + feet[0] * root.scale[0];
+  const y = root.position[1] + feet[1] * root.scale[1];
+  const z = root.position[2] + feet[2] * root.scale[2];
+  const layers = layersByLayer.get(shared);
+  let other, node, child, nodes;
+  for (other of layers) {
+    if (other === layer || kindByLayer.get(other) === 'terrain') continue;
+    if (kindByLayer.get(other) === 'traffic') {
+      hitData.best = 0;
+      hitData.found = false;
+      if (trafficCollision(other, x, y, z, 0, 0, 0, hitData)) return true;
+      continue;
+    }
+    nodes = hitData.nodes;
+    nodes.length = 0;
+    if (rootByLayer.get(other)) nodes.push(rootByLayer.get(other));
+    while (nodes.length) {
+      node = nodes.pop();
+      if (!node.visible) continue;
+      if (node.geometry && (
+        insideMesh(node, x, y + 0.45 * root.scale[1], z, hitData.seen, hitData.intersections) ||
+        insideMesh(node, x, y + 1.35 * root.scale[1], z, hitData.seen, hitData.intersections)
+      )) return true;
+      for (child of node.children) nodes.push(child);
+    }
+  }
+  return false;
+}

package/src/collision/intersectMeshes.js

@@ -1,40 +1,40 @@
-import { sortHits } from './sortHits.js';
-import { localRay } from './localRay.js';
-import { rayBounds } from './rayBounds.js';
-import { readTriangle } from './readTriangle.js';
-import { triangleDistance } from './triangleDistance.js';
-import { worldHit } from './worldHit.js';
-
-/**
- * Find the nearest triangle hit per mesh, sorted by world-space distance.
- *
- * @param {Object} ray World-space ray with origin and direction.
- * @param {Object[]} meshes Meshes to test.
- * @param {number} [night] Night-light intensity for halo picking.
- *
- * @returns {Object[]} Nearest hit for each intersected mesh.
- */
-export function intersectMeshes(ray, meshes, night = 0) {
-  const hits = /* alloc */ [];
-  const a = /* alloc */ [0, 0, 0], b = /* alloc */ [0, 0, 0], c = /* alloc */ [0, 0, 0];
-  const origin = /* alloc */ [0, 0, 0], direction = /* alloc */ [0, 0, 0];
-  let mesh, position, index, instanceOffset, vertices, closest, faceIndex, i, distance;
-  for (mesh of meshes) {
-    // Test locally, then compare distances in shared world space.
-    localRay(ray, mesh, origin, direction);
-    if (!rayBounds(mesh, origin, direction)) continue;
-    ({ position, index, instanceOffset } = mesh.geometry.attributes);
-    vertices = index?.count || position.count;
-    closest = Infinity, faceIndex = void 0;
-    for (i = 0; i < vertices * (instanceOffset?.count ?? 1); i += 3) {
-      readTriangle(mesh, i, a, b, c);
-      distance = triangleDistance(mesh, i, a, b, c, origin, direction, night);
-      if (distance > 0 && distance < closest) {
-        closest = distance; faceIndex = i / 3;
-      }
-    }
-    if (faceIndex === undefined) continue;
-    hits.push(worldHit(ray, mesh, origin, direction, closest, faceIndex));
-  }
-  return sortHits(hits);
-}
+import { sortHits } from './sortHits.js';
+import { localRay } from './localRay.js';
+import { rayBounds } from './rayBounds.js';
+import { readTriangle } from './readTriangle.js';
+import { triangleDistance } from './triangleDistance.js';
+import { worldHit } from './worldHit.js';
+
+/**
+ * Find the nearest triangle hit per mesh, sorted by world-space distance.
+ *
+ * @param {Object} ray World-space ray with origin and direction.
+ * @param {Object[]} meshes Meshes to test.
+ * @param {number} [night] Night-light intensity for halo picking.
+ *
+ * @returns {Object[]} Nearest hit for each intersected mesh.
+ */
+export function intersectMeshes(ray, meshes, night = 0) {
+  const hits = /* alloc */ [];
+  const a = /* alloc */ [0, 0, 0], b = /* alloc */ [0, 0, 0], c = /* alloc */ [0, 0, 0];
+  const origin = /* alloc */ [0, 0, 0], direction = /* alloc */ [0, 0, 0];
+  let mesh, position, index, instanceOffset, vertices, closest, faceIndex, i, distance;
+  for (mesh of meshes) {
+    // Test locally, then compare distances in shared world space.
+    localRay(ray, mesh, origin, direction);
+    if (!rayBounds(mesh, origin, direction)) continue;
+    ({ position, index, instanceOffset } = mesh.geometry.attributes);
+    vertices = index?.count || position.count;
+    closest = Infinity, faceIndex = void 0;
+    for (i = 0; i < vertices * (instanceOffset?.count ?? 1); i += 3) {
+      readTriangle(mesh, i, a, b, c);
+      distance = triangleDistance(mesh, i, a, b, c, origin, direction, night);
+      if (distance > 0 && distance < closest) {
+        closest = distance; faceIndex = i / 3;
+      }
+    }
+    if (faceIndex === undefined) continue;
+    hits.push(worldHit(ray, mesh, origin, direction, closest, faceIndex));
+  }
+  return sortHits(hits);
+}

package/src/collision/localRay.js

@@ -1,31 +1,31 @@
-/**
- * Transform a world-space ray into mesh coordinates, normalizing its direction and rejecting singular transforms.
- *
- * @param {Object} ray World-space origin and direction.
- * @param {Object} mesh Mesh whose world matrix is inverted.
- * @param {number[]} origin Output local origin.
- * @param {number[]} direction Output normalized local direction.
- *
- * @throws {Error} If the inverse transform contains non-finite values.
- */
-export function localRay(ray, mesh, origin, direction) {
-  const inverse = /* alloc */ new DOMMatrix(mesh.worldMatrix).invertSelf();
-  const inverseValues = inverse.toFloat64Array();
-  let value, x, y, z, w;
-  for (value of inverseValues) {
-    if (!Number.isFinite(value)) throw /* alloc */ new Error('Singular 3D transform');
-  }
-  x = ray.origin[0], y = ray.origin[1], z = ray.origin[2];
-  w = inverseValues[3] * x + inverseValues[7] * y + inverseValues[11] * z + inverseValues[15];
-  origin[0] = (inverseValues[0] * x + inverseValues[4] * y + inverseValues[8] * z + inverseValues[12]) / w;
-  origin[1] = (inverseValues[1] * x + inverseValues[5] * y + inverseValues[9] * z + inverseValues[13]) / w;
-  origin[2] = (inverseValues[2] * x + inverseValues[6] * y + inverseValues[10] * z + inverseValues[14]) / w;
-  x = ray.direction[0], y = ray.direction[1], z = ray.direction[2];
-  direction[0] = inverseValues[0] * x + inverseValues[4] * y + inverseValues[8] * z;
-  direction[1] = inverseValues[1] * x + inverseValues[5] * y + inverseValues[9] * z;
-  direction[2] = inverseValues[2] * x + inverseValues[6] * y + inverseValues[10] * z;
-  const directionLength = Math.hypot(...direction) || 1;
-  direction[0] /= directionLength;
-  direction[1] /= directionLength;
-  direction[2] /= directionLength;
-}
+/**
+ * Transform a world-space ray into mesh coordinates, normalizing its direction and rejecting singular transforms.
+ *
+ * @param {Object} ray World-space origin and direction.
+ * @param {Object} mesh Mesh whose world matrix is inverted.
+ * @param {number[]} origin Output local origin.
+ * @param {number[]} direction Output normalized local direction.
+ *
+ * @throws {Error} If the inverse transform contains non-finite values.
+ */
+export function localRay(ray, mesh, origin, direction) {
+  const inverse = /* alloc */ new DOMMatrix(mesh.worldMatrix).invertSelf();
+  const inverseValues = inverse.toFloat64Array();
+  let value, x, y, z, w;
+  for (value of inverseValues) {
+    if (!Number.isFinite(value)) throw /* alloc */ new Error('Singular 3D transform');
+  }
+  x = ray.origin[0], y = ray.origin[1], z = ray.origin[2];
+  w = inverseValues[3] * x + inverseValues[7] * y + inverseValues[11] * z + inverseValues[15];
+  origin[0] = (inverseValues[0] * x + inverseValues[4] * y + inverseValues[8] * z + inverseValues[12]) / w;
+  origin[1] = (inverseValues[1] * x + inverseValues[5] * y + inverseValues[9] * z + inverseValues[13]) / w;
+  origin[2] = (inverseValues[2] * x + inverseValues[6] * y + inverseValues[10] * z + inverseValues[14]) / w;
+  x = ray.direction[0], y = ray.direction[1], z = ray.direction[2];
+  direction[0] = inverseValues[0] * x + inverseValues[4] * y + inverseValues[8] * z;
+  direction[1] = inverseValues[1] * x + inverseValues[5] * y + inverseValues[9] * z;
+  direction[2] = inverseValues[2] * x + inverseValues[6] * y + inverseValues[10] * z;
+  const directionLength = Math.hypot(...direction) || 1;
+  direction[0] /= directionLength;
+  direction[1] /= directionLength;
+  direction[2] /= directionLength;
+}

package/src/collision/mergeHits.js

@@ -1,19 +1,19 @@
-/**
- * Merge two adjacent, distance-sorted hit runs into the target buffer, preserving ties.
- *
- * @param {Object[]} source Array containing the sorted runs.
- * @param {Object[]} target Array receiving the merged run.
- * @param {number} start First index of the runs.
- * @param {number} width Maximum length of each run.
- */
-export function mergeHits(source, target, start, width) {
-  const middle = Math.min(start + width, source.length), end = Math.min(start + width * 2, source.length);
-  let left = start, right = middle, output;
-  for (output = start; output < end; output++) {
-    if (left < middle && (right >= end || !(source[right].distance < source[left].distance))) {
-      target[output] = source[left++];
-    } else {
-      target[output] = source[right++];
-    }
-  }
-}
+/**
+ * Merge two adjacent, distance-sorted hit runs into the target buffer, preserving ties.
+ *
+ * @param {Object[]} source Array containing the sorted runs.
+ * @param {Object[]} target Array receiving the merged run.
+ * @param {number} start First index of the runs.
+ * @param {number} width Maximum length of each run.
+ */
+export function mergeHits(source, target, start, width) {
+  const middle = Math.min(start + width, source.length), end = Math.min(start + width * 2, source.length);
+  let left = start, right = middle, output;
+  for (output = start; output < end; output++) {
+    if (left < middle && (right >= end || !(source[right].distance < source[left].distance))) {
+      target[output] = source[left++];
+    } else {
+      target[output] = source[right++];
+    }
+  }
+}

package/src/collision/rayBounds.js

@@ -1,28 +1,28 @@
-import { computeBounds } from '../geometry/computeBounds.js';
-
-/**
- * Test a local-space ray against the mesh bounding box, calculating bounds when needed.
- *
- * @param {Object} mesh Mesh whose geometry bounds are tested.
- * @param {number[]} origin Local ray origin.
- * @param {number[]} direction Local ray direction.
- *
- * @returns {boolean} Whether the ray intersects the bounding box.
- */
-export function rayBounds(mesh, origin, direction) {
-  if (!mesh.geometry.bounds) computeBounds(mesh.geometry);
-  let near = 0, far = Infinity, i, a, b;
-  for (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 {
-      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));
-    }
-  }
-  return !(far < near);
-}
+import { computeBounds } from '../geometry/computeBounds.js';
+
+/**
+ * Test a local-space ray against the mesh bounding box, calculating bounds when needed.
+ *
+ * @param {Object} mesh Mesh whose geometry bounds are tested.
+ * @param {number[]} origin Local ray origin.
+ * @param {number[]} direction Local ray direction.
+ *
+ * @returns {boolean} Whether the ray intersects the bounding box.
+ */
+export function rayBounds(mesh, origin, direction) {
+  if (!mesh.geometry.bounds) computeBounds(mesh.geometry);
+  let near = 0, far = Infinity, i, a, b;
+  for (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 {
+      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));
+    }
+  }
+  return !(far < near);
+}

package/src/collision/readTriangle.js

@@ -1,32 +1,32 @@
-import { vertexCount } from './vertexCount.js';
-
-/**
- * Read an indexed or non-indexed triangle into caller-owned vectors, applying any instance offset.
- *
- * @param {Object} mesh Mesh containing geometry attributes.
- * @param {number} i First index or vertex offset, including instance offset.
- * @param {number[]} a Output first vertex.
- * @param {number[]} b Output second vertex.
- * @param {number[]} c Output third vertex.
- */
-export function readTriangle(mesh, i, a, b, c) {
-  const { position, index, instanceOffset } = mesh.geometry.attributes;
-  const size = position.size ?? 3;
-  const vertices = vertexCount(position, index);
-  const vertex = instanceOffset ? i % vertices : i;
-  const offset = instanceOffset ? Math.floor(i / vertices) * instanceOffset.size : 0;
-  const x = instanceOffset?.data[offset] ?? 0;
-  const y = instanceOffset?.data[offset + 1] ?? 0;
-  const z = instanceOffset?.data[offset + 2] ?? 0;
-  const ai = (index ? index.data[vertex] : vertex) * size;
-  const bi = (index ? index.data[vertex + 1] : vertex + 1) * size;
-  const ci = (index ? index.data[vertex + 2] : vertex + 2) * 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];
-  if (instanceOffset) {
-    a[0] = Math.fround(a[0] + x); a[1] = Math.fround(a[1] + y); a[2] = Math.fround(a[2] + z);
-    b[0] = Math.fround(b[0] + x); b[1] = Math.fround(b[1] + y); b[2] = Math.fround(b[2] + z);
-    c[0] = Math.fround(c[0] + x); c[1] = Math.fround(c[1] + y); c[2] = Math.fround(c[2] + z);
-  }
-}
+import { vertexCount } from './vertexCount.js';
+
+/**
+ * Read an indexed or non-indexed triangle into caller-owned vectors, applying any instance offset.
+ *
+ * @param {Object} mesh Mesh containing geometry attributes.
+ * @param {number} i First index or vertex offset, including instance offset.
+ * @param {number[]} a Output first vertex.
+ * @param {number[]} b Output second vertex.
+ * @param {number[]} c Output third vertex.
+ */
+export function readTriangle(mesh, i, a, b, c) {
+  const { position, index, instanceOffset } = mesh.geometry.attributes;
+  const size = position.size ?? 3;
+  const vertices = vertexCount(position, index);
+  const vertex = instanceOffset ? i % vertices : i;
+  const offset = instanceOffset ? Math.floor(i / vertices) * instanceOffset.size : 0;
+  const x = instanceOffset?.data[offset] ?? 0;
+  const y = instanceOffset?.data[offset + 1] ?? 0;
+  const z = instanceOffset?.data[offset + 2] ?? 0;
+  const ai = (index ? index.data[vertex] : vertex) * size;
+  const bi = (index ? index.data[vertex + 1] : vertex + 1) * size;
+  const ci = (index ? index.data[vertex + 2] : vertex + 2) * 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];
+  if (instanceOffset) {
+    a[0] = Math.fround(a[0] + x); a[1] = Math.fround(a[1] + y); a[2] = Math.fround(a[2] + z);
+    b[0] = Math.fround(b[0] + x); b[1] = Math.fround(b[1] + y); b[2] = Math.fround(b[2] + z);
+    c[0] = Math.fround(c[0] + x); c[1] = Math.fround(c[1] + y); c[2] = Math.fround(c[2] + z);
+  }
+}

package/src/collision/trafficCollision.js

@@ -1,27 +1,27 @@
-import { rootByLayer } from '../weakmaps/rootByLayer.js';
-import { trafficByLayer } from '../weakmaps/trafficByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { trafficByLayer } from '../weakmaps/trafficByLayer.js';
 import { collideTrip } from './collideTrip.js';
-import { trafficBounds } from './trafficBounds.js';
-
-/**
- * Test a walker point or movement ray against oriented traffic bounds, updating the nearest hit in data.
- *
- * @param {L.Layer} layer Traffic layer.
- * @param {number} x Walker world-space x coordinate.
- * @param {number} y Walker world-space feet height.
- * @param {number} z Walker world-space z coordinate.
- * @param {number} dx Movement direction x.
- * @param {number} dz Movement direction z.
- * @param {number} reach Movement distance, or zero to test overlap.
- * @param {Object} data Reusable hit record, updated when a collision is found.
- *
- * @returns {boolean} Whether a collision was found.
- */
-export function trafficCollision(layer, x, y, z, dx, dz, reach, data) {
-  const state = trafficByLayer.get(layer);
-  if (!state?.mesh || !state.trips.length) return false;
-  const root = rootByLayer.get(layer), bounds = trafficBounds(state);
-  let trip;
+import { trafficBounds } from './trafficBounds.js';
+
+/**
+ * Test a walker point or movement ray against oriented traffic bounds, updating the nearest hit in data.
+ *
+ * @param {L.Layer} layer Traffic layer.
+ * @param {number} x Walker world-space x coordinate.
+ * @param {number} y Walker world-space feet height.
+ * @param {number} z Walker world-space z coordinate.
+ * @param {number} dx Movement direction x.
+ * @param {number} dz Movement direction z.
+ * @param {number} reach Movement distance, or zero to test overlap.
+ * @param {Object} data Reusable hit record, updated when a collision is found.
+ *
+ * @returns {boolean} Whether a collision was found.
+ */
+export function trafficCollision(layer, x, y, z, dx, dz, reach, data) {
+  const state = trafficByLayer.get(layer);
+  if (!state?.mesh || !state.trips.length) return false;
+  const root = rootByLayer.get(layer), bounds = trafficBounds(state);
+  let trip;
   for (trip of state.trips) {
     collideTrip(state, trip, root, bounds, x, y, z, dx, dz, reach, data);
     if (!reach && data.found) break;

package/src/collision/transformTriangle.js

@@ -1,18 +1,18 @@
-/**
- * Write three indexed or sequential positions transformed by matrix m into v.
- *
- * @param {number[]} v Output packed triangle coordinates.
- * @param {ArrayLike<number>} p Packed input positions.
- * @param {Object|undefined} index Optional geometry index attribute.
- * @param {number} i First vertex or index offset.
- * @param {ArrayLike<number>} m Column-major transformation matrix.
- */
-export function transformTriangle(v, p, index, i, m) {
-  let k, j, x, y, z;
-  for (k = 0; k < 3; k++) {
-    j = (index ? index.data[i + k] : i + k) * 3, x = p[j], y = p[j + 1], z = p[j + 2];
-    v[k * 3] = m[0] * x + m[4] * y + m[8] * z + m[12];
-    v[k * 3 + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
-    v[k * 3 + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
-  }
-}
+/**
+ * Write three indexed or sequential positions transformed by matrix m into v.
+ *
+ * @param {number[]} v Output packed triangle coordinates.
+ * @param {ArrayLike<number>} p Packed input positions.
+ * @param {Object|undefined} index Optional geometry index attribute.
+ * @param {number} i First vertex or index offset.
+ * @param {ArrayLike<number>} m Column-major transformation matrix.
+ */
+export function transformTriangle(v, p, index, i, m) {
+  let k, j, x, y, z;
+  for (k = 0; k < 3; k++) {
+    j = (index ? index.data[i + k] : i + k) * 3, x = p[j], y = p[j + 1], z = p[j + 2];
+    v[k * 3] = m[0] * x + m[4] * y + m[8] * z + m[12];
+    v[k * 3 + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+    v[k * 3 + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+  }
+}

package/src/collision/triangleDistance.js

@@ -1,34 +1,34 @@
-import { hiddenLightHit } from './hiddenLightHit.js';
-
-/**
- * Compute ray-triangle distance using the renderer's culling and light-halo rules.
- *
- * @param {Object} mesh Mesh containing material and geometry attributes.
- * @param {number} i Triangle's first vertex or index offset.
- * @param {number[]} a First vertex.
- * @param {number[]} b Second vertex.
- * @param {number[]} c Third vertex.
- * @param {number[]} origin Local ray origin.
- * @param {number[]} direction Local ray direction.
- * @param {number} night Night-light intensity.
- *
- * @returns {number} Signed ray distance, or Infinity when the hit is rejected.
- */
-export function triangleDistance(mesh, i, a, b, c, origin, direction, night) {
-  const ex = b[0] - a[0], ey = b[1] - a[1], ez = b[2] - a[2];
-  const fx = c[0] - a[0], fy = c[1] - a[1], fz = c[2] - a[2];
-  const px = direction[1] * fz - direction[2] * fy;
-  const py = direction[2] * fx - direction[0] * fz;
-  const pz = direction[0] * fy - direction[1] * fx;
-  const det = ex * px + ey * py + ez * pz;
-  if (mesh.program.cullMode === 'none' || mesh.program.cullFace === null
-    ? Math.abs(det) < 1e-9 : det < 1e-9) return Infinity;
-  const tx = origin[0] - a[0], ty = origin[1] - a[1], tz = origin[2] - a[2];
-  const u = (tx * px + ty * py + tz * pz) / det;
-  if (u < 0 || u > 1) return Infinity;
-  const qx = ty * ez - tz * ey, qy = tz * ex - tx * ez, qz = tx * ey - ty * ex;
-  const v = (direction[0] * qx + direction[1] * qy + direction[2] * qz) / det;
-  if (v < 0 || u + v > 1) return Infinity;
-  if (hiddenLightHit(mesh, i, u, v, night)) return Infinity;
-  return (fx * qx + fy * qy + fz * qz) / det;
-}
+import { hiddenLightHit } from './hiddenLightHit.js';
+
+/**
+ * Compute ray-triangle distance using the renderer's culling and light-halo rules.
+ *
+ * @param {Object} mesh Mesh containing material and geometry attributes.
+ * @param {number} i Triangle's first vertex or index offset.
+ * @param {number[]} a First vertex.
+ * @param {number[]} b Second vertex.
+ * @param {number[]} c Third vertex.
+ * @param {number[]} origin Local ray origin.
+ * @param {number[]} direction Local ray direction.
+ * @param {number} night Night-light intensity.
+ *
+ * @returns {number} Signed ray distance, or Infinity when the hit is rejected.
+ */
+export function triangleDistance(mesh, i, a, b, c, origin, direction, night) {
+  const ex = b[0] - a[0], ey = b[1] - a[1], ez = b[2] - a[2];
+  const fx = c[0] - a[0], fy = c[1] - a[1], fz = c[2] - a[2];
+  const px = direction[1] * fz - direction[2] * fy;
+  const py = direction[2] * fx - direction[0] * fz;
+  const pz = direction[0] * fy - direction[1] * fx;
+  const det = ex * px + ey * py + ez * pz;
+  if (mesh.program.cullMode === 'none' || mesh.program.cullFace === null
+    ? Math.abs(det) < 1e-9 : det < 1e-9) return Infinity;
+  const tx = origin[0] - a[0], ty = origin[1] - a[1], tz = origin[2] - a[2];
+  const u = (tx * px + ty * py + tz * pz) / det;
+  if (u < 0 || u > 1) return Infinity;
+  const qx = ty * ez - tz * ey, qy = tz * ex - tx * ez, qz = tx * ey - ty * ex;
+  const v = (direction[0] * qx + direction[1] * qy + direction[2] * qz) / det;
+  if (v < 0 || u + v > 1) return Infinity;
+  if (hiddenLightHit(mesh, i, u, v, night)) return Infinity;
+  return (fx * qx + fy * qy + fz * qz) / det;
+}

package/src/collision/vertexCount.js

@@ -1,11 +1,11 @@
-/**
- * Return the number of indexed or sequential vertices represented by the geometry attributes.
- *
- * @param {Object} position Position attribute.
- * @param {Object|undefined} index Optional index attribute.
- *
- * @returns {number} Number of indices or sequential vertices.
- */
-export function vertexCount(position, index) {
-  return index?.count ?? index?.data.length ?? position.count ?? position.data.length / (position.size ?? 3);
-}
+/**
+ * Return the number of indexed or sequential vertices represented by the geometry attributes.
+ *
+ * @param {Object} position Position attribute.
+ * @param {Object|undefined} index Optional index attribute.
+ *
+ * @returns {number} Number of indices or sequential vertices.
+ */
+export function vertexCount(position, index) {
+  return index?.count ?? index?.data.length ?? position.count ?? position.data.length / (position.size ?? 3);
+}