leaflet-city-mapper 0.1.0 → 0.1.1

package/src/geometry/diskAt.js

@@ -1,18 +1,18 @@
-import { tau } from '../globals/tau.js';
-import { L } from '../globals/L.js';
-
-/**
- * Compute a point on an elliptical disk perimeter.
- *
- * @param {L.Point} center Disk center.
- * @param {number} radius Horizontal radius.
- * @param {number} radiusY Vertical radius.
- * @param {number} count Perimeter subdivision count.
- * @param {number} index Perimeter point index.
- *
- * @returns {L.Point} Perimeter point.
- */
-export function diskAt(center, radius, radiusY, count, index) {
-  return /* alloc */ new L.Point(center.x + radius * Math.cos(index * tau / count),
-    center.y + radiusY * Math.sin(index * tau / count));
-}
+import { tau } from '../globals/tau.js';
+import { L } from '../globals/L.js';
+
+/**
+ * Compute a point on an elliptical disk perimeter.
+ *
+ * @param {L.Point} center Disk center.
+ * @param {number} radius Horizontal radius.
+ * @param {number} radiusY Vertical radius.
+ * @param {number} count Perimeter subdivision count.
+ * @param {number} index Perimeter point index.
+ *
+ * @returns {L.Point} Perimeter point.
+ */
+export function diskAt(center, radius, radiusY, count, index) {
+  return /* alloc */ new L.Point(center.x + radius * Math.cos(index * tau / count),
+    center.y + radiusY * Math.sin(index * tau / count));
+}

package/src/geometry/emitter.js

@@ -1,18 +1,18 @@
-/**
- * Construct a point on one axis-aligned plane of a light emitter.
- *
- * @param {Object} point Projected center and ground height.
- * @param {number} u First local coordinate.
- * @param {number} v Second local coordinate.
- * @param {number} axis Plane axis index.
- *
- * @returns {Object} Projected point with ground height and UV coordinates.
- */
-export function emitter(point, u, v, axis) {
-  const r = 0.65;
-  return /* alloc */ {
-    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: /* alloc */ [u, v],
-  };
-}
+/**
+ * Construct a point on one axis-aligned plane of a light emitter.
+ *
+ * @param {Object} point Projected center and ground height.
+ * @param {number} u First local coordinate.
+ * @param {number} v Second local coordinate.
+ * @param {number} axis Plane axis index.
+ *
+ * @returns {Object} Projected point with ground height and UV coordinates.
+ */
+export function emitter(point, u, v, axis) {
+  const r = 0.65;
+  return /* alloc */ {
+    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: /* alloc */ [u, v],
+  };
+}

package/src/geometry/fillNativePolygon.js

@@ -1,28 +1,28 @@
-import { triangle } from './appendNativeTriangle.js';
-import { triangulate } from '../triangulation/triangulate.js';
-
-/**
- * Append fill triangles for a native polygon, respecting pre-triangulated input.
- *
- * @param {Object} context Projection, style and fill buffer.
- * @param {Array<Array<L.Point>>} projected Projected polygon rings.
- *
- * @throws {Error} If a pre-triangulated polygon does not have exactly three vertices and no holes.
- */
-export function fillNativePolygon(context, projected) {
-  const { options, fill, point } = context;
-  if (options.triangulated) {
-    if (projected.length !== 1 || projected[0].length !== 3) {
-      throw /* alloc */ new Error('triangulated polygons require three vertices per polygon and no holes');
-    }
-    triangle(point, fill, projected[0][0], projected[0][1], projected[0][2]);
-    return;
-  }
-  const valid = /* alloc */ [];
-  let ring, indices;
-  for (ring of projected) if (ring.length >= 3) valid.push(ring);
-  const vertices = valid.flat();
-  for (indices of triangulate(valid[0], valid.slice(1))) {
-    triangle(point, fill, vertices[indices[0]], vertices[indices[1]], vertices[indices[2]]);
-  }
-}
+import { triangle } from './appendNativeTriangle.js';
+import { triangulate } from '../triangulation/triangulate.js';
+
+/**
+ * Append fill triangles for a native polygon, respecting pre-triangulated input.
+ *
+ * @param {Object} context Projection, style and fill buffer.
+ * @param {Array<Array<L.Point>>} projected Projected polygon rings.
+ *
+ * @throws {Error} If a pre-triangulated polygon does not have exactly three vertices and no holes.
+ */
+export function fillNativePolygon(context, projected) {
+  const { options, fill, point } = context;
+  if (options.triangulated) {
+    if (projected.length !== 1 || projected[0].length !== 3) {
+      throw /* alloc */ new Error('triangulated polygons require three vertices per polygon and no holes');
+    }
+    triangle(point, fill, projected[0][0], projected[0][1], projected[0][2]);
+    return;
+  }
+  const valid = /* alloc */ [];
+  let ring, indices;
+  for (ring of projected) if (ring.length >= 3) valid.push(ring);
+  const vertices = valid.flat();
+  for (indices of triangulate(valid[0], valid.slice(1))) {
+    triangle(point, fill, vertices[indices[0]], vertices[indices[1]], vertices[indices[2]]);
+  }
+}

package/src/geometry/generateTreeGeometry.js

@@ -1,19 +1,19 @@
-import { triangleContexts } from '../globals/triangleContexts.js';
-import { addGeneratedTriangle } from './addGeneratedTriangle.js';
-
-/**
- * Run a point geometry generator with the current triangle destination context.
- *
- * @param {Object} context Destination area geometry.
- * @param {Function} generator Point geometry generator.
- * @param {Object} point Projected point.
- * @param {Object} style Geometry style.
- */
-export function generateTreeGeometry(context, generator, point, style) {
-  triangleContexts.push(context);
-  try {
-    generator(point, style, addGeneratedTriangle);
-  } finally {
-    triangleContexts.pop();
-  }
+import { triangleContexts } from '../globals/triangleContexts.js';
+import { addGeneratedTriangle } from './addGeneratedTriangle.js';
+
+/**
+ * Run a point geometry generator with the current triangle destination context.
+ *
+ * @param {Object} context Destination area geometry.
+ * @param {Function} generator Point geometry generator.
+ * @param {Object} point Projected point.
+ * @param {Object} style Geometry style.
+ */
+export function generateTreeGeometry(context, generator, point, style) {
+  triangleContexts.push(context);
+  try {
+    generator(point, style, addGeneratedTriangle);
+  } finally {
+    triangleContexts.pop();
+  }
 }

package/src/geometry/indexBridge.js

@@ -1,36 +1,36 @@
-import { bridgesByLayer } from '../weakmaps/bridgesByLayer.js';
-
-/**
- * Index bridge triangles in 64-pixel buckets for elevation lookup.
- *
- * @param {L.Layer} layer Terrain layer owning the bridge index.
- * @param {Array<Array<number>>} pixels Projected vertices including elevation.
- * @param {Array<Array<number>>} triangles Triangle vertex indices.
- */
-export function indexBridge(layer, pixels, triangles) {
-  const bridgeTriangles = /* alloc */ [];
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  let t, triangle, i, p, x, y, key, bucket;
-  for (t of triangles) {
-    triangle = /* alloc */ [];
-    for (i of t) triangle.push(pixels[i]);
-    bridgeTriangles.push(triangle);
-  }
-  for (p of pixels) {
-    minX = Math.min(minX, p[0]); minY = Math.min(minY, p[1]);
-    maxX = Math.max(maxX, p[0]); maxY = Math.max(maxY, p[1]);
-  }
-  const bridge = /* alloc */ {
-    triangles: bridgeTriangles,
-    min: /* alloc */ [minX, minY],
-    max: /* alloc */ [maxX, maxY],
-  };
-  for (x = Math.floor(bridge.min[0] / 64); x <= Math.floor(bridge.max[0] / 64); x++) {
-    for (y = Math.floor(bridge.min[1] / 64); y <= Math.floor(bridge.max[1] / 64); y++) {
-      key = `${x}/${y}`;
-      bucket = bridgesByLayer.get(layer).get(key);
-      if (!bucket) bridgesByLayer.get(layer).set(key, bucket = /* alloc */ []);
-      bucket.push(bridge);
-    }
-  }
-}
+import { bridgesByLayer } from '../weakmaps/bridgesByLayer.js';
+
+/**
+ * Index bridge triangles in 64-pixel buckets for elevation lookup.
+ *
+ * @param {L.Layer} layer Terrain layer owning the bridge index.
+ * @param {Array<Array<number>>} pixels Projected vertices including elevation.
+ * @param {Array<Array<number>>} triangles Triangle vertex indices.
+ */
+export function indexBridge(layer, pixels, triangles) {
+  const bridgeTriangles = /* alloc */ [];
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let t, triangle, i, p, x, y, key, bucket;
+  for (t of triangles) {
+    triangle = /* alloc */ [];
+    for (i of t) triangle.push(pixels[i]);
+    bridgeTriangles.push(triangle);
+  }
+  for (p of pixels) {
+    minX = Math.min(minX, p[0]); minY = Math.min(minY, p[1]);
+    maxX = Math.max(maxX, p[0]); maxY = Math.max(maxY, p[1]);
+  }
+  const bridge = /* alloc */ {
+    triangles: bridgeTriangles,
+    min: /* alloc */ [minX, minY],
+    max: /* alloc */ [maxX, maxY],
+  };
+  for (x = Math.floor(bridge.min[0] / 64); x <= Math.floor(bridge.max[0] / 64); x++) {
+    for (y = Math.floor(bridge.min[1] / 64); y <= Math.floor(bridge.max[1] / 64); y++) {
+      key = `${x}/${y}`;
+      bucket = bridgesByLayer.get(layer).get(key);
+      if (!bucket) bridgesByLayer.get(layer).set(key, bucket = /* alloc */ []);
+      bucket.push(bridge);
+    }
+  }
+}

package/src/geometry/instanceAreaGeometry.js

@@ -1,37 +1,37 @@
-/**
- * Compact repeated features only when reconstructed float32 positions compare equal.
- *
- * @param {Object} context Area geometry buffers and feature ranges.
- *
- * @returns {Object} Instanced buffers, or the original context if compaction is unsuitable.
- */
-export function instanceAreaGeometry(context) {
-  const { positions, normals, colors, featureFaces } = context;
-  if (context.backend.options.nightLight || featureFaces.length < 2) return context;
-  const vertices = featureFaces[0].vertexEnd;
-  const length = vertices * 3;
-  if (!vertices || positions.length !== length * featureFaces.length) return context;
-  const originX = Math.trunc(positions[0]), originY = Math.trunc(positions[1]), originZ = Math.trunc(positions[2]);
-  const template = /* alloc */ new Float32Array(length);
-  let i, instance, face, start;
-  for (i = 0; i < length; i++) template[i] = positions[i] - (i % 3 === 0 ? originX : i % 3 === 1 ? originY : originZ);
-  const offsets = /* alloc */ new Float32Array(featureFaces.length * 4);
-  for (instance = 0; instance < featureFaces.length; instance++) {
-    face = featureFaces[instance];
-    start = instance * length;
-    if (face.vertexStart !== instance * vertices || face.vertexEnd !== (instance + 1) * vertices) return context;
-    offsets[instance * 4] = originX + positions[start] - positions[0];
-    offsets[instance * 4 + 1] = originY + positions[start + 1] - positions[1];
-    offsets[instance * 4 + 2] = originZ + positions[start + 2] - positions[2];
-    offsets[instance * 4 + 3] = instance * vertices;
-    for (i = 0; i < length; i++) {
-      if (Math.fround(template[i] + offsets[instance * 4 + i % 3]) !== Math.fround(positions[start + i]) ||
-          Math.fround(normals[i]) !== Math.fround(normals[start + i]) ||
-          Math.fround(colors[i]) !== Math.fround(colors[start + i])) return context;
-    }
-  }
-  return /* alloc */ {
-    positions: template, normals: normals.slice(0, length), colors: colors.slice(0, length),
-    instanceOffsets: offsets,
-  };
-}
+/**
+ * Compact repeated features only when reconstructed float32 positions compare equal.
+ *
+ * @param {Object} context Area geometry buffers and feature ranges.
+ *
+ * @returns {Object} Instanced buffers, or the original context if compaction is unsuitable.
+ */
+export function instanceAreaGeometry(context) {
+  const { positions, normals, colors, featureFaces } = context;
+  if (context.backend.options.nightLight || featureFaces.length < 2) return context;
+  const vertices = featureFaces[0].vertexEnd;
+  const length = vertices * 3;
+  if (!vertices || positions.length !== length * featureFaces.length) return context;
+  const originX = Math.trunc(positions[0]), originY = Math.trunc(positions[1]), originZ = Math.trunc(positions[2]);
+  const template = /* alloc */ new Float32Array(length);
+  let i, instance, face, start;
+  for (i = 0; i < length; i++) template[i] = positions[i] - (i % 3 === 0 ? originX : i % 3 === 1 ? originY : originZ);
+  const offsets = /* alloc */ new Float32Array(featureFaces.length * 4);
+  for (instance = 0; instance < featureFaces.length; instance++) {
+    face = featureFaces[instance];
+    start = instance * length;
+    if (face.vertexStart !== instance * vertices || face.vertexEnd !== (instance + 1) * vertices) return context;
+    offsets[instance * 4] = originX + positions[start] - positions[0];
+    offsets[instance * 4 + 1] = originY + positions[start + 1] - positions[1];
+    offsets[instance * 4 + 2] = originZ + positions[start + 2] - positions[2];
+    offsets[instance * 4 + 3] = instance * vertices;
+    for (i = 0; i < length; i++) {
+      if (Math.fround(template[i] + offsets[instance * 4 + i % 3]) !== Math.fround(positions[start + i]) ||
+          Math.fround(normals[i]) !== Math.fround(normals[start + i]) ||
+          Math.fround(colors[i]) !== Math.fround(colors[start + i])) return context;
+    }
+  }
+  return /* alloc */ {
+    positions: template, normals: normals.slice(0, length), colors: colors.slice(0, length),
+    instanceOffsets: offsets,
+  };
+}

package/src/geometry/line.js

@@ -1,28 +1,28 @@
-import { segment } from './segment.js';
-import { lineJoin } from './lineJoin.js';
-import { dashedSegment } from './dashedSegment.js';
-
-/**
- * Generate solid or dashed stroke geometry for a projected line or ring.
- *
- * @param {Object} context Line style and geometry buffers.
- * @param {Array<L.Point>} points Projected line points.
- * @param {boolean} closed Whether to connect the last point to the first.
- */
-export function line(context, points, closed) {
-  const { options, width, dash } = context;
-  if (!options.stroke || width <= 0 || points.length < 2) return;
-  let distance = Number(options.dashOffset) || 0;
-  let period = 0, value, i, a, b, length;
-  for (value of dash) period += value;
-  for (i = 0; i < points.length - (closed ? 0 : 1); i++) {
-    a = points[i], b = points[(i + 1) % points.length], length = a.distanceTo(b);
-    if (!dash.length) {
-      segment(context, a, b, !closed && i === 0, !closed && i === points.length - 2);
-      if (closed || i > 0) lineJoin(context, points, i, b, length);
-    } else {
-      dashedSegment(context, a, b, length, distance, period);
-    }
-    distance += length;
-  }
-}
+import { segment } from './segment.js';
+import { lineJoin } from './lineJoin.js';
+import { dashedSegment } from './dashedSegment.js';
+
+/**
+ * Generate solid or dashed stroke geometry for a projected line or ring.
+ *
+ * @param {Object} context Line style and geometry buffers.
+ * @param {Array<L.Point>} points Projected line points.
+ * @param {boolean} closed Whether to connect the last point to the first.
+ */
+export function line(context, points, closed) {
+  const { options, width, dash } = context;
+  if (!options.stroke || width <= 0 || points.length < 2) return;
+  let distance = Number(options.dashOffset) || 0;
+  let period = 0, value, i, a, b, length;
+  for (value of dash) period += value;
+  for (i = 0; i < points.length - (closed ? 0 : 1); i++) {
+    a = points[i], b = points[(i + 1) % points.length], length = a.distanceTo(b);
+    if (!dash.length) {
+      segment(context, a, b, !closed && i === 0, !closed && i === points.length - 2);
+      if (closed || i > 0) lineJoin(context, points, i, b, length);
+    } else {
+      dashedSegment(context, a, b, length, distance, period);
+    }
+    distance += length;
+  }
+}

package/src/geometry/lineJoin.js

@@ -1,35 +1,35 @@
-import { L } from '../globals/L.js';
-import { triangle } from './appendNativeTriangle.js';
-import { disk } from './disk.js';
-
-/**
- * Append a round, bevel or limited miter join between consecutive line segments.
- *
- * @param {Object} context Line style and geometry buffers.
- * @param {Array<L.Point>} points Projected line points.
- * @param {number} i Index of the join point.
- * @param {L.Point} b Next point.
- * @param {number} length Outgoing segment length.
- */
-export function lineJoin(context, points, i, b, length) {
-  const { options, width, point, stroke } = context;
-  const a = points[i], radius = width / 2;
-  if (options.lineJoin === 'round') {
-    disk(point, a, radius, stroke);
-    return;
-  }
-  const previous = a.subtract(points[(i + points.length - 1) % points.length]);
-  const previousLength = Math.hypot(previous.x, previous.y);
-  if (!previousLength || !length) return;
-  const incoming = previous.divideBy(previousLength), outgoing = b.subtract(a).divideBy(length);
-  const side = incoming.x * outgoing.y - incoming.y * outgoing.x > 0 ? -1 : 1;
-  const n1 = /* alloc */ new L.Point(-incoming.y * side, incoming.x * side);
-  const n2 = /* alloc */ new L.Point(-outgoing.y * side, outgoing.x * side);
-  const from = a.add(n1.multiplyBy(radius)), to = a.add(n2.multiplyBy(radius));
-  const denominator = 1 + n1.x * n2.x + n1.y * n2.y;
-  const miter = denominator > 0 ? n1.add(n2).multiplyBy(radius / denominator) : null;
-  triangle(point, stroke, from, a, to, a, a, a);
-  if (options.lineJoin === 'miter' && miter && Math.hypot(miter.x, miter.y) <= radius * 4) {
-    triangle(point, stroke, from, a.add(miter), to, a, a, a);
-  }
-}
+import { L } from '../globals/L.js';
+import { triangle } from './appendNativeTriangle.js';
+import { disk } from './disk.js';
+
+/**
+ * Append a round, bevel or limited miter join between consecutive line segments.
+ *
+ * @param {Object} context Line style and geometry buffers.
+ * @param {Array<L.Point>} points Projected line points.
+ * @param {number} i Index of the join point.
+ * @param {L.Point} b Next point.
+ * @param {number} length Outgoing segment length.
+ */
+export function lineJoin(context, points, i, b, length) {
+  const { options, width, point, stroke } = context;
+  const a = points[i], radius = width / 2;
+  if (options.lineJoin === 'round') {
+    disk(point, a, radius, stroke);
+    return;
+  }
+  const previous = a.subtract(points[(i + points.length - 1) % points.length]);
+  const previousLength = Math.hypot(previous.x, previous.y);
+  if (!previousLength || !length) return;
+  const incoming = previous.divideBy(previousLength), outgoing = b.subtract(a).divideBy(length);
+  const side = incoming.x * outgoing.y - incoming.y * outgoing.x > 0 ? -1 : 1;
+  const n1 = /* alloc */ new L.Point(-incoming.y * side, incoming.x * side);
+  const n2 = /* alloc */ new L.Point(-outgoing.y * side, outgoing.x * side);
+  const from = a.add(n1.multiplyBy(radius)), to = a.add(n2.multiplyBy(radius));
+  const denominator = 1 + n1.x * n2.x + n1.y * n2.y;
+  const miter = denominator > 0 ? n1.add(n2).multiplyBy(radius / denominator) : null;
+  triangle(point, stroke, from, a, to, a, a, a);
+  if (options.lineJoin === 'miter' && miter && Math.hypot(miter.x, miter.y) <= radius * 4) {
+    triangle(point, stroke, from, a.add(miter), to, a, a, a);
+  }
+}

package/src/geometry/markerImageBounds.js

@@ -1,20 +1,20 @@
-/**
- * Resolve and cache a marker icon or shadow's dimensions and anchor.
- *
- * @param {Object} state Native marker state.
- * @param {string} key Image kind, such as shadow.
- * @param {HTMLImageElement} image Image providing fallback dimensions.
- *
- * @returns {Array<number>} Width, height, anchor x and anchor y.
- */
-export function markerImageBounds(state, key, image) {
-  const options = state.source.options.icon.options;
-  const dimensions = options[key === 'shadow' ? 'shadowSize' : 'iconSize'];
-  const bounds = state.markerImageBounds ||= /* alloc */ [0, 0, 0, 0];
-  bounds[0] = dimensions ? dimensions.x ?? dimensions[0] : image.naturalWidth;
-  bounds[1] = dimensions ? dimensions.y ?? dimensions[1] : image.naturalHeight;
-  const anchor = (key === 'shadow' && options.shadowAnchor) || options.iconAnchor;
-  bounds[2] = anchor ? anchor.x ?? anchor[0] : Math.floor(bounds[0] / 2);
-  bounds[3] = anchor ? anchor.y ?? anchor[1] : Math.floor(bounds[1] / 2);
-  return bounds;
-}
+/**
+ * Resolve and cache a marker icon or shadow's dimensions and anchor.
+ *
+ * @param {Object} state Native marker state.
+ * @param {string} key Image kind, such as shadow.
+ * @param {HTMLImageElement} image Image providing fallback dimensions.
+ *
+ * @returns {Array<number>} Width, height, anchor x and anchor y.
+ */
+export function markerImageBounds(state, key, image) {
+  const options = state.source.options.icon.options;
+  const dimensions = options[key === 'shadow' ? 'shadowSize' : 'iconSize'];
+  const bounds = state.markerImageBounds ||= /* alloc */ [0, 0, 0, 0];
+  bounds[0] = dimensions ? dimensions.x ?? dimensions[0] : image.naturalWidth;
+  bounds[1] = dimensions ? dimensions.y ?? dimensions[1] : image.naturalHeight;
+  const anchor = (key === 'shadow' && options.shadowAnchor) || options.iconAnchor;
+  bounds[2] = anchor ? anchor.x ?? anchor[0] : Math.floor(bounds[0] / 2);
+  bounds[3] = anchor ? anchor.y ?? anchor[1] : Math.floor(bounds[1] / 2);
+  return bounds;
+}

package/src/geometry/meshShadowBounds.js

@@ -1,33 +1,33 @@
-/**
- * Transform and cache a mesh's bounding box for shadow calculations.
- *
- * @param {Object} mesh Mesh containing the world-matrix version.
- * @param {Object} bounds Local bounding box.
- * @param {ArrayLike<number>} matrix World transformation matrix.
- *
- * @returns {Object} Cached transformed minimum and maximum bounds.
- */
-export function meshShadowBounds(mesh, bounds, matrix) {
-  let cached = mesh._shadowBounds;
-  if (!cached || cached.version !== mesh._worldMatrixVersion || cached.bounds !== bounds) {
-    cached ||= mesh._shadowBounds = /* alloc */ {
-      min: /* alloc */ [Infinity, Infinity, Infinity],
-      max: /* alloc */ [-Infinity, -Infinity, -Infinity],
-    };
-    cached.version = mesh._worldMatrixVersion;
-    cached.bounds = bounds;
-    cached.min.fill(Infinity); cached.max.fill(-Infinity);
-    let i, x, y, z, w, axis, value;
-    for (i = 0; i < 8; i++) {
-      x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
-      z = i & 4 ? bounds.max[2] : bounds.min[2];
-      w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
-      for (axis = 0; axis < 3; axis++) {
-        value = (matrix[axis] * x + matrix[axis + 4] * y + matrix[axis + 8] * z + matrix[axis + 12]) / w;
-        cached.min[axis] = Math.min(cached.min[axis], value);
-        cached.max[axis] = Math.max(cached.max[axis], value);
-      }
-    }
-  }
-  return cached;
-}
+/**
+ * Transform and cache a mesh's bounding box for shadow calculations.
+ *
+ * @param {Object} mesh Mesh containing the world-matrix version.
+ * @param {Object} bounds Local bounding box.
+ * @param {ArrayLike<number>} matrix World transformation matrix.
+ *
+ * @returns {Object} Cached transformed minimum and maximum bounds.
+ */
+export function meshShadowBounds(mesh, bounds, matrix) {
+  let cached = mesh._shadowBounds;
+  if (!cached || cached.version !== mesh._worldMatrixVersion || cached.bounds !== bounds) {
+    cached ||= mesh._shadowBounds = /* alloc */ {
+      min: /* alloc */ [Infinity, Infinity, Infinity],
+      max: /* alloc */ [-Infinity, -Infinity, -Infinity],
+    };
+    cached.version = mesh._worldMatrixVersion;
+    cached.bounds = bounds;
+    cached.min.fill(Infinity); cached.max.fill(-Infinity);
+    let i, x, y, z, w, axis, value;
+    for (i = 0; i < 8; i++) {
+      x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
+      z = i & 4 ? bounds.max[2] : bounds.min[2];
+      w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
+      for (axis = 0; axis < 3; axis++) {
+        value = (matrix[axis] * x + matrix[axis + 4] * y + matrix[axis + 8] * z + matrix[axis + 12]) / w;
+        cached.min[axis] = Math.min(cached.min[axis], value);
+        cached.max[axis] = Math.max(cached.max[axis], value);
+      }
+    }
+  }
+  return cached;
+}

package/src/geometry/offsetBelowGround.js

@@ -1,10 +1,10 @@
-/**
- * Offset a 3D point downward by the bridge deck thickness.
- *
- * @param {Array<number>} p Input point.
- *
- * @returns {Array<number>} Offset point.
- */
-export function below(p) {
-  return /* alloc */ [p[0], p[1] - 1.2, p[2]];
-}
+/**
+ * Offset a 3D point downward by the bridge deck thickness.
+ *
+ * @param {Array<number>} p Input point.
+ *
+ * @returns {Array<number>} Offset point.
+ */
+export function below(p) {
+  return /* alloc */ [p[0], p[1] - 1.2, p[2]];
+}

package/src/geometry/quad.js

@@ -1,23 +1,23 @@
-/**
- * Append a quad as two triangles at a common height.
- *
- * @param {Function} addTriangle Triangle destination callback.
- * @param {Object} color Triangle color.
- * @param {Object} a First corner.
- * @param {Object} b Second corner.
- * @param {Object} c Third corner.
- * @param {Object} d Fourth corner.
- * @param {number} height Quad height.
- * @param {number|Array<number>} nx Normal x component or complete normal vector.
- * @param {number} ny Normal y component when nx is numeric.
- * @param {number} nz Normal z component when nx is numeric.
- */
-export function quad(addTriangle, color, a, b, c, d, height, nx, ny, nz) {
-  if (typeof nx !== 'number') {
-    addTriangle(a, height, b, height, c, height, ...nx, color);
-    addTriangle(a, height, c, height, d, height, ...nx, color);
-  } else {
-    addTriangle(a, height, b, height, c, height, nx, ny, nz, color);
-    addTriangle(a, height, c, height, d, height, nx, ny, nz, color);
-  }
-}
+/**
+ * Append a quad as two triangles at a common height.
+ *
+ * @param {Function} addTriangle Triangle destination callback.
+ * @param {Object} color Triangle color.
+ * @param {Object} a First corner.
+ * @param {Object} b Second corner.
+ * @param {Object} c Third corner.
+ * @param {Object} d Fourth corner.
+ * @param {number} height Quad height.
+ * @param {number|Array<number>} nx Normal x component or complete normal vector.
+ * @param {number} ny Normal y component when nx is numeric.
+ * @param {number} nz Normal z component when nx is numeric.
+ */
+export function quad(addTriangle, color, a, b, c, d, height, nx, ny, nz) {
+  if (typeof nx !== 'number') {
+    addTriangle(a, height, b, height, c, height, ...nx, color);
+    addTriangle(a, height, c, height, d, height, ...nx, color);
+  } else {
+    addTriangle(a, height, b, height, c, height, nx, ny, nz, color);
+    addTriangle(a, height, c, height, d, height, nx, ny, nz, color);
+  }
+}