@math.gl/culling 3.6.0-alpha.8 → 3.6.2

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

@@ -1,131 +0,0 @@
-// 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();
-/**
- * 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 default 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;
-}
-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);
-}
-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);
-}
-// 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;
-    // 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));
-        }
-        c = 1.0 / Math.sqrt(1.0 + t * t);
-        s = t * c;
-    }
-    // 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;
-}

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

@@ -1,111 +0,0 @@
-import { Vector3 } from '@math.gl/core';
-import { INTERSECTION } from '../../constants';
-const scratchVector = new Vector3();
-const scratchNormal = new Vector3();
-/**
- * An axis aligned bounding box - aligned with coordinate axes
- * @see BoundingVolume
- * @see BoundingRectangle
- * @see OrientedBoundingBox
- */
-export default 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.
-     * @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);
-    }
-    /**
-     * Duplicates a AxisAlignedBoundingBox instance.
-     *
-     * @returns {AxisAlignedBoundingBox} A new AxisAlignedBoundingBox instance.
-     */
-    clone() {
-        return new AxisAlignedBoundingBox(this.minimum, this.maximum, this.center);
-    }
-    /**
-     * 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)));
-    }
-    /**
-     * 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;
-    }
-    /**
-     * 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;
-    }
-}

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

@@ -1,118 +0,0 @@
-// 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 } from '@math.gl/core';
-import * as mat4 from 'gl-matrix/mat4';
-import { INTERSECTION } from '../../constants';
-const scratchVector = new Vector3();
-const scratchVector2 = new Vector3();
-/** A BoundingSphere */
-export default class BoundingSphere {
-    /** Creates a bounding sphere */
-    constructor(center = [0, 0, 0], radius = 0.0) {
-        this.radius = -0;
-        this.center = new Vector3();
-        this.fromCenterRadius(center, radius);
-    }
-    /** Sets the bounding sphere from `center` and `radius`. */
-    fromCenterRadius(center, radius) {
-        this.center.from(center);
-        this.radius = radius;
-        return this;
-    }
-    /**
-     * 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;
-    }
-    /** Compares the provided BoundingSphere component wise */
-    equals(right) {
-        return (this === right ||
-            (Boolean(right) && this.center.equals(right.center) && this.radius === right.radius));
-    }
-    /** 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;
-    }
-}

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

@@ -1 +0,0 @@
-export {};

package/dist/lib/bounding-volumes/oriented-bounding-box.js

@@ -1,256 +0,0 @@
-// 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, Matrix3, Quaternion } from '@math.gl/core';
-import BoundingSphere from './bounding-sphere';
-import { INTERSECTION } from '../../constants';
-const scratchVector3 = new Vector3();
-const scratchOffset = new Vector3();
-const scratchVectorU = new Vector3();
-const scratchVectorV = new Vector3();
-const scratchVectorW = new Vector3();
-const scratchCorner = new Vector3();
-const scratchToCenter = new Vector3();
-const MATRIX3 = {
-    COLUMN0ROW0: 0,
-    COLUMN0ROW1: 1,
-    COLUMN0ROW2: 2,
-    COLUMN1ROW0: 3,
-    COLUMN1ROW1: 4,
-    COLUMN1ROW2: 5,
-    COLUMN2ROW0: 6,
-    COLUMN2ROW1: 7,
-    COLUMN2ROW2: 8
-};
-/**
- * An OrientedBoundingBox of some object is a closed and convex cuboid.
- * It can provide a tighter bounding volume than `BoundingSphere` or
- * `AxisAlignedBoundingBox` in many cases.
- */
-export default class OrientedBoundingBox {
-    constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
-        this.center = new Vector3().from(center);
-        this.halfAxes = new Matrix3(halfAxes);
-    }
-    /** Returns an array with three halfSizes for the bounding box */
-    get halfSize() {
-        const xAxis = this.halfAxes.getColumn(0);
-        const yAxis = this.halfAxes.getColumn(1);
-        const zAxis = this.halfAxes.getColumn(2);
-        return [new Vector3(xAxis).len(), new Vector3(yAxis).len(), new Vector3(zAxis).len()];
-    }
-    /** Returns a quaternion describing the orientation of the bounding box */
-    get quaternion() {
-        const xAxis = this.halfAxes.getColumn(0);
-        const yAxis = this.halfAxes.getColumn(1);
-        const zAxis = this.halfAxes.getColumn(2);
-        const normXAxis = new Vector3(xAxis).normalize();
-        const normYAxis = new Vector3(yAxis).normalize();
-        const normZAxis = new Vector3(zAxis).normalize();
-        return new Quaternion().fromMatrix3(new Matrix3([...normXAxis, ...normYAxis, ...normZAxis]));
-    }
-    /**
-     * Create OrientedBoundingBox from quaternion based OBB,
-     */
-    fromCenterHalfSizeQuaternion(center, halfSize, quaternion) {
-        const quaternionObject = new Quaternion(quaternion);
-        const directionsMatrix = new Matrix3().fromQuaternion(quaternionObject);
-        directionsMatrix[0] = directionsMatrix[0] * halfSize[0];
-        directionsMatrix[1] = directionsMatrix[1] * halfSize[0];
-        directionsMatrix[2] = directionsMatrix[2] * halfSize[0];
-        directionsMatrix[3] = directionsMatrix[3] * halfSize[1];
-        directionsMatrix[4] = directionsMatrix[4] * halfSize[1];
-        directionsMatrix[5] = directionsMatrix[5] * halfSize[1];
-        directionsMatrix[6] = directionsMatrix[6] * halfSize[2];
-        directionsMatrix[7] = directionsMatrix[7] * halfSize[2];
-        directionsMatrix[8] = directionsMatrix[8] * halfSize[2];
-        this.center = new Vector3().from(center);
-        this.halfAxes = directionsMatrix;
-        return this;
-    }
-    /** Duplicates a OrientedBoundingBox instance. */
-    clone() {
-        return new OrientedBoundingBox(this.center, this.halfAxes);
-    }
-    /** Compares the provided OrientedBoundingBox component wise and returns */
-    equals(right) {
-        return (this === right ||
-            (Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes)));
-    }
-    /** Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box. */
-    getBoundingSphere(result = new BoundingSphere()) {
-        const halfAxes = this.halfAxes;
-        const u = halfAxes.getColumn(0, scratchVectorU);
-        const v = halfAxes.getColumn(1, scratchVectorV);
-        const w = halfAxes.getColumn(2, scratchVectorW);
-        // Calculate "corner" vector
-        const cornerVector = scratchVector3.copy(u).add(v).add(w);
-        result.center.copy(this.center);
-        result.radius = cornerVector.magnitude();
-        return result;
-    }
-    /** Determines which side of a plane the oriented bounding box is located. */
-    intersectPlane(plane) {
-        const center = this.center;
-        const normal = plane.normal;
-        const halfAxes = this.halfAxes;
-        const normalX = normal.x;
-        const normalY = normal.y;
-        const normalZ = normal.z;
-        // Plane is used as if it is its normal; the first three components are assumed to be normalized
-        const radEffective = Math.abs(normalX * halfAxes[MATRIX3.COLUMN0ROW0] +
-            normalY * halfAxes[MATRIX3.COLUMN0ROW1] +
-            normalZ * halfAxes[MATRIX3.COLUMN0ROW2]) +
-            Math.abs(normalX * halfAxes[MATRIX3.COLUMN1ROW0] +
-                normalY * halfAxes[MATRIX3.COLUMN1ROW1] +
-                normalZ * halfAxes[MATRIX3.COLUMN1ROW2]) +
-            Math.abs(normalX * halfAxes[MATRIX3.COLUMN2ROW0] +
-                normalY * halfAxes[MATRIX3.COLUMN2ROW1] +
-                normalZ * halfAxes[MATRIX3.COLUMN2ROW2]);
-        const distanceToPlane = normal.dot(center) + plane.distance;
-        if (distanceToPlane <= -radEffective) {
-            // The entire box is on the negative side of the plane normal
-            return INTERSECTION.OUTSIDE;
-        }
-        else if (distanceToPlane >= radEffective) {
-            // The entire box is on the positive side of the plane normal
-            return INTERSECTION.INSIDE;
-        }
-        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.
-     * See Geometric Tools for Computer Graphics 10.4.2
-     */
-    distanceSquaredTo(point) {
-        // Computes the estimated distance squared from the
-        // closest point on a bounding box to a point.
-        // See Geometric Tools for Computer Graphics 10.4.2
-        const offset = scratchOffset.from(point).subtract(this.center);
-        const halfAxes = this.halfAxes;
-        const u = halfAxes.getColumn(0, scratchVectorU);
-        const v = halfAxes.getColumn(1, scratchVectorV);
-        const w = halfAxes.getColumn(2, scratchVectorW);
-        const uHalf = u.magnitude();
-        const vHalf = v.magnitude();
-        const wHalf = w.magnitude();
-        u.normalize();
-        v.normalize();
-        w.normalize();
-        let distanceSquared = 0.0;
-        let d;
-        d = Math.abs(offset.dot(u)) - uHalf;
-        if (d > 0) {
-            distanceSquared += d * d;
-        }
-        d = Math.abs(offset.dot(v)) - vHalf;
-        if (d > 0) {
-            distanceSquared += d * d;
-        }
-        d = Math.abs(offset.dot(w)) - wHalf;
-        if (d > 0) {
-            distanceSquared += d * d;
-        }
-        return distanceSquared;
-    }
-    /**
-     * The distances calculated by the vector from the center of the bounding box
-     * to position projected onto direction.
-     *
-     * - If you imagine the infinite number of planes with normal direction,
-     *   this computes the smallest distance to the closest and farthest planes
-     *   from `position` that intersect the bounding box.
-     *
-     * @param position The position to calculate the distance from.
-     * @param direction The direction from position.
-     * @param result An Interval (array of length 2) to store the nearest and farthest distances.
-     * @returns Interval (array of length 2) with nearest and farthest distances
-     *   on the bounding box from position in direction.
-     */
-    // eslint-disable-next-line max-statements
-    computePlaneDistances(position, direction, result = [-0, -0]) {
-        let minDist = Number.POSITIVE_INFINITY;
-        let maxDist = Number.NEGATIVE_INFINITY;
-        const center = this.center;
-        const halfAxes = this.halfAxes;
-        const u = halfAxes.getColumn(0, scratchVectorU);
-        const v = halfAxes.getColumn(1, scratchVectorV);
-        const w = halfAxes.getColumn(2, scratchVectorW);
-        // project first corner
-        const corner = scratchCorner.copy(u).add(v).add(w).add(center);
-        const toCenter = scratchToCenter.copy(corner).subtract(position);
-        let mag = direction.dot(toCenter);
-        minDist = Math.min(mag, minDist);
-        maxDist = Math.max(mag, maxDist);
-        // project second corner
-        corner.copy(center).add(u).add(v).subtract(w);
-        toCenter.copy(corner).subtract(position);
-        mag = direction.dot(toCenter);
-        minDist = Math.min(mag, minDist);
-        maxDist = Math.max(mag, maxDist);
-        // project third corner
-        corner.copy(center).add(u).subtract(v).add(w);
-        toCenter.copy(corner).subtract(position);
-        mag = direction.dot(toCenter);
-        minDist = Math.min(mag, minDist);
-        maxDist = Math.max(mag, maxDist);
-        // project fourth corner
-        corner.copy(center).add(u).subtract(v).subtract(w);
-        toCenter.copy(corner).subtract(position);
-        mag = direction.dot(toCenter);
-        minDist = Math.min(mag, minDist);
-        maxDist = Math.max(mag, maxDist);
-        // project fifth corner
-        center.copy(corner).subtract(u).add(v).add(w);
-        toCenter.copy(corner).subtract(position);
-        mag = direction.dot(toCenter);
-        minDist = Math.min(mag, minDist);
-        maxDist = Math.max(mag, maxDist);
-        // project sixth corner
-        center.copy(corner).subtract(u).add(v).subtract(w);
-        toCenter.copy(corner).subtract(position);
-        mag = direction.dot(toCenter);
-        minDist = Math.min(mag, minDist);
-        maxDist = Math.max(mag, maxDist);
-        // project seventh corner
-        center.copy(corner).subtract(u).subtract(v).add(w);
-        toCenter.copy(corner).subtract(position);
-        mag = direction.dot(toCenter);
-        minDist = Math.min(mag, minDist);
-        maxDist = Math.max(mag, maxDist);
-        // project eighth corner
-        center.copy(corner).subtract(u).subtract(v).subtract(w);
-        toCenter.copy(corner).subtract(position);
-        mag = direction.dot(toCenter);
-        minDist = Math.min(mag, minDist);
-        maxDist = Math.max(mag, maxDist);
-        result[0] = minDist;
-        result[1] = maxDist;
-        return result;
-    }
-    /**
-     * 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(transformation) {
-        this.center.transformAsPoint(transformation);
-        const xAxis = this.halfAxes.getColumn(0, scratchVectorU);
-        xAxis.transformAsPoint(transformation);
-        const yAxis = this.halfAxes.getColumn(1, scratchVectorV);
-        yAxis.transformAsPoint(transformation);
-        const zAxis = this.halfAxes.getColumn(2, scratchVectorW);
-        zAxis.transformAsPoint(transformation);
-        this.halfAxes = new Matrix3([...xAxis, ...yAxis, ...zAxis]);
-        return this;
-    }
-    getTransform() {
-        // const modelMatrix = Matrix4.fromRotationTranslation(this.boundingVolume.halfAxes, this.boundingVolume.center);
-        // return modelMatrix;
-        throw new Error('not implemented');
-    }
-}