leaflet-city-mapper 0.1.0 → 0.1.1

package/src/native/updateNativeHover.js

@@ -1,15 +1,15 @@
-/**
- * Dispatch hover transitions and update the cursor for the current native hit.
- *
- * @param {Object} map Leaflet map.
- * @param {Object} context Native event state.
- * @param {Event} event Original DOM event.
- * @param {Object|null} source Hit source layer, if any.
- */
-export function updateNativeHover(map, context, event, source) {
-  if (context.hovered === source) return;
-  if (context.hovered) context.fireDOMEvent.call(map, event, context.out, /* alloc */ [context.hovered]);
-  context.hovered = source;
-  if (source) context.fireDOMEvent.call(map, event, context.over, /* alloc */ [source]);
-  map.getContainer().style.cursor = source ? 'pointer' : '';
-}
+/**
+ * Dispatch hover transitions and update the cursor for the current native hit.
+ *
+ * @param {Object} map Leaflet map.
+ * @param {Object} context Native event state.
+ * @param {Event} event Original DOM event.
+ * @param {Object|null} source Hit source layer, if any.
+ */
+export function updateNativeHover(map, context, event, source) {
+  if (context.hovered === source) return;
+  if (context.hovered) context.fireDOMEvent.call(map, event, context.out, /* alloc */ [context.hovered]);
+  context.hovered = source;
+  if (source) context.fireDOMEvent.call(map, event, context.over, /* alloc */ [source]);
+  map.getContainer().style.cursor = source ? 'pointer' : '';
+}

package/src/native/updateNativeStrokeRadius.js

@@ -1,14 +1,14 @@
-/**
- * Store the maximum distance between stroke vertices and their anchors.
- *
- * @param {Object} mesh Native stroke mesh.
- */
-export function updateNativeStrokeRadius(mesh) {
-  const attributes = mesh.geometry.attributes, positions = attributes.position.data, anchors = attributes.normal.data;
-  let i, radius = 0;
-  for (i = 0; i < positions.length; i += 3) {
-    radius = Math.max(radius, Math.hypot(positions[i] - anchors[i],
-      positions[i + 1] - anchors[i + 1], positions[i + 2] - anchors[i + 2]));
-  }
-  mesh.geometry.nativeStrokeRadius = radius;
-}
+/**
+ * Store the maximum distance between stroke vertices and their anchors.
+ *
+ * @param {Object} mesh Native stroke mesh.
+ */
+export function updateNativeStrokeRadius(mesh) {
+  const attributes = mesh.geometry.attributes, positions = attributes.position.data, anchors = attributes.normal.data;
+  let i, radius = 0;
+  for (i = 0; i < positions.length; i += 3) {
+    radius = Math.max(radius, Math.hypot(positions[i] - anchors[i],
+      positions[i + 1] - anchors[i + 1], positions[i + 2] - anchors[i + 2]));
+  }
+  mesh.geometry.nativeStrokeRadius = radius;
+}

package/src/picking/hitColliderCell.js

@@ -1,29 +1,29 @@
-import { horizontalRay } from '../collision/horizontalRay.js';
-
-/**
- * Test unseen, front-facing triangles in a collider cell at knee and chest heights.
- *
- * @param {number[]} cell Triangle indices in the cell.
- * @param {Object} c Cached collider geometry and normals.
- * @param {Object} data Collision scratch and nearest-hit state.
- * @param {number} ox Collider-local ray origin x coordinate.
- * @param {number} oy Collider-local ray origin y coordinate.
- * @param {number} oz Collider-local ray origin z coordinate.
- */
-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];
-      }
-    }
-  }
-}
+import { horizontalRay } from '../collision/horizontalRay.js';
+
+/**
+ * Test unseen, front-facing triangles in a collider cell at knee and chest heights.
+ *
+ * @param {number[]} cell Triangle indices in the cell.
+ * @param {Object} c Cached collider geometry and normals.
+ * @param {Object} data Collision scratch and nearest-hit state.
+ * @param {number} ox Collider-local ray origin x coordinate.
+ * @param {number} oy Collider-local ray origin y coordinate.
+ * @param {number} oz Collider-local ray origin z coordinate.
+ */
+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/validateCameraInverse.js

@@ -1,15 +1,15 @@
-/**
- * Verify that all components of an inverse camera matrix are finite.
- *
- * @param {DOMMatrix} matrix Inverse camera matrix.
- *
- * @throws {Error} If any matrix component is not finite.
- */
-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');
-    }
-  }
-}
+/**
+ * Verify that all components of an inverse camera matrix are finite.
+ *
+ * @param {DOMMatrix} matrix Inverse camera matrix.
+ *
+ * @throws {Error} If any matrix component is not finite.
+ */
+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');
+    }
+  }
+}

package/src/projections/displayContainerPoint.js

@@ -1,32 +1,32 @@
-import { streamTerrainByMap } from '../weakmaps/streamTerrainByMap.js';
-import { renderers } from '../weakmaps/renderers.js';
-import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
-import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
-import { mapMethods } from '../globals/mapMethods.js';
-import { radians } from '../globals/radians.js';
-import { earthCirc } from '../globals/earthCirc.js';
-import { mapElevationOf } from '../terrain/mapElevationOf.js';
-import { animationPoint } from './transformZoomAnimationPoint.js';
-import { project } from './projectCameraPoint.js';
-
-/**
- * Convert a layer point to container coordinates, accounting for terrain elevation and camera animation.
- *
- * @param {L.Map} map Map containing the point.
- * @param {L.Point} point Layer point to project.
- * @param {L.LatLng} [location] Geographic position used to sample elevation.
- *
- * @returns {L.Point} Display position relative to the map pane.
- */
-export function displayPoint(map, point, location) {
-  const shared = renderers.get(map), origin = shared && sceneOriginByLayer.get(shared);
-  if (!streamTerrainByMap.get(map) || !origin) {
-    return map.layerPointToContainerPoint(point).subtract(map._getMapPanePos());
-  }
-  const elevation = mapElevationOf(map, location || map.layerPointToLatLng(point)) ?? 0;
-  const center = mapElevationOf(map, map.getCenter()) ?? 0;
-  const zoom = cameraViewByMap.get(map)?.zoom ?? map.getZoom();
-  const height = (elevation - center) * map.options.crs.scale(zoom) / (earthCirc * Math.cos(origin.lat * radians));
-  const raw = animationPoint(map, mapMethods.value.layerPointToContainerPoint.call(map, point));
-  return project(map, raw, false, false, height).subtract(map._getMapPanePos());
-}
+import { streamTerrainByMap } from '../weakmaps/streamTerrainByMap.js';
+import { renderers } from '../weakmaps/renderers.js';
+import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+import { mapMethods } from '../globals/mapMethods.js';
+import { radians } from '../globals/radians.js';
+import { earthCirc } from '../globals/earthCirc.js';
+import { mapElevationOf } from '../terrain/mapElevationOf.js';
+import { animationPoint } from './transformZoomAnimationPoint.js';
+import { project } from './projectCameraPoint.js';
+
+/**
+ * Convert a layer point to container coordinates, accounting for terrain elevation and camera animation.
+ *
+ * @param {L.Map} map Map containing the point.
+ * @param {L.Point} point Layer point to project.
+ * @param {L.LatLng} [location] Geographic position used to sample elevation.
+ *
+ * @returns {L.Point} Display position relative to the map pane.
+ */
+export function displayPoint(map, point, location) {
+  const shared = renderers.get(map), origin = shared && sceneOriginByLayer.get(shared);
+  if (!streamTerrainByMap.get(map) || !origin) {
+    return map.layerPointToContainerPoint(point).subtract(map._getMapPanePos());
+  }
+  const elevation = mapElevationOf(map, location || map.layerPointToLatLng(point)) ?? 0;
+  const center = mapElevationOf(map, map.getCenter()) ?? 0;
+  const zoom = cameraViewByMap.get(map)?.zoom ?? map.getZoom();
+  const height = (elevation - center) * map.options.crs.scale(zoom) / (earthCirc * Math.cos(origin.lat * radians));
+  const raw = animationPoint(map, mapMethods.value.layerPointToContainerPoint.call(map, point));
+  return project(map, raw, false, false, height).subtract(map._getMapPanePos());
+}

package/src/projections/projectBridgePoint.js

@@ -1,17 +1,17 @@
-import { L } from '../globals/L.js';
-
-/**
- * Project a geographic bridge point and its elevation into local scene coordinates.
- *
- * @param {number[]} coordinates Longitude, latitude and elevation.
- * @param {Object} crs Coordinate reference system.
- * @param {L.Point} origin Projected scene origin.
- * @param {number} metres Projection scale to local metres.
- * @param {number} base Scene base elevation.
- *
- * @returns {number[]} Local coordinates as [x, y, z].
- */
-export function local([lng, lat, z], crs, origin, metres, base) {
-  const p = crs.project(/* alloc */ new L.LatLng(lat, lng));
-  return /* alloc */ [(p.x - origin.x) * metres, z - base, -(p.y - origin.y) * metres];
-}
+import { L } from '../globals/L.js';
+
+/**
+ * Project a geographic bridge point and its elevation into local scene coordinates.
+ *
+ * @param {number[]} coordinates Longitude, latitude and elevation.
+ * @param {Object} crs Coordinate reference system.
+ * @param {L.Point} origin Projected scene origin.
+ * @param {number} metres Projection scale to local metres.
+ * @param {number} base Scene base elevation.
+ *
+ * @returns {number[]} Local coordinates as [x, y, z].
+ */
+export function local([lng, lat, z], crs, origin, metres, base) {
+  const p = crs.project(/* alloc */ new L.LatLng(lat, lng));
+  return /* alloc */ [(p.x - origin.x) * metres, z - base, -(p.y - origin.y) * metres];
+}

package/src/projections/toPoint.js

@@ -1,13 +1,13 @@
-import { L } from '../globals/L.js';
-
-/**
- * Copy an array or point-like object into a Leaflet point.
- *
- * @param {number[]|Object} point Array or object with x and y coordinates.
- *
- * @returns {L.Point} New point.
- */
-export function pointOf(point) {
-  return /* alloc */ new L.Point(
-    Array.isArray(point) ? point[0] : point.x, Array.isArray(point) ? point[1] : point.y);
-}
+import { L } from '../globals/L.js';
+
+/**
+ * Copy an array or point-like object into a Leaflet point.
+ *
+ * @param {number[]|Object} point Array or object with x and y coordinates.
+ *
+ * @returns {L.Point} New point.
+ */
+export function pointOf(point) {
+  return /* alloc */ new L.Point(
+    Array.isArray(point) ? point[0] : point.x, Array.isArray(point) ? point[1] : point.y);
+}

package/src/projections/transformZoomAnimationPoint.js

@@ -1,5 +1,5 @@
-import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
-
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+
 /**
  * Apply or invert the current camera zoom-animation transform to a container point.
  *
@@ -10,10 +10,10 @@ import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
  * @returns {L.Point} Transformed point, or the input when no animation view exists.
  */
 export function animationPoint(map, point, inverse = false) {
-  const view = cameraViewByMap.get(map);
-  if (!view) return point;
-  const half = map.getSize().divideBy(2), scale = map.getZoomScale(view.zoom);
-  const shift = map.project(map.getCenter(), view.zoom).subtract(map.project(view.center, view.zoom));
-  return inverse ? point.subtract(half).subtract(shift).divideBy(scale).add(half) :
-    point.subtract(half).multiplyBy(scale).add(shift).add(half);
+  const view = cameraViewByMap.get(map);
+  if (!view) return point;
+  const half = map.getSize().divideBy(2), scale = map.getZoomScale(view.zoom);
+  const shift = map.project(map.getCenter(), view.zoom).subtract(map.project(view.center, view.zoom));
+  return inverse ? point.subtract(half).subtract(shift).divideBy(scale).add(half) :
+    point.subtract(half).multiplyBy(scale).add(shift).add(half);
 }

package/src/projections/verticalGroundY.js

@@ -1,15 +1,15 @@
-/**
- * Invert the vertical camera projection onto the ground, clamping at the far distance.
- *
- * @param {number} y Vertical camera coordinate.
- * @param {number} tilt Cosine of camera pitch.
- * @param {number} distance Camera distance.
- * @param {number} rise Sine of camera pitch.
- * @param {number} far Maximum ground distance.
- *
- * @returns {number} Clamped ground coordinate.
- */
-export function verticalGroundY(y, tilt, distance, rise, far) {
-  return tilt * distance + rise * y > 0
-    ? Math.max(-far, Math.min(far, y * distance / (tilt * distance + rise * y))) : -far;
+/**
+ * Invert the vertical camera projection onto the ground, clamping at the far distance.
+ *
+ * @param {number} y Vertical camera coordinate.
+ * @param {number} tilt Cosine of camera pitch.
+ * @param {number} distance Camera distance.
+ * @param {number} rise Sine of camera pitch.
+ * @param {number} far Maximum ground distance.
+ *
+ * @returns {number} Clamped ground coordinate.
+ */
+export function verticalGroundY(y, tilt, distance, rise, far) {
+  return tilt * distance + rise * y > 0
+    ? Math.max(-far, Math.min(far, y * distance / (tilt * distance + rise * y))) : -far;
 }

package/src/raster/rasterTileRange.js

@@ -1,32 +1,32 @@
-import { TILE_SIZE } from '../globals/TILE_SIZE.js';
-import { TILE_RADIUS } from '../globals/TILE_RADIUS.js';
-import { archiveNorthWest } from '../globals/archiveNorthWest.js';
-import { archiveSouthEast } from '../globals/archiveSouthEast.js';
-
-/**
- * Compute the visible tile range, clipped to archive bounds and the center tile radius.
- *
- * @param {L.Map} map Map providing the view bounds and projection.
- * @param {Object} header Archive header with optional geographic bounds.
- * @param {number} zoom Tile zoom level.
- *
- * @returns {Object} Inclusive minimum and maximum tile coordinates.
- */
-export function rasterTileRange(map, header, zoom) {
-  const bounds = map.getBounds();
-  const northwest = map.project(bounds.getNorthWest(), zoom).divideBy(TILE_SIZE).floor();
-  const southeast = map.project(bounds.getSouthEast(), zoom).divideBy(TILE_SIZE).floor();
-  archiveNorthWest[0] = header.maxLat; archiveNorthWest[1] = header.minLon;
-  archiveSouthEast[0] = header.minLat; archiveSouthEast[1] = header.maxLon;
-  const archiveMin = header.maxLat === undefined || header.minLon === undefined
-    ? null : map.project(archiveNorthWest, zoom).divideBy(TILE_SIZE).floor();
-  const archiveMax = header.minLat === undefined || header.maxLon === undefined
-    ? null : map.project(archiveSouthEast, zoom).divideBy(TILE_SIZE).floor();
-  const center = map.project(map.getCenter(), zoom).divideBy(TILE_SIZE).floor();
-  return /* alloc */ {
-    minX: Math.max(0, northwest.x, archiveMin?.x ?? 0, center.x - TILE_RADIUS),
-    maxX: Math.min(2 ** zoom - 1, southeast.x, archiveMax?.x ?? 2 ** zoom - 1, center.x + TILE_RADIUS),
-    minY: Math.max(0, northwest.y, archiveMin?.y ?? 0, center.y - TILE_RADIUS),
-    maxY: Math.min(2 ** zoom - 1, southeast.y, archiveMax?.y ?? 2 ** zoom - 1, center.y + TILE_RADIUS),
-  };
-}
+import { TILE_SIZE } from '../globals/TILE_SIZE.js';
+import { TILE_RADIUS } from '../globals/TILE_RADIUS.js';
+import { archiveNorthWest } from '../globals/archiveNorthWest.js';
+import { archiveSouthEast } from '../globals/archiveSouthEast.js';
+
+/**
+ * Compute the visible tile range, clipped to archive bounds and the center tile radius.
+ *
+ * @param {L.Map} map Map providing the view bounds and projection.
+ * @param {Object} header Archive header with optional geographic bounds.
+ * @param {number} zoom Tile zoom level.
+ *
+ * @returns {Object} Inclusive minimum and maximum tile coordinates.
+ */
+export function rasterTileRange(map, header, zoom) {
+  const bounds = map.getBounds();
+  const northwest = map.project(bounds.getNorthWest(), zoom).divideBy(TILE_SIZE).floor();
+  const southeast = map.project(bounds.getSouthEast(), zoom).divideBy(TILE_SIZE).floor();
+  archiveNorthWest[0] = header.maxLat; archiveNorthWest[1] = header.minLon;
+  archiveSouthEast[0] = header.minLat; archiveSouthEast[1] = header.maxLon;
+  const archiveMin = header.maxLat === undefined || header.minLon === undefined
+    ? null : map.project(archiveNorthWest, zoom).divideBy(TILE_SIZE).floor();
+  const archiveMax = header.minLat === undefined || header.maxLon === undefined
+    ? null : map.project(archiveSouthEast, zoom).divideBy(TILE_SIZE).floor();
+  const center = map.project(map.getCenter(), zoom).divideBy(TILE_SIZE).floor();
+  return /* alloc */ {
+    minX: Math.max(0, northwest.x, archiveMin?.x ?? 0, center.x - TILE_RADIUS),
+    maxX: Math.min(2 ** zoom - 1, southeast.x, archiveMax?.x ?? 2 ** zoom - 1, center.x + TILE_RADIUS),
+    minY: Math.max(0, northwest.y, archiveMin?.y ?? 0, center.y - TILE_RADIUS),
+    maxY: Math.min(2 ** zoom - 1, southeast.y, archiveMax?.y ?? 2 ** zoom - 1, center.y + TILE_RADIUS),
+  };
+}

package/src/raster/retainRasterTiles.js

@@ -1,21 +1,21 @@
-import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
-import { releaseRasterTile } from './releaseRasterTile.js';
-
-/**
- * Cancel unneeded unfinished tiles and create state for missing required tiles.
- *
- * @param {L.Layer} layer Raster layer.
- * @param {Map<string, Object>} required Required tile coordinates by key.
- */
-export function retainRasterTiles(layer, required) {
-  const tiles = rasterTilesByLayer.get(layer);
-  let key, tile, coords;
-  for ([key, tile] of tiles) {
-    if (!required.has(key) && !tile.done) releaseRasterTile(layer, tile);
-  }
-  for ([key, coords] of required) {
-    if (tiles.has(key)) continue;
-    tile = /* alloc */ { coords, request: /* alloc */ new AbortController(), done: false };
-    tiles.set(key, tile);
-  }
-}
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { releaseRasterTile } from './releaseRasterTile.js';
+
+/**
+ * Cancel unneeded unfinished tiles and create state for missing required tiles.
+ *
+ * @param {L.Layer} layer Raster layer.
+ * @param {Map<string, Object>} required Required tile coordinates by key.
+ */
+export function retainRasterTiles(layer, required) {
+  const tiles = rasterTilesByLayer.get(layer);
+  let key, tile, coords;
+  for ([key, tile] of tiles) {
+    if (!required.has(key) && !tile.done) releaseRasterTile(layer, tile);
+  }
+  for ([key, coords] of required) {
+    if (tiles.has(key)) continue;
+    tile = /* alloc */ { coords, request: /* alloc */ new AbortController(), done: false };
+    tiles.set(key, tile);
+  }
+}

package/src/rendering/collectVisibleMesh.js

@@ -1,48 +1,48 @@
-import { computeBounds } from '../geometry/computeBounds.js';
-import { nativeStrokeExpansion } from './nativeStrokeExpansion.js';
-
-/**
- * Cull a mesh against the camera frustum and append it when visible.
- *
- * @param {Object} mesh Mesh whose world-space bounding sphere is tested.
- * @param {ArrayLike<number>} projection Camera projection-view matrix.
- * @param {Array} frustum Camera frustum planes.
- * @param {ArrayLike<number>} frustumLengths Lengths of the plane normals.
- * @param {Array<Object>} candidates Destination for visible meshes.
- */
-export function collectVisibleMesh(mesh, projection, frustum, frustumLengths, candidates) {
-  if (!mesh.geometry.bounds) computeBounds(mesh.geometry);
-  const bounds = mesh.geometry.bounds;
-  const world = mesh.worldMatrix;
-  let sphere = mesh._cullingSphere;
-  if (!sphere || sphere.bounds !== bounds || sphere.matrix !== world ||
-      sphere.version !== mesh._worldMatrixVersion || mesh._worldMatrixVersion === undefined) {
-    sphere ||= mesh._cullingSphere = /* alloc */ {};
-    const center = bounds.center;
-    sphere.x = world[0] * center[0] + world[4] * center[1] + world[8] * center[2] + world[12];
-    sphere.y = world[1] * center[0] + world[5] * center[1] + world[9] * center[2] + world[13];
-    sphere.z = world[2] * center[0] + world[6] * center[1] + world[10] * center[2] + world[14];
-    sphere.scale = Math.max(
-      Math.hypot(world[0], world[1], world[2]),
-      Math.hypot(world[4], world[5], world[6]),
-      Math.hypot(world[8], world[9], world[10])
-    );
-    sphere.radius = bounds.radius * sphere.scale;
-    sphere.bounds = bounds;
-    sphere.matrix = world;
-    sphere.version = mesh._worldMatrixVersion;
-  }
-  const { x, y, z } = sphere;
-  const radius = sphere.radius + nativeStrokeExpansion(mesh) * sphere.scale;
-  const clipZ = projection[2] * x + projection[6] * y + projection[10] * z + projection[14];
-  const clipW = projection[3] * x + projection[7] * y + projection[11] * z + projection[15];
-  mesh._sortDepth = clipZ / clipW;
-  mesh._visibleInFrame =
-    frustum[0][0] * x + frustum[0][1] * y + frustum[0][2] * z + frustum[0][3] >= -radius * frustumLengths[0] &&
-    frustum[1][0] * x + frustum[1][1] * y + frustum[1][2] * z + frustum[1][3] >= -radius * frustumLengths[1] &&
-    frustum[2][0] * x + frustum[2][1] * y + frustum[2][2] * z + frustum[2][3] >= -radius * frustumLengths[2] &&
-    frustum[3][0] * x + frustum[3][1] * y + frustum[3][2] * z + frustum[3][3] >= -radius * frustumLengths[3] &&
-    frustum[4][0] * x + frustum[4][1] * y + frustum[4][2] * z + frustum[4][3] >= -radius * frustumLengths[4] &&
-    frustum[5][0] * x + frustum[5][1] * y + frustum[5][2] * z + frustum[5][3] >= -radius * frustumLengths[5];
-  if (mesh._visibleInFrame) candidates.push(mesh);
-}
+import { computeBounds } from '../geometry/computeBounds.js';
+import { nativeStrokeExpansion } from './nativeStrokeExpansion.js';
+
+/**
+ * Cull a mesh against the camera frustum and append it when visible.
+ *
+ * @param {Object} mesh Mesh whose world-space bounding sphere is tested.
+ * @param {ArrayLike<number>} projection Camera projection-view matrix.
+ * @param {Array} frustum Camera frustum planes.
+ * @param {ArrayLike<number>} frustumLengths Lengths of the plane normals.
+ * @param {Array<Object>} candidates Destination for visible meshes.
+ */
+export function collectVisibleMesh(mesh, projection, frustum, frustumLengths, candidates) {
+  if (!mesh.geometry.bounds) computeBounds(mesh.geometry);
+  const bounds = mesh.geometry.bounds;
+  const world = mesh.worldMatrix;
+  let sphere = mesh._cullingSphere;
+  if (!sphere || sphere.bounds !== bounds || sphere.matrix !== world ||
+      sphere.version !== mesh._worldMatrixVersion || mesh._worldMatrixVersion === undefined) {
+    sphere ||= mesh._cullingSphere = /* alloc */ {};
+    const center = bounds.center;
+    sphere.x = world[0] * center[0] + world[4] * center[1] + world[8] * center[2] + world[12];
+    sphere.y = world[1] * center[0] + world[5] * center[1] + world[9] * center[2] + world[13];
+    sphere.z = world[2] * center[0] + world[6] * center[1] + world[10] * center[2] + world[14];
+    sphere.scale = Math.max(
+      Math.hypot(world[0], world[1], world[2]),
+      Math.hypot(world[4], world[5], world[6]),
+      Math.hypot(world[8], world[9], world[10])
+    );
+    sphere.radius = bounds.radius * sphere.scale;
+    sphere.bounds = bounds;
+    sphere.matrix = world;
+    sphere.version = mesh._worldMatrixVersion;
+  }
+  const { x, y, z } = sphere;
+  const radius = sphere.radius + nativeStrokeExpansion(mesh) * sphere.scale;
+  const clipZ = projection[2] * x + projection[6] * y + projection[10] * z + projection[14];
+  const clipW = projection[3] * x + projection[7] * y + projection[11] * z + projection[15];
+  mesh._sortDepth = clipZ / clipW;
+  mesh._visibleInFrame =
+    frustum[0][0] * x + frustum[0][1] * y + frustum[0][2] * z + frustum[0][3] >= -radius * frustumLengths[0] &&
+    frustum[1][0] * x + frustum[1][1] * y + frustum[1][2] * z + frustum[1][3] >= -radius * frustumLengths[1] &&
+    frustum[2][0] * x + frustum[2][1] * y + frustum[2][2] * z + frustum[2][3] >= -radius * frustumLengths[2] &&
+    frustum[3][0] * x + frustum[3][1] * y + frustum[3][2] * z + frustum[3][3] >= -radius * frustumLengths[3] &&
+    frustum[4][0] * x + frustum[4][1] * y + frustum[4][2] * z + frustum[4][3] >= -radius * frustumLengths[4] &&
+    frustum[5][0] * x + frustum[5][1] * y + frustum[5][2] * z + frustum[5][3] >= -radius * frustumLengths[5];
+  if (mesh._visibleInFrame) candidates.push(mesh);
+}

package/src/rendering/compareMeshDepth.js

@@ -1,14 +1,14 @@
-/**
- * Order opaque meshes front-to-back and transparent meshes by render order and depth.
- *
- * @param {Object} a First mesh.
- * @param {Object} b Second mesh.
- *
- * @returns {number} Sort comparison, breaking ties by mesh ID.
- */
-export function compareMeshDepth(a, b) {
-  return a.program.transparent
-    ? (a.renderOrder || 0) - (b.renderOrder || 0) ||
-      b._sortDepth - a._sortDepth || a.id - b.id
-    : (a._sortDepth ?? 0) - (b._sortDepth ?? 0) || a.id - b.id;
-}
+/**
+ * Order opaque meshes front-to-back and transparent meshes by render order and depth.
+ *
+ * @param {Object} a First mesh.
+ * @param {Object} b Second mesh.
+ *
+ * @returns {number} Sort comparison, breaking ties by mesh ID.
+ */
+export function compareMeshDepth(a, b) {
+  return a.program.transparent
+    ? (a.renderOrder || 0) - (b.renderOrder || 0) ||
+      b._sortDepth - a._sortDepth || a.id - b.id
+    : (a._sortDepth ?? 0) - (b._sortDepth ?? 0) || a.id - b.id;
+}