@math.gl/culling 4.0.0 → 4.0.1

package/dist/lib/algorithms/compute-eigen-decomposition.js

@@ -1,103 +1,131 @@
+// This file is derived from the Cesium math library under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 import { Matrix3, _MathUtils } from '@math.gl/core';
 const scratchMatrix = new Matrix3();
 const scratchUnitary = new Matrix3();
 const scratchDiagonal = new Matrix3();
 const jMatrix = new Matrix3();
 const jMatrixTranspose = new Matrix3();
-export function computeEigenDecomposition(matrix, result = {}) {
-  const EIGEN_TOLERANCE = _MathUtils.EPSILON20;
-  const EIGEN_MAX_SWEEPS = 10;
-  let count = 0;
-  let sweep = 0;
-  const unitaryMatrix = scratchUnitary;
-  const diagonalMatrix = scratchDiagonal;
-  unitaryMatrix.identity();
-  diagonalMatrix.copy(matrix);
-  const epsilon = EIGEN_TOLERANCE * computeFrobeniusNorm(diagonalMatrix);
-
-  while (sweep < EIGEN_MAX_SWEEPS && offDiagonalFrobeniusNorm(diagonalMatrix) > epsilon) {
-    shurDecomposition(diagonalMatrix, jMatrix);
-    jMatrixTranspose.copy(jMatrix).transpose();
-    diagonalMatrix.multiplyRight(jMatrix);
-    diagonalMatrix.multiplyLeft(jMatrixTranspose);
-    unitaryMatrix.multiplyRight(jMatrix);
-
-    if (++count > 2) {
-      ++sweep;
-      count = 0;
+/**
+ * Computes the eigenvectors and eigenvalues of a symmetric matrix.
+ *
+ * - Returns a diagonal matrix and unitary matrix such that:
+ * `matrix = unitary matrix * diagonal matrix * transpose(unitary matrix)`
+ * - The values along the diagonal of the diagonal matrix are the eigenvalues. The columns
+ * of the unitary matrix are the corresponding eigenvectors.
+ * - This routine was created based upon Matrix Computations, 3rd ed., by Golub and Van Loan,
+ * section 8.4.3 The Classical Jacobi Algorithm
+ *
+ * @param matrix The 3x3 matrix to decompose into diagonal and unitary matrix. Expected to be symmetric.
+ * @param result Optional object with unitary and diagonal properties which are matrices onto which to store the result.
+ * @returns An object with unitary and diagonal properties which are the unitary and diagonal matrices, respectively.
+ *
+ * @example
+ * const a = //... symmetric matrix
+ * const result = {
+ *   unitary : new Matrix3(),
+ *   diagonal : new Matrix3()
+ * };
+ * computeEigenDecomposition(a, result);
+ *
+ * const unitaryTranspose = Matrix3.transpose(result.unitary, new Matrix3());
+ * const b = Matrix3.multiply(result.unitary, result.diagonal, new Matrix3());
+ * Matrix3.multiply(b, unitaryTranspose, b); // b is now equal to a
+ *
+ * const lambda = result.diagonal.getColumn(0, new Vector3()).x;  // first eigenvalue
+ * const v = result.unitary.getColumn(0, new Vector3());          // first eigenvector
+ * const c = v.multiplyByScalar(lambda);                          // equal to v.transformByMatrix3(a)
+ */
+export function computeEigenDecomposition(matrix, 
+// @ts-expect-error accept empty object type
+result = {}) {
+    const EIGEN_TOLERANCE = _MathUtils.EPSILON20;
+    const EIGEN_MAX_SWEEPS = 10;
+    let count = 0;
+    let sweep = 0;
+    const unitaryMatrix = scratchUnitary;
+    const diagonalMatrix = scratchDiagonal;
+    unitaryMatrix.identity();
+    diagonalMatrix.copy(matrix);
+    const epsilon = EIGEN_TOLERANCE * computeFrobeniusNorm(diagonalMatrix);
+    while (sweep < EIGEN_MAX_SWEEPS && offDiagonalFrobeniusNorm(diagonalMatrix) > epsilon) {
+        shurDecomposition(diagonalMatrix, jMatrix);
+        jMatrixTranspose.copy(jMatrix).transpose();
+        diagonalMatrix.multiplyRight(jMatrix);
+        diagonalMatrix.multiplyLeft(jMatrixTranspose);
+        unitaryMatrix.multiplyRight(jMatrix);
+        if (++count > 2) {
+            ++sweep;
+            count = 0;
+        }
     }
-  }
-
-  result.unitary = unitaryMatrix.toTarget(result.unitary);
-  result.diagonal = diagonalMatrix.toTarget(result.diagonal);
-  return result;
+    result.unitary = unitaryMatrix.toTarget(result.unitary);
+    result.diagonal = diagonalMatrix.toTarget(result.diagonal);
+    return result;
 }
-
 function computeFrobeniusNorm(matrix) {
-  let norm = 0.0;
-
-  for (let i = 0; i < 9; ++i) {
-    const temp = matrix[i];
-    norm += temp * temp;
-  }
-
-  return Math.sqrt(norm);
+    let norm = 0.0;
+    for (let i = 0; i < 9; ++i) {
+        const temp = matrix[i];
+        norm += temp * temp;
+    }
+    return Math.sqrt(norm);
 }
-
 const rowVal = [1, 0, 0];
 const colVal = [2, 2, 1];
-
+// Computes the "off-diagonal" Frobenius norm.
+// Assumes matrix is symmetric.
 function offDiagonalFrobeniusNorm(matrix) {
-  let norm = 0.0;
-
-  for (let i = 0; i < 3; ++i) {
-    const temp = matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])];
-    norm += 2.0 * temp * temp;
-  }
-
-  return Math.sqrt(norm);
+    let norm = 0.0;
+    for (let i = 0; i < 3; ++i) {
+        const temp = matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])];
+        norm += 2.0 * temp * temp;
+    }
+    return Math.sqrt(norm);
 }
-
+// The routine takes a matrix, which is assumed to be symmetric, and
+// finds the largest off-diagonal term, and then creates
+// a matrix (result) which can be used to help reduce it
+//
+// This routine was created based upon Matrix Computations, 3rd ed., by Golub and Van Loan,
+// section 8.4.2 The 2by2 Symmetric Schur Decomposition.
+//
+// eslint-disable-next-line max-statements
 function shurDecomposition(matrix, result) {
-  const tolerance = _MathUtils.EPSILON15;
-  let maxDiagonal = 0.0;
-  let rotAxis = 1;
-
-  for (let i = 0; i < 3; ++i) {
-    const temp = Math.abs(matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])]);
-
-    if (temp > maxDiagonal) {
-      rotAxis = i;
-      maxDiagonal = temp;
+    const tolerance = _MathUtils.EPSILON15;
+    let maxDiagonal = 0.0;
+    let rotAxis = 1;
+    // find pivot (rotAxis) based on max diagonal of matrix
+    for (let i = 0; i < 3; ++i) {
+        const temp = Math.abs(matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])]);
+        if (temp > maxDiagonal) {
+            rotAxis = i;
+            maxDiagonal = temp;
+        }
     }
-  }
-
-  const p = rowVal[rotAxis];
-  const q = colVal[rotAxis];
-  let c = 1.0;
-  let s = 0.0;
-
-  if (Math.abs(matrix[scratchMatrix.getElementIndex(q, p)]) > tolerance) {
-    const qq = matrix[scratchMatrix.getElementIndex(q, q)];
-    const pp = matrix[scratchMatrix.getElementIndex(p, p)];
-    const qp = matrix[scratchMatrix.getElementIndex(q, p)];
-    const tau = (qq - pp) / 2.0 / qp;
-    let t;
-
-    if (tau < 0.0) {
-      t = -1.0 / (-tau + Math.sqrt(1.0 + tau * tau));
-    } else {
-      t = 1.0 / (tau + Math.sqrt(1.0 + tau * tau));
+    const p = rowVal[rotAxis];
+    const q = colVal[rotAxis];
+    let c = 1.0;
+    let s = 0.0;
+    if (Math.abs(matrix[scratchMatrix.getElementIndex(q, p)]) > tolerance) {
+        const qq = matrix[scratchMatrix.getElementIndex(q, q)];
+        const pp = matrix[scratchMatrix.getElementIndex(p, p)];
+        const qp = matrix[scratchMatrix.getElementIndex(q, p)];
+        const tau = (qq - pp) / 2.0 / qp;
+        let t;
+        if (tau < 0.0) {
+            t = -1.0 / (-tau + Math.sqrt(1.0 + tau * tau));
+        }
+        else {
+            t = 1.0 / (tau + Math.sqrt(1.0 + tau * tau));
+        }
+        c = 1.0 / Math.sqrt(1.0 + t * t);
+        s = t * c;
     }
-
-    c = 1.0 / Math.sqrt(1.0 + t * t);
-    s = t * c;
-  }
-
-  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;
-  return result;
+    // Copy into result
+    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;
+    return result;
 }
-//# sourceMappingURL=compute-eigen-decomposition.js.map

package/dist/lib/bounding-volumes/axis-aligned-bounding-box.d.ts

@@ -1,6 +1,6 @@
-import { BoundingVolume } from './bounding-volume';
+import { BoundingVolume } from "./bounding-volume.js";
 import { Vector3 } from '@math.gl/core';
-import { Plane } from '../plane';
+import { Plane } from "../plane.js";
 /**
  * An axis aligned bounding box - aligned with coordinate axes
  * @see BoundingVolume
@@ -52,4 +52,3 @@ export declare class AxisAlignedBoundingBox implements BoundingVolume {
     /** Computes the estimated distance squared from the closest point on a bounding box to a point. */
     distanceSquaredTo(point: readonly number[]): number;
 }
-//# sourceMappingURL=axis-aligned-bounding-box.d.ts.map

package/dist/lib/bounding-volumes/axis-aligned-bounding-box.js

@@ -1,91 +1,111 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { Vector3 } from '@math.gl/core';
 import { INTERSECTION } from "../../constants.js";
 const scratchVector = new Vector3();
 const scratchNormal = new Vector3();
+/**
+ * An axis aligned bounding box - aligned with coordinate axes
+ * @see BoundingVolume
+ * @see BoundingRectangle
+ * @see OrientedBoundingBox
+ */
 export class AxisAlignedBoundingBox {
-  constructor(minimum = [0, 0, 0], maximum = [0, 0, 0], center) {
-    _defineProperty(this, "center", void 0);
-
-    _defineProperty(this, "halfDiagonal", void 0);
-
-    _defineProperty(this, "minimum", void 0);
-
-    _defineProperty(this, "maximum", void 0);
-
-    center = center || scratchVector.copy(minimum).add(maximum).scale(0.5);
-    this.center = new Vector3(center);
-    this.halfDiagonal = new Vector3(maximum).subtract(this.center);
-    this.minimum = new Vector3(minimum);
-    this.maximum = new Vector3(maximum);
-  }
-
-  clone() {
-    return new AxisAlignedBoundingBox(this.minimum, this.maximum, this.center);
-  }
-
-  equals(right) {
-    return this === right || Boolean(right) && this.minimum.equals(right.minimum) && this.maximum.equals(right.maximum);
-  }
-
-  transform(transform) {
-    this.center.transformAsPoint(transform);
-    this.halfDiagonal.transform(transform);
-    this.minimum.transform(transform);
-    this.maximum.transform(transform);
-    return this;
-  }
-
-  intersectPlane(plane) {
-    const {
-      halfDiagonal
-    } = this;
-    const normal = scratchNormal.from(plane.normal);
-    const e = halfDiagonal.x * Math.abs(normal.x) + halfDiagonal.y * Math.abs(normal.y) + halfDiagonal.z * Math.abs(normal.z);
-    const s = this.center.dot(normal) + plane.distance;
-
-    if (s - e > 0) {
-      return INTERSECTION.INSIDE;
+    /**
+     * 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.
+     * @param maximum=[0, 0, 0] The maximum point along the x, y, and z axes.
+     * @param center The center of the box; automatically computed if not supplied.
+     */
+    constructor(minimum = [0, 0, 0], maximum = [0, 0, 0], center) {
+        // If center was not defined, compute it.
+        center = center || scratchVector.copy(minimum).add(maximum).scale(0.5);
+        this.center = new Vector3(center);
+        this.halfDiagonal = new Vector3(maximum).subtract(this.center);
+        /**
+         * The minimum point defining the bounding box.
+         * @type {Vector3}
+         * @default {@link 0, 0, 0}
+         */
+        this.minimum = new Vector3(minimum);
+        /**
+         * The maximum point defining the bounding box.
+         * @type {Vector3}
+         * @default {@link 0, 0, 0}
+         */
+        this.maximum = new Vector3(maximum);
     }
-
-    if (s + e < 0) {
-      return INTERSECTION.OUTSIDE;
+    /**
+     * Duplicates a AxisAlignedBoundingBox instance.
+     *
+     * @returns {AxisAlignedBoundingBox} A new AxisAlignedBoundingBox instance.
+     */
+    clone() {
+        return new AxisAlignedBoundingBox(this.minimum, this.maximum, this.center);
     }
-
-    return INTERSECTION.INTERSECTING;
-  }
-
-  distanceTo(point) {
-    return Math.sqrt(this.distanceSquaredTo(point));
-  }
-
-  distanceSquaredTo(point) {
-    const offset = scratchVector.from(point).subtract(this.center);
-    const {
-      halfDiagonal
-    } = this;
-    let distanceSquared = 0.0;
-    let d;
-    d = Math.abs(offset.x) - halfDiagonal.x;
-
-    if (d > 0) {
-      distanceSquared += d * d;
+    /**
+     * Compares the provided AxisAlignedBoundingBox componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     *
+     * @param {AxisAlignedBoundingBox} [right] The second AxisAlignedBoundingBox to compare with.
+     * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+     */
+    equals(right) {
+        return (this === right ||
+            (Boolean(right) && this.minimum.equals(right.minimum) && this.maximum.equals(right.maximum)));
     }
-
-    d = Math.abs(offset.y) - halfDiagonal.y;
-
-    if (d > 0) {
-      distanceSquared += d * d;
+    /**
+     * Applies a 4x4 affine transformation matrix to a bounding sphere.
+     * @param transform The transformation matrix to apply to the bounding sphere.
+     * @returns itself, i.e. the modified BoundingVolume.
+     */
+    transform(transform) {
+        this.center.transformAsPoint(transform);
+        // TODO - this.halfDiagonal.transformAsVector(transform);
+        this.halfDiagonal.transform(transform);
+        this.minimum.transform(transform);
+        this.maximum.transform(transform);
+        return this;
     }
-
-    d = Math.abs(offset.z) - halfDiagonal.z;
-
-    if (d > 0) {
-      distanceSquared += d * d;
+    /**
+     * Determines which side of a plane a box is located.
+     */
+    intersectPlane(plane) {
+        const { halfDiagonal } = this;
+        const normal = scratchNormal.from(plane.normal);
+        const e = halfDiagonal.x * Math.abs(normal.x) +
+            halfDiagonal.y * Math.abs(normal.y) +
+            halfDiagonal.z * Math.abs(normal.z);
+        const s = this.center.dot(normal) + plane.distance; // signed distance from center
+        if (s - e > 0) {
+            return INTERSECTION.INSIDE;
+        }
+        if (s + e < 0) {
+            // Not in front because normals point inward
+            return INTERSECTION.OUTSIDE;
+        }
+        return INTERSECTION.INTERSECTING;
+    }
+    /** Computes the estimated distance from the closest point on a bounding box to a point. */
+    distanceTo(point) {
+        return Math.sqrt(this.distanceSquaredTo(point));
+    }
+    /** Computes the estimated distance squared from the closest point on a bounding box to a point. */
+    distanceSquaredTo(point) {
+        const offset = scratchVector.from(point).subtract(this.center);
+        const { halfDiagonal } = this;
+        let distanceSquared = 0.0;
+        let d;
+        d = Math.abs(offset.x) - halfDiagonal.x;
+        if (d > 0) {
+            distanceSquared += d * d;
+        }
+        d = Math.abs(offset.y) - halfDiagonal.y;
+        if (d > 0) {
+            distanceSquared += d * d;
+        }
+        d = Math.abs(offset.z) - halfDiagonal.z;
+        if (d > 0) {
+            distanceSquared += d * d;
+        }
+        return distanceSquared;
     }
-
-    return distanceSquared;
-  }
-
 }
-//# sourceMappingURL=axis-aligned-bounding-box.js.map

package/dist/lib/bounding-volumes/bounding-sphere.d.ts

@@ -1,6 +1,6 @@
 import { NumericArray, Vector3 } from '@math.gl/core';
-import { BoundingVolume } from './bounding-volume';
-import { Plane } from '../plane';
+import { BoundingVolume } from "./bounding-volume.js";
+import { Plane } from "../plane.js";
 /** A BoundingSphere */
 export declare class BoundingSphere implements BoundingVolume {
     center: Vector3;
@@ -36,4 +36,3 @@ export declare class BoundingSphere implements BoundingVolume {
     /** Determines which side of a plane a sphere is located. */
     intersectPlane(plane: Plane): number;
 }
-//# sourceMappingURL=bounding-sphere.d.ts.map

package/dist/lib/bounding-volumes/bounding-sphere.js

@@ -1,108 +1,117 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// This file is derived from the Cesium math library under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 import { Vector3, mat4 } from '@math.gl/core';
 import { INTERSECTION } from "../../constants.js";
 const scratchVector = new Vector3();
 const scratchVector2 = new Vector3();
+/** A BoundingSphere */
 export class BoundingSphere {
-  constructor(center = [0, 0, 0], radius = 0.0) {
-    _defineProperty(this, "center", void 0);
-
-    _defineProperty(this, "radius", void 0);
-
-    this.radius = -0;
-    this.center = new Vector3();
-    this.fromCenterRadius(center, radius);
-  }
-
-  fromCenterRadius(center, radius) {
-    this.center.from(center);
-    this.radius = radius;
-    return this;
-  }
-
-  fromCornerPoints(corner, oppositeCorner) {
-    oppositeCorner = scratchVector.from(oppositeCorner);
-    this.center = new Vector3().from(corner).add(oppositeCorner).scale(0.5);
-    this.radius = this.center.distance(oppositeCorner);
-    return this;
-  }
-
-  equals(right) {
-    return this === right || Boolean(right) && this.center.equals(right.center) && this.radius === right.radius;
-  }
-
-  clone() {
-    return new BoundingSphere(this.center, this.radius);
-  }
-
-  union(boundingSphere) {
-    const leftCenter = this.center;
-    const leftRadius = this.radius;
-    const rightCenter = boundingSphere.center;
-    const rightRadius = boundingSphere.radius;
-    const toRightCenter = scratchVector.copy(rightCenter).subtract(leftCenter);
-    const centerSeparation = toRightCenter.magnitude();
-
-    if (leftRadius >= centerSeparation + rightRadius) {
-      return this.clone();
+    /** Creates a bounding sphere */
+    constructor(center = [0, 0, 0], radius = 0.0) {
+        this.radius = -0;
+        this.center = new Vector3();
+        this.fromCenterRadius(center, radius);
     }
-
-    if (rightRadius >= centerSeparation + leftRadius) {
-      return boundingSphere.clone();
+    /** Sets the bounding sphere from `center` and `radius`. */
+    fromCenterRadius(center, radius) {
+        this.center.from(center);
+        this.radius = radius;
+        return this;
     }
-
-    const halfDistanceBetweenTangentPoints = (leftRadius + centerSeparation + rightRadius) * 0.5;
-    scratchVector2.copy(toRightCenter).scale((-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation).add(leftCenter);
-    this.center.copy(scratchVector2);
-    this.radius = halfDistanceBetweenTangentPoints;
-    return this;
-  }
-
-  expand(point) {
-    const scratchPoint = scratchVector.from(point);
-    const radius = scratchPoint.subtract(this.center).magnitude();
-
-    if (radius > this.radius) {
-      this.radius = radius;
+    /**
+     * Computes a bounding sphere from the corner points of an axis-aligned bounding box.  The sphere
+     * tightly and fully encompasses the box.
+     */
+    fromCornerPoints(corner, oppositeCorner) {
+        oppositeCorner = scratchVector.from(oppositeCorner);
+        this.center = new Vector3().from(corner).add(oppositeCorner).scale(0.5);
+        this.radius = this.center.distance(oppositeCorner);
+        return this;
     }
-
-    return this;
-  }
-
-  transform(transform) {
-    this.center.transform(transform);
-    const scale = mat4.getScaling(scratchVector, transform);
-    this.radius = Math.max(scale[0], Math.max(scale[1], scale[2])) * this.radius;
-    return this;
-  }
-
-  distanceSquaredTo(point) {
-    const d = this.distanceTo(point);
-    return d * d;
-  }
-
-  distanceTo(point) {
-    const scratchPoint = scratchVector.from(point);
-    const delta = scratchPoint.subtract(this.center);
-    return Math.max(0, delta.len() - this.radius);
-  }
-
-  intersectPlane(plane) {
-    const center = this.center;
-    const radius = this.radius;
-    const normal = plane.normal;
-    const distanceToPlane = normal.dot(center) + plane.distance;
-
-    if (distanceToPlane < -radius) {
-      return INTERSECTION.OUTSIDE;
+    /** Compares the provided BoundingSphere component wise */
+    equals(right) {
+        return (this === right ||
+            (Boolean(right) && this.center.equals(right.center) && this.radius === right.radius));
     }
-
-    if (distanceToPlane < radius) {
-      return INTERSECTION.INTERSECTING;
+    /** Duplicates a BoundingSphere instance. */
+    clone() {
+        return new BoundingSphere(this.center, this.radius);
+    }
+    /** Computes a bounding sphere that contains both the left and right bounding spheres. */
+    union(boundingSphere) {
+        const leftCenter = this.center;
+        const leftRadius = this.radius;
+        const rightCenter = boundingSphere.center;
+        const rightRadius = boundingSphere.radius;
+        const toRightCenter = scratchVector.copy(rightCenter).subtract(leftCenter);
+        const centerSeparation = toRightCenter.magnitude();
+        if (leftRadius >= centerSeparation + rightRadius) {
+            // Left sphere wins.
+            return this.clone();
+        }
+        if (rightRadius >= centerSeparation + leftRadius) {
+            // Right sphere wins.
+            return boundingSphere.clone();
+        }
+        // There are two tangent points, one on far side of each sphere.
+        const halfDistanceBetweenTangentPoints = (leftRadius + centerSeparation + rightRadius) * 0.5;
+        // Compute the center point halfway between the two tangent points.
+        scratchVector2
+            .copy(toRightCenter)
+            .scale((-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation)
+            .add(leftCenter);
+        this.center.copy(scratchVector2);
+        this.radius = halfDistanceBetweenTangentPoints;
+        return this;
+    }
+    /** Computes a bounding sphere by enlarging the provided sphere to contain the provided point. */
+    expand(point) {
+        const scratchPoint = scratchVector.from(point);
+        const radius = scratchPoint.subtract(this.center).magnitude();
+        if (radius > this.radius) {
+            this.radius = radius;
+        }
+        return this;
+    }
+    // BoundingVolume interface
+    /**
+     * Applies a 4x4 affine transformation matrix to a bounding sphere.
+     * @param sphere The bounding sphere to apply the transformation to.
+     * @param transform The transformation matrix to apply to the bounding sphere.
+     * @returns self.
+     */
+    transform(transform) {
+        this.center.transform(transform);
+        const scale = mat4.getScaling(scratchVector, transform);
+        this.radius = Math.max(scale[0], Math.max(scale[1], scale[2])) * this.radius;
+        return this;
+    }
+    /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
+    distanceSquaredTo(point) {
+        const d = this.distanceTo(point);
+        return d * d;
+    }
+    /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
+    distanceTo(point) {
+        const scratchPoint = scratchVector.from(point);
+        const delta = scratchPoint.subtract(this.center);
+        return Math.max(0, delta.len() - this.radius);
+    }
+    /** Determines which side of a plane a sphere is located. */
+    intersectPlane(plane) {
+        const center = this.center;
+        const radius = this.radius;
+        const normal = plane.normal;
+        const distanceToPlane = normal.dot(center) + plane.distance;
+        // The center point is negative side of the plane normal
+        if (distanceToPlane < -radius) {
+            return INTERSECTION.OUTSIDE;
+        }
+        // The center point is positive side of the plane, but radius extends beyond it; partial overlap
+        if (distanceToPlane < radius) {
+            return INTERSECTION.INTERSECTING;
+        }
+        // The center point and radius is positive side of the plane
+        return INTERSECTION.INSIDE;
     }
-
-    return INTERSECTION.INSIDE;
-  }
-
 }
-//# sourceMappingURL=bounding-sphere.js.map

package/dist/lib/bounding-volumes/bounding-volume.d.ts

@@ -1,4 +1,4 @@
-import { Plane } from '../plane';
+import { Plane } from "../plane.js";
 /**
  * Common interface for BoundingVolumes
  * including BoundingSphere, AxisAlignedBoundingBox and OrientedBoundingBox
@@ -26,4 +26,3 @@ export interface BoundingVolume {
      */
     intersectPlane(plane: Plane): number;
 }
-//# sourceMappingURL=bounding-volume.d.ts.map