@math.gl/culling 4.1.0 → 4.2.0-alpha.5

package/dist/index.cjs

@@ -17,14 +17,20 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
+var index_exports = {};
+__export(index_exports, {
   AxisAlignedBoundingBox: () => AxisAlignedBoundingBox,
   BoundingSphere: () => BoundingSphere,
+  BoxShape: () => BoxShape,
+  CapsuleShape: () => CapsuleShape,
   CullingVolume: () => CullingVolume,
+  CylinderShape: () => CylinderShape,
   INTERSECTION: () => INTERSECTION,
   OrientedBoundingBox: () => OrientedBoundingBox,
   Plane: () => Plane,
+  PlaneShape: () => PlaneShape,
+  Ray: () => Ray,
+  SphereShape: () => SphereShape,
   _PerspectiveFrustum: () => PerspectiveFrustum,
   _PerspectiveOffCenterFrustum: () => PerspectiveOffCenterFrustum,
   computeEigenDecomposition: () => computeEigenDecomposition,
@@ -32,7 +38,7 @@ __export(dist_exports, {
   makeBoundingSphereFromPoints: () => makeBoundingSphereFromPoints,
   makeOrientedBoundingBoxFromPoints: () => makeOrientedBoundingBoxFromPoints
 });
-module.exports = __toCommonJS(dist_exports);
+module.exports = __toCommonJS(index_exports);
 
 // dist/constants.js
 var INTERSECTION = {
@@ -48,7 +54,7 @@ var INTERSECTION = {
 var import_core = require("@math.gl/core");
 var scratchVector = new import_core.Vector3();
 var scratchNormal = new import_core.Vector3();
-var AxisAlignedBoundingBox = class {
+var AxisAlignedBoundingBox = class _AxisAlignedBoundingBox {
   /**
    * Creates an instance of an AxisAlignedBoundingBox from the minimum and maximum points along the x, y, and z axes.
    * @param minimum=[0, 0, 0] The minimum point along the x, y, and z axes.
@@ -68,7 +74,7 @@ var AxisAlignedBoundingBox = class {
    * @returns {AxisAlignedBoundingBox} A new AxisAlignedBoundingBox instance.
    */
   clone() {
-    return new AxisAlignedBoundingBox(this.minimum, this.maximum, this.center);
+    return new _AxisAlignedBoundingBox(this.minimum, this.maximum, this.center);
   }
   /**
    * Compares the provided AxisAlignedBoundingBox componentwise and returns
@@ -138,7 +144,7 @@ var AxisAlignedBoundingBox = class {
 var import_core2 = require("@math.gl/core");
 var scratchVector2 = new import_core2.Vector3();
 var scratchVector22 = new import_core2.Vector3();
-var BoundingSphere = class {
+var BoundingSphere = class _BoundingSphere {
   /** Creates a bounding sphere */
   constructor(center = [0, 0, 0], radius = 0) {
     this.radius = -0;
@@ -167,7 +173,7 @@ var BoundingSphere = class {
   }
   /** Duplicates a BoundingSphere instance. */
   clone() {
-    return new BoundingSphere(this.center, this.radius);
+    return new _BoundingSphere(this.center, this.radius);
   }
   /** Computes a bounding sphere that contains both the left and right bounding spheres. */
   union(boundingSphere) {
@@ -258,7 +264,7 @@ var MATRIX3 = {
   COLUMN2ROW1: 7,
   COLUMN2ROW2: 8
 };
-var OrientedBoundingBox = class {
+var OrientedBoundingBox = class _OrientedBoundingBox {
   constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
     this.center = new import_core3.Vector3().from(center);
     this.halfAxes = new import_core3.Matrix3(halfAxes);
@@ -301,7 +307,7 @@ var OrientedBoundingBox = class {
   }
   /** Duplicates a OrientedBoundingBox instance. */
   clone() {
-    return new OrientedBoundingBox(this.center, this.halfAxes);
+    return new _OrientedBoundingBox(this.center, this.halfAxes);
   }
   /** Compares the provided OrientedBoundingBox component wise and returns */
   equals(right) {
@@ -467,7 +473,7 @@ var import_core5 = require("@math.gl/core");
 var import_core4 = require("@math.gl/core");
 var scratchPosition = new import_core4.Vector3();
 var scratchNormal2 = new import_core4.Vector3();
-var Plane = class {
+var Plane = class _Plane {
   constructor(normal = [0, 0, 1], distance = 0) {
     this.normal = new import_core4.Vector3();
     this.distance = -0;
@@ -497,7 +503,7 @@ var Plane = class {
   }
   /** Duplicates a Plane instance. */
   clone() {
-    return new Plane(this.normal, this.distance);
+    return new _Plane(this.normal, this.distance);
   }
   /** Compares the provided Planes by normal and distance */
   equals(right) {
@@ -521,13 +527,34 @@ var Plane = class {
     const scaledNormal = scratchNormal2.copy(this.normal).scale(pointDistance);
     return scratchPoint.subtract(scaledNormal).to(result);
   }
+  /**
+   * Computes the intersection of a ray and this plane.
+   *
+   * @param {Ray} ray The ray.
+   * @param {Vector3} [result] The object onto which to store the result.
+   * @returns {Vector3} The intersection point or undefined if there is no intersection.
+   */
+  intersectWithRay(ray, result = new import_core4.Vector3()) {
+    const origin = ray.origin;
+    const direction = ray.direction;
+    const normal = this.normal;
+    const denominator = normal.dot(direction);
+    if (Math.abs(denominator) < import_core4._MathUtils.EPSILON15) {
+      return void 0;
+    }
+    const t = (-this.distance - normal.dot(origin)) / denominator;
+    if (t < 0) {
+      return void 0;
+    }
+    return result.copy(direction).multiplyByScalar(t).add(origin);
+  }
 };
 
 // dist/lib/culling-volume.js
 var faces = [new import_core5.Vector3([1, 0, 0]), new import_core5.Vector3([0, 1, 0]), new import_core5.Vector3([0, 0, 1])];
 var scratchPlaneCenter = new import_core5.Vector3();
 var scratchPlaneNormal = new import_core5.Vector3();
-var CullingVolume = class {
+var CullingVolume = class _CullingVolume {
   /**
    * Create a new `CullingVolume` bounded by an array of clipping planed
    * @param planes Array of clipping planes.
@@ -588,10 +615,10 @@ var CullingVolume = class {
    */
   computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) {
     (0, import_core5.assert)(Number.isFinite(parentPlaneMask), "parentPlaneMask is required.");
-    if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {
+    if (parentPlaneMask === _CullingVolume.MASK_OUTSIDE || parentPlaneMask === _CullingVolume.MASK_INSIDE) {
       return parentPlaneMask;
     }
-    let mask = CullingVolume.MASK_INSIDE;
+    let mask = _CullingVolume.MASK_INSIDE;
     const planes = this.planes;
     for (let k = 0; k < this.planes.length; ++k) {
       const flag = k < 31 ? 1 << k : 0;
@@ -601,7 +628,7 @@ var CullingVolume = class {
       const plane = planes[k];
       const result = boundingVolume.intersectPlane(plane);
       if (result === INTERSECTION.OUTSIDE) {
-        return CullingVolume.MASK_OUTSIDE;
+        return _CullingVolume.MASK_OUTSIDE;
       } else if (result === INTERSECTION.INTERSECTING) {
         mask |= flag;
       }
@@ -613,14 +640,564 @@ CullingVolume.MASK_OUTSIDE = 4294967295;
 CullingVolume.MASK_INSIDE = 0;
 CullingVolume.MASK_INDETERMINATE = 2147483647;
 
-// dist/lib/perspective-off-center-frustum.js
+// dist/lib/ray.js
 var import_core6 = require("@math.gl/core");
-var scratchPlaneUpVector = new import_core6.Vector3();
-var scratchPlaneRightVector = new import_core6.Vector3();
-var scratchPlaneNearCenter = new import_core6.Vector3();
-var scratchPlaneFarCenter = new import_core6.Vector3();
-var scratchPlaneNormal2 = new import_core6.Vector3();
-var PerspectiveOffCenterFrustum = class {
+var Ray = class {
+  /**
+   * Creates a new ray that extends infinitely from the provided origin in the provided direction.
+   *
+   * @param [origin=Vector3] The origin of the ray.
+   * @param [direction=Vector3] The direction of the ray.
+   */
+  constructor(origin, direction) {
+    if (origin)
+      origin = origin.clone();
+    else
+      origin = new import_core6.Vector3();
+    if (direction)
+      direction = direction.clone().normalize();
+    else
+      direction = new import_core6.Vector3();
+    this.origin = origin;
+    this.direction = direction;
+  }
+};
+
+// dist/lib/shapes/implicit-shape.js
+var import_core7 = require("@math.gl/core");
+var ImplicitShapeBase = class {
+  constructor(matrix) {
+    this.matrix = new import_core7.Matrix4();
+    if (matrix)
+      this.matrix.copy(matrix);
+    validateAffineMatrix(this.matrix);
+    this.inverseMatrix = this.matrix.clone().invert();
+  }
+  equals(shape) {
+    if (this.type !== shape.type)
+      return false;
+    for (let i = 0; i < 16; i++)
+      if (this.matrix[i] !== shape.matrix[i])
+        return false;
+    return true;
+  }
+  transform(transform) {
+    const next = new import_core7.Matrix4().copy(transform);
+    validateAffineMatrix(next);
+    this.matrix.multiplyLeft(next);
+    validateAffineMatrix(this.matrix);
+    this.inverseMatrix.copy(this.matrix).invert();
+    return this;
+  }
+  containsPoint(point) {
+    return this.containsLocalPoint(this.inverseMatrix.transformAsPoint(point));
+  }
+  distanceSquaredTo(point) {
+    const distance = this.distanceTo(point);
+    return distance * distance;
+  }
+  /** Exact for rigid/uniform transforms; conservative estimate for non-uniform scale or shear. */
+  distanceTo(point) {
+    const localPoint = this.inverseMatrix.transformAsPoint(point);
+    const localDistance = this.distanceToLocalPoint(localPoint);
+    const scales = this.matrix.getScale();
+    return localDistance * Math.min(scales[0], scales[1], scales[2]);
+  }
+  intersectPlane(plane) {
+    const maximum = this.getSupportPoint(plane.normal);
+    const minimum = this.getSupportPoint([-plane.normal[0], -plane.normal[1], -plane.normal[2]]);
+    const maxDistance = plane.getPointDistance(maximum);
+    const minDistance = plane.getPointDistance(minimum);
+    if (minDistance > 0)
+      return INTERSECTION.INSIDE;
+    if (maxDistance < 0)
+      return INTERSECTION.OUTSIDE;
+    return INTERSECTION.INTERSECTING;
+  }
+  intersectRay(ray) {
+    const localOrigin = this.inverseMatrix.transformAsPoint(ray.origin);
+    const localDirection = this.inverseMatrix.transformAsVector(ray.direction);
+    const hit = this.intersectLocalRay(localOrigin, localDirection);
+    if (!hit || hit.distance < 0)
+      return void 0;
+    const point = new import_core7.Vector3(ray.direction).scale(hit.distance).add(ray.origin);
+    const inverse = this.inverseMatrix;
+    const normal = new import_core7.Vector3(inverse[0] * hit.normal[0] + inverse[1] * hit.normal[1] + inverse[2] * hit.normal[2], inverse[4] * hit.normal[0] + inverse[5] * hit.normal[1] + inverse[6] * hit.normal[2], inverse[8] * hit.normal[0] + inverse[9] * hit.normal[1] + inverse[10] * hit.normal[2]).normalize();
+    return { distance: hit.distance, point, normal, entering: ray.direction.dot(normal) < 0 };
+  }
+  getAxisAlignedBoundingBox() {
+    const minimum = new import_core7.Vector3();
+    const maximum = new import_core7.Vector3();
+    for (let axis = 0; axis < 3; axis++) {
+      const direction = [0, 0, 0];
+      direction[axis] = 1;
+      maximum[axis] = this.getSupportPoint(direction)[axis];
+      direction[axis] = -1;
+      minimum[axis] = this.getSupportPoint(direction)[axis];
+    }
+    return new AxisAlignedBoundingBox(minimum, maximum);
+  }
+  getBoundingSphere() {
+    const box = this.getAxisAlignedBoundingBox();
+    if (!box)
+      return void 0;
+    return new BoundingSphere().fromCornerPoints(box.minimum, box.maximum);
+  }
+  getSupportPoint(worldDirection) {
+    const matrix = this.matrix;
+    const localDirection = [
+      matrix[0] * worldDirection[0] + matrix[1] * worldDirection[1] + matrix[2] * worldDirection[2],
+      matrix[4] * worldDirection[0] + matrix[5] * worldDirection[1] + matrix[6] * worldDirection[2],
+      matrix[8] * worldDirection[0] + matrix[9] * worldDirection[1] + matrix[10] * worldDirection[2]
+    ];
+    return new import_core7.Vector3(this.supportLocal(localDirection)).transform(this.matrix);
+  }
+};
+function validateAffineMatrix(matrix) {
+  if (matrix.length !== 16 || matrix.some((value) => !Number.isFinite(value))) {
+    throw new Error("Shape matrix must contain 16 finite values");
+  }
+  if (Math.abs(matrix[3]) > 1e-12 || Math.abs(matrix[7]) > 1e-12 || Math.abs(matrix[11]) > 1e-12 || Math.abs(matrix[15] - 1) > 1e-12) {
+    throw new Error("Shape matrix must be affine");
+  }
+  if (Math.abs(new import_core7.Matrix4().copy(matrix).determinant()) < 1e-15)
+    throw new Error("Shape matrix must be invertible");
+}
+function solveQuadratic(a, b, c) {
+  if (Math.abs(a) < 1e-15)
+    return Math.abs(b) < 1e-15 ? [] : [-c / b];
+  const discriminant = b * b - 4 * a * c;
+  if (discriminant < 0)
+    return [];
+  const root = Math.sqrt(Math.max(0, discriminant));
+  return [(-b - root) / (2 * a), (-b + root) / (2 * a)].sort((left, right) => left - right);
+}
+function closestDistanceToSegment2D(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const denominator = dx * dx + dy * dy;
+  const t = denominator ? Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / denominator)) : 0;
+  return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+}
+function closestDistanceToCircleArc2D(px, py, centerY, radius, minimumNormalY, maximumNormalY) {
+  if (radius === 0)
+    return Math.hypot(px, py - centerY);
+  const dx = px;
+  const dy = py - centerY;
+  const length = Math.hypot(dx, dy);
+  const normalY = length ? dy / length : 0;
+  if (normalY >= minimumNormalY && normalY <= maximumNormalY) {
+    return Math.abs(length - radius);
+  }
+  const minimumRadius = radius * Math.sqrt(Math.max(0, 1 - minimumNormalY ** 2));
+  const maximumRadius = radius * Math.sqrt(Math.max(0, 1 - maximumNormalY ** 2));
+  return Math.min(Math.hypot(px - minimumRadius, py - (centerY + radius * minimumNormalY)), Math.hypot(px - maximumRadius, py - (centerY + radius * maximumNormalY)));
+}
+
+// dist/lib/shapes/box-shape.js
+var EPSILON = 1e-6;
+var BoxShape = class _BoxShape extends ImplicitShapeBase {
+  constructor(props = {}) {
+    super(props.matrix);
+    this.type = "box";
+    this.size = props.size ? [...props.size] : [1, 1, 1];
+    if (this.size.some((value) => !Number.isFinite(value) || value <= 0))
+      throw new Error("Box size values must be greater than zero");
+    this.halfSize = [this.size[0] / 2, this.size[1] / 2, this.size[2] / 2];
+  }
+  clone() {
+    return new _BoxShape({ size: this.size, matrix: this.matrix });
+  }
+  equals(shape) {
+    return shape instanceof _BoxShape && super.equals(shape) && this.size.every((value, i) => value === shape.size[i]);
+  }
+  containsLocalPoint(point) {
+    return point.every((value, i) => Math.abs(value) <= this.halfSize[i] + EPSILON);
+  }
+  distanceToLocalPoint(point) {
+    return Math.hypot(...point.map((value, i) => Math.max(0, Math.abs(value) - this.halfSize[i])));
+  }
+  supportLocal(direction) {
+    return direction.map((value, i) => value < 0 ? -this.halfSize[i] : this.halfSize[i]);
+  }
+  intersectLocalRay(origin, direction) {
+    let near = -Infinity;
+    let far = Infinity;
+    let nearAxis = 0;
+    let farAxis = 0;
+    for (let axis2 = 0; axis2 < 3; axis2++) {
+      if (Math.abs(direction[axis2]) < 1e-15) {
+        if (Math.abs(origin[axis2]) > this.halfSize[axis2])
+          return void 0;
+        continue;
+      }
+      let t1 = (-this.halfSize[axis2] - origin[axis2]) / direction[axis2];
+      let t2 = (this.halfSize[axis2] - origin[axis2]) / direction[axis2];
+      if (t1 > t2)
+        [t1, t2] = [t2, t1];
+      if (t1 > near) {
+        near = t1;
+        nearAxis = axis2;
+      }
+      if (t2 < far) {
+        far = t2;
+        farAxis = axis2;
+      }
+      if (near > far)
+        return void 0;
+    }
+    const distance = near >= 0 ? near : far;
+    if (distance < 0 || !Number.isFinite(distance))
+      return void 0;
+    const axis = near >= 0 ? nearAxis : farAxis;
+    const pointCoordinate = origin[axis] + distance * direction[axis];
+    const normal = [0, 0, 0];
+    normal[axis] = pointCoordinate < 0 ? -1 : 1;
+    return { distance, normal };
+  }
+};
+
+// dist/lib/shapes/capsule-shape.js
+var EPSILON2 = 1e-6;
+var CapsuleShape = class _CapsuleShape extends ImplicitShapeBase {
+  constructor(props = {}) {
+    super(props.matrix);
+    this.type = "capsule";
+    this.height = props.height ?? 1;
+    this.radiusBottom = props.radiusBottom ?? 0.5;
+    this.radiusTop = props.radiusTop ?? 0.5;
+    if (!Number.isFinite(this.height) || this.height <= 0)
+      throw new Error("Capsule height must be greater than zero");
+    if (![this.radiusBottom, this.radiusTop].every((value) => Number.isFinite(value) && value >= 0))
+      throw new Error("Capsule radii must be non-negative");
+    if (this.radiusBottom === 0 && this.radiusTop === 0)
+      throw new Error("At least one capsule radius must be greater than zero");
+  }
+  clone() {
+    return new _CapsuleShape({
+      height: this.height,
+      radiusBottom: this.radiusBottom,
+      radiusTop: this.radiusTop,
+      matrix: this.matrix
+    });
+  }
+  equals(shape) {
+    return shape instanceof _CapsuleShape && super.equals(shape) && this.height === shape.height && this.radiusBottom === shape.radiusBottom && this.radiusTop === shape.radiusTop;
+  }
+  containsLocalPoint(point) {
+    const profile = this.getProfile();
+    const radial = Math.hypot(point[0], point[2]);
+    if (profile.sphere)
+      return Math.hypot(radial, point[1] - profile.sphere.center) <= profile.sphere.radius + EPSILON2;
+    if (point[1] < profile.bottom.y)
+      return Math.hypot(radial, point[1] + this.height / 2) <= this.radiusBottom + EPSILON2;
+    if (point[1] > profile.top.y)
+      return Math.hypot(radial, point[1] - this.height / 2) <= this.radiusTop + EPSILON2;
+    const t = (point[1] - profile.bottom.y) / (profile.top.y - profile.bottom.y);
+    return radial <= profile.bottom.radius + (profile.top.radius - profile.bottom.radius) * t + EPSILON2;
+  }
+  distanceToLocalPoint(point) {
+    if (this.containsLocalPoint(point))
+      return 0;
+    const profile = this.getProfile();
+    const radial = Math.hypot(point[0], point[2]);
+    if (profile.sphere)
+      return Math.max(0, Math.hypot(radial, point[1] - profile.sphere.center) - profile.sphere.radius);
+    const delta = this.radiusTop - this.radiusBottom;
+    const sideNormalY = -delta / this.height;
+    const bottomArc = closestDistanceToCircleArc2D(radial, point[1], -this.height / 2, this.radiusBottom, -1, sideNormalY);
+    const topArc = closestDistanceToCircleArc2D(radial, point[1], this.height / 2, this.radiusTop, sideNormalY, 1);
+    const side = closestDistanceToSegment2D(radial, point[1], profile.bottom.radius, profile.bottom.y, profile.top.radius, profile.top.y);
+    return Math.min(bottomArc, topArc, side);
+  }
+  supportLocal(direction) {
+    const length = Math.hypot(...direction);
+    const unit = length ? direction.map((value) => value / length) : [1, 0, 0];
+    const bottom = [
+      unit[0] * this.radiusBottom,
+      -this.height / 2 + unit[1] * this.radiusBottom,
+      unit[2] * this.radiusBottom
+    ];
+    const top = [
+      unit[0] * this.radiusTop,
+      this.height / 2 + unit[1] * this.radiusTop,
+      unit[2] * this.radiusTop
+    ];
+    return dot(top, direction) >= dot(bottom, direction) ? top : bottom;
+  }
+  intersectLocalRay(origin, direction) {
+    const profile = this.getProfile();
+    if (profile.sphere)
+      return intersectSphere(origin, direction, profile.sphere.center, profile.sphere.radius);
+    const candidates = [];
+    const slope = (profile.top.radius - profile.bottom.radius) / (profile.top.y - profile.bottom.y);
+    const intercept = profile.bottom.radius - slope * profile.bottom.y;
+    const radialAtOrigin = intercept + slope * origin[1];
+    const radialAlongRay = slope * direction[1];
+    for (const distance of solveQuadratic(direction[0] ** 2 + direction[2] ** 2 - radialAlongRay ** 2, 2 * (origin[0] * direction[0] + origin[2] * direction[2] - radialAtOrigin * radialAlongRay), origin[0] ** 2 + origin[2] ** 2 - radialAtOrigin ** 2)) {
+      const y = origin[1] + distance * direction[1];
+      if (distance >= 0 && y >= profile.bottom.y - EPSILON2 && y <= profile.top.y + EPSILON2) {
+        const x = origin[0] + distance * direction[0];
+        const z = origin[2] + distance * direction[2];
+        const radial = Math.hypot(x, z) || 1;
+        const normal = [x / radial, -slope, z / radial];
+        const length = Math.hypot(...normal);
+        candidates.push({ distance, normal: normal.map((value) => value / length) });
+      }
+    }
+    for (const bottomHit of intersectSphereRoots(origin, direction, -this.height / 2, this.radiusBottom)) {
+      const y = origin[1] + bottomHit.distance * direction[1];
+      if (y <= profile.bottom.y + EPSILON2)
+        candidates.push(bottomHit);
+    }
+    for (const topHit of intersectSphereRoots(origin, direction, this.height / 2, this.radiusTop)) {
+      const y = origin[1] + topHit.distance * direction[1];
+      if (y >= profile.top.y - EPSILON2)
+        candidates.push(topHit);
+    }
+    return candidates.sort((a, b) => a.distance - b.distance)[0];
+  }
+  getProfile() {
+    const delta = this.radiusTop - this.radiusBottom;
+    if (Math.abs(delta) >= this.height) {
+      const topWins = this.radiusTop >= this.radiusBottom;
+      return {
+        sphere: {
+          center: topWins ? this.height / 2 : -this.height / 2,
+          radius: topWins ? this.radiusTop : this.radiusBottom
+        },
+        bottom: { radius: 0, y: 0 },
+        top: { radius: 0, y: 0 }
+      };
+    }
+    const sinSlope = delta / this.height;
+    const radialNormal = Math.sqrt(1 - sinSlope * sinSlope);
+    const normalY = -sinSlope;
+    return {
+      bottom: {
+        radius: this.radiusBottom * radialNormal,
+        y: -this.height / 2 + this.radiusBottom * normalY
+      },
+      top: { radius: this.radiusTop * radialNormal, y: this.height / 2 + this.radiusTop * normalY }
+    };
+  }
+};
+function intersectSphere(origin, direction, centerY, radius) {
+  return intersectSphereRoots(origin, direction, centerY, radius)[0];
+}
+function intersectSphereRoots(origin, direction, centerY, radius) {
+  if (radius === 0)
+    return [];
+  const relative = [origin[0], origin[1] - centerY, origin[2]];
+  return solveQuadratic(dot(direction, direction), 2 * dot(relative, direction), dot(relative, relative) - radius * radius).filter((distance) => distance >= 0).map((distance) => ({
+    distance,
+    normal: relative.map((value, i) => (value + distance * direction[i]) / radius)
+  }));
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+// dist/lib/shapes/cylinder-shape.js
+var EPSILON3 = 1e-6;
+var CylinderShape = class _CylinderShape extends ImplicitShapeBase {
+  constructor(props = {}) {
+    super(props.matrix);
+    this.type = "cylinder";
+    this.height = props.height ?? 2;
+    this.radiusBottom = props.radiusBottom ?? 0.5;
+    this.radiusTop = props.radiusTop ?? 0.5;
+    if (!Number.isFinite(this.height) || this.height <= 0)
+      throw new Error("Cylinder height must be greater than zero");
+    if (![this.radiusBottom, this.radiusTop].every((value) => Number.isFinite(value) && value >= 0))
+      throw new Error("Cylinder radii must be non-negative");
+    if (this.radiusBottom === 0 && this.radiusTop === 0)
+      throw new Error("At least one cylinder radius must be greater than zero");
+  }
+  clone() {
+    return new _CylinderShape({
+      height: this.height,
+      radiusBottom: this.radiusBottom,
+      radiusTop: this.radiusTop,
+      matrix: this.matrix
+    });
+  }
+  equals(shape) {
+    return shape instanceof _CylinderShape && super.equals(shape) && this.height === shape.height && this.radiusBottom === shape.radiusBottom && this.radiusTop === shape.radiusTop;
+  }
+  containsLocalPoint(point) {
+    const half = this.height / 2;
+    if (point[1] < -half - EPSILON3 || point[1] > half + EPSILON3)
+      return false;
+    const t = (point[1] + half) / this.height;
+    const radius = this.radiusBottom + (this.radiusTop - this.radiusBottom) * t;
+    return Math.hypot(point[0], point[2]) <= radius + EPSILON3;
+  }
+  distanceToLocalPoint(point) {
+    if (this.containsLocalPoint(point))
+      return 0;
+    const radial = Math.hypot(point[0], point[2]);
+    const half = this.height / 2;
+    const side = closestDistanceToSegment2D(radial, point[1], this.radiusBottom, -half, this.radiusTop, half);
+    const bottom = closestDistanceToSegment2D(radial, point[1], 0, -half, this.radiusBottom, -half);
+    const top = closestDistanceToSegment2D(radial, point[1], 0, half, this.radiusTop, half);
+    return Math.min(side, bottom, top);
+  }
+  supportLocal(direction) {
+    const radialLength = Math.hypot(direction[0], direction[2]);
+    const x = radialLength ? direction[0] / radialLength : 1;
+    const z = radialLength ? direction[2] / radialLength : 0;
+    const half = this.height / 2;
+    const bottomValue = radialLength * this.radiusBottom - direction[1] * half;
+    const topValue = radialLength * this.radiusTop + direction[1] * half;
+    return topValue >= bottomValue ? [x * this.radiusTop, half, z * this.radiusTop] : [x * this.radiusBottom, -half, z * this.radiusBottom];
+  }
+  intersectLocalRay(origin, direction) {
+    const half = this.height / 2;
+    const slope = (this.radiusTop - this.radiusBottom) / this.height;
+    const intercept = (this.radiusTop + this.radiusBottom) / 2;
+    const radialAtOrigin = intercept + slope * origin[1];
+    const radialAlongRay = slope * direction[1];
+    const candidates = [];
+    const roots = solveQuadratic(direction[0] ** 2 + direction[2] ** 2 - radialAlongRay ** 2, 2 * (origin[0] * direction[0] + origin[2] * direction[2] - radialAtOrigin * radialAlongRay), origin[0] ** 2 + origin[2] ** 2 - radialAtOrigin ** 2);
+    for (const distance of roots) {
+      const y = origin[1] + distance * direction[1];
+      if (distance >= 0 && y >= -half - EPSILON3 && y <= half + EPSILON3) {
+        const x = origin[0] + distance * direction[0];
+        const z = origin[2] + distance * direction[2];
+        const radial = Math.hypot(x, z) || 1;
+        const normal = [x / radial, -slope, z / radial];
+        const length = Math.hypot(...normal);
+        candidates.push({ distance, normal: normal.map((value) => value / length) });
+      }
+    }
+    if (Math.abs(direction[1]) > 1e-15) {
+      for (const [y, radius, normalY] of [
+        [-half, this.radiusBottom, -1],
+        [half, this.radiusTop, 1]
+      ]) {
+        const distance = (y - origin[1]) / direction[1];
+        const x = origin[0] + distance * direction[0];
+        const z = origin[2] + distance * direction[2];
+        if (distance >= 0 && Math.hypot(x, z) <= radius + EPSILON3)
+          candidates.push({ distance, normal: [0, normalY, 0] });
+      }
+    }
+    return candidates.sort((a, b) => a.distance - b.distance)[0];
+  }
+};
+
+// dist/lib/shapes/plane-shape.js
+var import_core8 = require("@math.gl/core");
+var PlaneShape = class _PlaneShape extends ImplicitShapeBase {
+  constructor(props = {}) {
+    super(props.matrix);
+    this.type = "plane";
+    this.sizeX = props.sizeX;
+    this.sizeZ = props.sizeZ;
+    if (this.sizeX !== void 0 && (!Number.isFinite(this.sizeX) || this.sizeX <= 0))
+      throw new Error("Plane sizeX must be greater than zero");
+    if (this.sizeZ !== void 0 && (!Number.isFinite(this.sizeZ) || this.sizeZ <= 0))
+      throw new Error("Plane sizeZ must be greater than zero");
+  }
+  clone() {
+    return new _PlaneShape({ sizeX: this.sizeX, sizeZ: this.sizeZ, matrix: this.matrix });
+  }
+  equals(shape) {
+    return shape instanceof _PlaneShape && super.equals(shape) && this.sizeX === shape.sizeX && this.sizeZ === shape.sizeZ;
+  }
+  containsLocalPoint(point) {
+    return point[1] <= 1e-12;
+  }
+  distanceToLocalPoint(point) {
+    return Math.max(0, point[1]);
+  }
+  supportLocal() {
+    throw new Error("An unbounded plane half-space has no finite support point");
+  }
+  intersectLocalRay(origin, direction) {
+    if (Math.abs(direction[1]) < 1e-15)
+      return void 0;
+    const distance = -origin[1] / direction[1];
+    if (distance < 0)
+      return void 0;
+    const x = origin[0] + distance * direction[0];
+    const z = origin[2] + distance * direction[2];
+    if (this.sizeX !== void 0 && Math.abs(x) > this.sizeX / 2 + 1e-12)
+      return void 0;
+    if (this.sizeZ !== void 0 && Math.abs(z) > this.sizeZ / 2 + 1e-12)
+      return void 0;
+    return { distance, normal: [0, 1, 0] };
+  }
+  intersectPlane(plane) {
+    const boundaryPoint = new import_core8.Vector3(0, 0, 0).transform(this.matrix);
+    const inverse = this.inverseMatrix;
+    const boundaryNormal = new import_core8.Vector3(inverse[1], inverse[5], inverse[9]).normalize();
+    const alignment = boundaryNormal.dot(plane.normal);
+    if (Math.abs(Math.abs(alignment) - 1) > 1e-10)
+      return INTERSECTION.INTERSECTING;
+    const boundaryDistance = plane.getPointDistance(boundaryPoint);
+    if (alignment < 0 && boundaryDistance > 0)
+      return INTERSECTION.INSIDE;
+    if (alignment > 0 && boundaryDistance < 0)
+      return INTERSECTION.OUTSIDE;
+    return INTERSECTION.INTERSECTING;
+  }
+  getAxisAlignedBoundingBox() {
+    return void 0;
+  }
+  getBoundingSphere() {
+    return void 0;
+  }
+};
+
+// dist/lib/shapes/sphere-shape.js
+var EPSILON4 = 1e-6;
+var SphereShape = class _SphereShape extends ImplicitShapeBase {
+  constructor(props = {}) {
+    super(props.matrix);
+    this.type = "sphere";
+    this.radius = props.radius ?? 0.5;
+    if (!Number.isFinite(this.radius) || this.radius <= 0)
+      throw new Error("Sphere radius must be greater than zero");
+  }
+  clone() {
+    return new _SphereShape({ radius: this.radius, matrix: this.matrix });
+  }
+  equals(shape) {
+    return shape instanceof _SphereShape && super.equals(shape) && this.radius === shape.radius;
+  }
+  containsLocalPoint(point) {
+    return Math.hypot(...point) <= this.radius + EPSILON4;
+  }
+  distanceToLocalPoint(point) {
+    return Math.max(0, Math.hypot(...point) - this.radius);
+  }
+  supportLocal(direction) {
+    const length = Math.hypot(...direction);
+    return length ? direction.map((value) => value / length * this.radius) : [this.radius, 0, 0];
+  }
+  intersectLocalRay(origin, direction) {
+    const roots = solveQuadratic(dot2(direction, direction), 2 * dot2(origin, direction), dot2(origin, origin) - this.radius * this.radius);
+    const distance = roots.find((value) => value >= 0);
+    if (distance === void 0)
+      return void 0;
+    const point = origin.map((value, i) => value + distance * direction[i]);
+    return { distance, normal: point.map((value) => value / this.radius) };
+  }
+};
+function dot2(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+// dist/lib/perspective-off-center-frustum.js
+var import_core9 = require("@math.gl/core");
+var scratchPlaneUpVector = new import_core9.Vector3();
+var scratchPlaneRightVector = new import_core9.Vector3();
+var scratchPlaneNearCenter = new import_core9.Vector3();
+var scratchPlaneFarCenter = new import_core9.Vector3();
+var scratchPlaneNormal2 = new import_core9.Vector3();
+var PerspectiveOffCenterFrustum = class _PerspectiveOffCenterFrustum {
   /**
    * The viewing frustum is defined by 6 planes.
    * Each plane is represented by a {@link Vector4} object, where the x, y, and z components
@@ -650,8 +1227,8 @@ var PerspectiveOffCenterFrustum = class {
       new Plane(),
       new Plane()
     ]);
-    this._perspectiveMatrix = new import_core6.Matrix4();
-    this._infinitePerspective = new import_core6.Matrix4();
+    this._perspectiveMatrix = new import_core9.Matrix4();
+    this._infinitePerspective = new import_core9.Matrix4();
     const { near = 1, far = 5e8 } = options;
     this.left = options.left;
     this._left = void 0;
@@ -671,7 +1248,7 @@ var PerspectiveOffCenterFrustum = class {
    * @returns {PerspectiveOffCenterFrustum} A new PerspectiveFrustum instance.
    * */
   clone() {
-    return new PerspectiveOffCenterFrustum({
+    return new _PerspectiveOffCenterFrustum({
       right: this.right,
       left: this.left,
       top: this.top,
@@ -687,7 +1264,7 @@ var PerspectiveOffCenterFrustum = class {
    * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
    */
   equals(other) {
-    return other && other instanceof PerspectiveOffCenterFrustum && this.right === other.right && this.left === other.left && this.top === other.top && this.bottom === other.bottom && this.near === other.near && this.far === other.far;
+    return other && other instanceof _PerspectiveOffCenterFrustum && this.right === other.right && this.left === other.left && this.top === other.top && this.bottom === other.bottom && this.near === other.near && this.far === other.far;
   }
   /**
    * Gets the perspective projection matrix computed from the view frustum.
@@ -722,9 +1299,9 @@ var PerspectiveOffCenterFrustum = class {
    */
   // eslint-disable-next-line complexity, max-statements
   computeCullingVolume(position, direction, up) {
-    (0, import_core6.assert)(position, "position is required.");
-    (0, import_core6.assert)(direction, "direction is required.");
-    (0, import_core6.assert)(up, "up is required.");
+    (0, import_core9.assert)(position, "position is required.");
+    (0, import_core9.assert)(direction, "direction is required.");
+    (0, import_core9.assert)(up, "up is required.");
     const planes = this._cullingVolume.planes;
     up = scratchPlaneUpVector.copy(up).normalize();
     const right = scratchPlaneRightVector.copy(direction).cross(up).normalize();
@@ -739,7 +1316,7 @@ var PerspectiveOffCenterFrustum = class {
     planes[2].fromPointNormal(position, normal);
     normal.copy(up).multiplyByScalar(this.top).add(nearCenter).subtract(position).cross(right);
     planes[3].fromPointNormal(position, normal);
-    normal = new import_core6.Vector3().copy(direction);
+    normal = new import_core9.Vector3().copy(direction);
     planes[4].fromPointNormal(nearCenter, normal);
     normal.negate();
     planes[5].fromPointNormal(farCenter, normal);
@@ -771,11 +1348,11 @@ var PerspectiveOffCenterFrustum = class {
    */
   getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result) {
     this._update();
-    (0, import_core6.assert)(Number.isFinite(drawingBufferWidth) && Number.isFinite(drawingBufferHeight));
-    (0, import_core6.assert)(drawingBufferWidth > 0);
-    (0, import_core6.assert)(drawingBufferHeight > 0);
-    (0, import_core6.assert)(distance > 0);
-    (0, import_core6.assert)(result);
+    (0, import_core9.assert)(Number.isFinite(drawingBufferWidth) && Number.isFinite(drawingBufferHeight));
+    (0, import_core9.assert)(drawingBufferWidth > 0);
+    (0, import_core9.assert)(drawingBufferHeight > 0);
+    (0, import_core9.assert)(distance > 0);
+    (0, import_core9.assert)(result);
     const inverseNear = 1 / this.near;
     let tanTheta = this.top * inverseNear;
     const pixelHeight = 2 * distance * tanTheta / drawingBufferHeight;
@@ -787,17 +1364,17 @@ var PerspectiveOffCenterFrustum = class {
   }
   // eslint-disable-next-line complexity, max-statements
   _update() {
-    (0, import_core6.assert)(Number.isFinite(this.right) && Number.isFinite(this.left) && Number.isFinite(this.top) && Number.isFinite(this.bottom) && Number.isFinite(this.near) && Number.isFinite(this.far));
+    (0, import_core9.assert)(Number.isFinite(this.right) && Number.isFinite(this.left) && Number.isFinite(this.top) && Number.isFinite(this.bottom) && Number.isFinite(this.near) && Number.isFinite(this.far));
     const { top, bottom, right, left, near, far } = this;
     if (top !== this._top || bottom !== this._bottom || left !== this._left || right !== this._right || near !== this._near || far !== this._far) {
-      (0, import_core6.assert)(this.near > 0 && this.near < this.far, "near must be greater than zero and less than far.");
+      (0, import_core9.assert)(this.near > 0 && this.near < this.far, "near must be greater than zero and less than far.");
       this._left = left;
       this._right = right;
       this._top = top;
       this._bottom = bottom;
       this._near = near;
       this._far = far;
-      this._perspectiveMatrix = new import_core6.Matrix4().frustum({
+      this._perspectiveMatrix = new import_core9.Matrix4().frustum({
         left,
         right,
         bottom,
@@ -805,7 +1382,7 @@ var PerspectiveOffCenterFrustum = class {
         near,
         far
       });
-      this._infinitePerspective = new import_core6.Matrix4().frustum({
+      this._infinitePerspective = new import_core9.Matrix4().frustum({
         left,
         right,
         bottom,
@@ -818,9 +1395,9 @@ var PerspectiveOffCenterFrustum = class {
 };
 
 // dist/lib/perspective-frustum.js
-var import_core7 = require("@math.gl/core");
+var import_core10 = require("@math.gl/core");
 var defined = (val) => val !== null && typeof val !== "undefined";
-var PerspectiveFrustum = class {
+var PerspectiveFrustum = class _PerspectiveFrustum {
   constructor(options = {}) {
     this._offCenterFrustum = new PerspectiveOffCenterFrustum();
     const { fov, aspectRatio, near = 1, far = 5e8, xOffset = 0, yOffset = 0 } = options;
@@ -835,7 +1412,7 @@ var PerspectiveFrustum = class {
    * Returns a duplicate of a PerspectiveFrustum instance.
    */
   clone() {
-    return new PerspectiveFrustum({
+    return new _PerspectiveFrustum({
       aspectRatio: this.aspectRatio,
       fov: this.fov,
       near: this.near,
@@ -847,7 +1424,7 @@ var PerspectiveFrustum = class {
    * <code>true</code> if they are equal, <code>false</code> otherwise.
    */
   equals(other) {
-    if (!defined(other) || !(other instanceof PerspectiveFrustum)) {
+    if (!defined(other) || !(other instanceof _PerspectiveFrustum)) {
       return false;
     }
     this._update();
@@ -920,16 +1497,16 @@ var PerspectiveFrustum = class {
    */
   getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result) {
     this._update();
-    return this._offCenterFrustum.getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result || new import_core7.Vector2());
+    return this._offCenterFrustum.getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result || new import_core10.Vector2());
   }
   // eslint-disable-next-line complexity, max-statements
   _update() {
-    (0, import_core7.assert)(Number.isFinite(this.fov) && Number.isFinite(this.aspectRatio) && Number.isFinite(this.near) && Number.isFinite(this.far));
+    (0, import_core10.assert)(Number.isFinite(this.fov) && Number.isFinite(this.aspectRatio) && Number.isFinite(this.near) && Number.isFinite(this.far));
     const f = this._offCenterFrustum;
     if (this.fov !== this._fov || this.aspectRatio !== this._aspectRatio || this.near !== this._near || this.far !== this._far || this.xOffset !== this._xOffset || this.yOffset !== this._yOffset) {
-      (0, import_core7.assert)(this.fov >= 0 && this.fov < Math.PI);
-      (0, import_core7.assert)(this.aspectRatio > 0);
-      (0, import_core7.assert)(this.near >= 0 && this.near < this.far);
+      (0, import_core10.assert)(this.fov >= 0 && this.fov < Math.PI);
+      (0, import_core10.assert)(this.aspectRatio > 0);
+      (0, import_core10.assert)(this.near >= 0 && this.near < this.far);
       this._aspectRatio = this.aspectRatio;
       this._fov = this.fov;
       this._fovy = this.aspectRatio <= 1 ? this.fov : Math.atan(Math.tan(this.fov * 0.5) / this.aspectRatio) * 2;
@@ -953,19 +1530,19 @@ var PerspectiveFrustum = class {
 };
 
 // dist/lib/algorithms/bounding-sphere-from-points.js
-var import_core8 = require("@math.gl/core");
-var fromPointsXMin = new import_core8.Vector3();
-var fromPointsYMin = new import_core8.Vector3();
-var fromPointsZMin = new import_core8.Vector3();
-var fromPointsXMax = new import_core8.Vector3();
-var fromPointsYMax = new import_core8.Vector3();
-var fromPointsZMax = new import_core8.Vector3();
-var fromPointsCurrentPos = new import_core8.Vector3();
-var fromPointsScratch = new import_core8.Vector3();
-var fromPointsRitterCenter = new import_core8.Vector3();
-var fromPointsMinBoxPt = new import_core8.Vector3();
-var fromPointsMaxBoxPt = new import_core8.Vector3();
-var fromPointsNaiveCenterScratch = new import_core8.Vector3();
+var import_core11 = require("@math.gl/core");
+var fromPointsXMin = new import_core11.Vector3();
+var fromPointsYMin = new import_core11.Vector3();
+var fromPointsZMin = new import_core11.Vector3();
+var fromPointsXMax = new import_core11.Vector3();
+var fromPointsYMax = new import_core11.Vector3();
+var fromPointsZMax = new import_core11.Vector3();
+var fromPointsCurrentPos = new import_core11.Vector3();
+var fromPointsScratch = new import_core11.Vector3();
+var fromPointsRitterCenter = new import_core11.Vector3();
+var fromPointsMinBoxPt = new import_core11.Vector3();
+var fromPointsMaxBoxPt = new import_core11.Vector3();
+var fromPointsNaiveCenterScratch = new import_core11.Vector3();
 function makeBoundingSphereFromPoints(positions, result = new BoundingSphere()) {
   if (!positions || positions.length === 0) {
     return result.fromCenterRadius([0, 0, 0], 0);
@@ -1061,17 +1638,17 @@ function makeBoundingSphereFromPoints(positions, result = new BoundingSphere())
 }
 
 // dist/lib/algorithms/bounding-box-from-points.js
-var import_core10 = require("@math.gl/core");
+var import_core13 = require("@math.gl/core");
 
 // dist/lib/algorithms/compute-eigen-decomposition.js
-var import_core9 = require("@math.gl/core");
-var scratchMatrix = new import_core9.Matrix3();
-var scratchUnitary = new import_core9.Matrix3();
-var scratchDiagonal = new import_core9.Matrix3();
-var jMatrix = new import_core9.Matrix3();
-var jMatrixTranspose = new import_core9.Matrix3();
+var import_core12 = require("@math.gl/core");
+var scratchMatrix = new import_core12.Matrix3();
+var scratchUnitary = new import_core12.Matrix3();
+var scratchDiagonal = new import_core12.Matrix3();
+var jMatrix = new import_core12.Matrix3();
+var jMatrixTranspose = new import_core12.Matrix3();
 function computeEigenDecomposition(matrix, result = {}) {
-  const EIGEN_TOLERANCE = import_core9._MathUtils.EPSILON20;
+  const EIGEN_TOLERANCE = import_core12._MathUtils.EPSILON20;
   const EIGEN_MAX_SWEEPS = 10;
   let count = 0;
   let sweep = 0;
@@ -1114,7 +1691,7 @@ function offDiagonalFrobeniusNorm(matrix) {
   return Math.sqrt(norm);
 }
 function shurDecomposition(matrix, result) {
-  const tolerance = import_core9._MathUtils.EPSILON15;
+  const tolerance = import_core12._MathUtils.EPSILON15;
   let maxDiagonal = 0;
   let rotAxis = 1;
   for (let i = 0; i < 3; ++i) {
@@ -1142,7 +1719,7 @@ function shurDecomposition(matrix, result) {
     c = 1 / Math.sqrt(1 + t * t);
     s = t * c;
   }
-  import_core9.Matrix3.IDENTITY.to(result);
+  import_core12.Matrix3.IDENTITY.to(result);
   result[scratchMatrix.getElementIndex(p, p)] = result[scratchMatrix.getElementIndex(q, q)] = c;
   result[scratchMatrix.getElementIndex(q, p)] = s;
   result[scratchMatrix.getElementIndex(p, q)] = -s;
@@ -1150,24 +1727,24 @@ function shurDecomposition(matrix, result) {
 }
 
 // dist/lib/algorithms/bounding-box-from-points.js
-var scratchVector23 = new import_core10.Vector3();
-var scratchVector32 = new import_core10.Vector3();
-var scratchVector4 = new import_core10.Vector3();
-var scratchVector5 = new import_core10.Vector3();
-var scratchVector6 = new import_core10.Vector3();
-var scratchCovarianceResult = new import_core10.Matrix3();
+var scratchVector23 = new import_core13.Vector3();
+var scratchVector32 = new import_core13.Vector3();
+var scratchVector4 = new import_core13.Vector3();
+var scratchVector5 = new import_core13.Vector3();
+var scratchVector6 = new import_core13.Vector3();
+var scratchCovarianceResult = new import_core13.Matrix3();
 var scratchEigenResult = {
-  diagonal: new import_core10.Matrix3(),
-  unitary: new import_core10.Matrix3()
+  diagonal: new import_core13.Matrix3(),
+  unitary: new import_core13.Matrix3()
 };
 function makeOrientedBoundingBoxFromPoints(positions, result = new OrientedBoundingBox()) {
   if (!positions || positions.length === 0) {
-    result.halfAxes = new import_core10.Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);
-    result.center = new import_core10.Vector3();
+    result.halfAxes = new import_core13.Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    result.center = new import_core13.Vector3();
     return result;
   }
   const length = positions.length;
-  const meanPoint = new import_core10.Vector3(0, 0, 0);
+  const meanPoint = new import_core13.Vector3(0, 0, 0);
   for (const position of positions) {
     meanPoint.add(position);
   }
@@ -1229,7 +1806,7 @@ function makeOrientedBoundingBoxFromPoints(positions, result = new OrientedBound
   v3 = v3.multiplyByScalar(0.5 * (l3 + u3));
   result.center.copy(v1).add(v2).add(v3);
   const scale = scratchVector32.set(u1 - l1, u2 - l2, u3 - l3).multiplyByScalar(0.5);
-  const scaleMatrix = new import_core10.Matrix3([scale[0], 0, 0, 0, scale[1], 0, 0, 0, scale[2]]);
+  const scaleMatrix = new import_core13.Matrix3([scale[0], 0, 0, 0, scale[1], 0, 0, 0, scale[2]]);
   result.halfAxes.multiplyRight(scaleMatrix);
   return result;
 }