@math.gl/culling 3.5.6 → 3.6.0-alpha.1

package/dist/lib/algorithms/bounding-sphere-from-points.js

@@ -0,0 +1,142 @@
+// 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 BoundingSphere from '../bounding-volumes/bounding-sphere';
+/* eslint-disable */
+const fromPointsXMin = new Vector3();
+const fromPointsYMin = new Vector3();
+const fromPointsZMin = new Vector3();
+const fromPointsXMax = new Vector3();
+const fromPointsYMax = new Vector3();
+const fromPointsZMax = new Vector3();
+const fromPointsCurrentPos = new Vector3();
+const fromPointsScratch = new Vector3();
+const fromPointsRitterCenter = new Vector3();
+const fromPointsMinBoxPt = new Vector3();
+const fromPointsMaxBoxPt = new Vector3();
+const fromPointsNaiveCenterScratch = new Vector3();
+const volumeConstant = (4.0 / 3.0) * Math.PI;
+/**
+ * Computes a tight-fitting bounding sphere enclosing a list of 3D Cartesian points.
+ *
+ * The bounding sphere is computed by running two algorithms, a naive algorithm and
+ * Ritter's algorithm. The smaller of the two spheres is used to ensure a tight fit.
+ * Bounding sphere computation article http://blogs.agi.com/insight3d/index.php/2008/02/04/a-bounding
+ *
+ * @param positions An array of points that the bounding sphere will enclose.
+ * @param result Optional object onto which to store the result.
+ * @returns The modified result parameter or a new `BoundingSphere` instance if not provided.
+ */
+export default function makeBoundingSphereFromPoints(positions, result = new BoundingSphere()) {
+    if (!positions || positions.length === 0) {
+        return result.fromCenterRadius([0, 0, 0], 0);
+    }
+    const currentPos = fromPointsCurrentPos.copy(positions[0]);
+    const xMin = fromPointsXMin.copy(currentPos);
+    const yMin = fromPointsYMin.copy(currentPos);
+    const zMin = fromPointsZMin.copy(currentPos);
+    const xMax = fromPointsXMax.copy(currentPos);
+    const yMax = fromPointsYMax.copy(currentPos);
+    const zMax = fromPointsZMax.copy(currentPos);
+    for (const position of positions) {
+        currentPos.copy(position);
+        const x = currentPos.x;
+        const y = currentPos.y;
+        const z = currentPos.z;
+        // Store points containing the the smallest and largest components
+        if (x < xMin.x) {
+            xMin.copy(currentPos);
+        }
+        if (x > xMax.x) {
+            xMax.copy(currentPos);
+        }
+        if (y < yMin.y) {
+            yMin.copy(currentPos);
+        }
+        if (y > yMax.y) {
+            yMax.copy(currentPos);
+        }
+        if (z < zMin.z) {
+            zMin.copy(currentPos);
+        }
+        if (z > zMax.z) {
+            zMax.copy(currentPos);
+        }
+    }
+    // Compute x-, y-, and z-spans (Squared distances b/n each component's min. and max.).
+    const xSpan = fromPointsScratch.copy(xMax).subtract(xMin).magnitudeSquared();
+    const ySpan = fromPointsScratch.copy(yMax).subtract(yMin).magnitudeSquared();
+    const zSpan = fromPointsScratch.copy(zMax).subtract(zMin).magnitudeSquared();
+    // Set the diameter endpoints to the largest span.
+    let diameter1 = xMin;
+    let diameter2 = xMax;
+    let maxSpan = xSpan;
+    if (ySpan > maxSpan) {
+        maxSpan = ySpan;
+        diameter1 = yMin;
+        diameter2 = yMax;
+    }
+    if (zSpan > maxSpan) {
+        maxSpan = zSpan;
+        diameter1 = zMin;
+        diameter2 = zMax;
+    }
+    // Calculate the center of the initial sphere found by Ritter's algorithm
+    const ritterCenter = fromPointsRitterCenter;
+    ritterCenter.x = (diameter1.x + diameter2.x) * 0.5;
+    ritterCenter.y = (diameter1.y + diameter2.y) * 0.5;
+    ritterCenter.z = (diameter1.z + diameter2.z) * 0.5;
+    // Calculate the radius of the initial sphere found by Ritter's algorithm
+    let radiusSquared = fromPointsScratch.copy(diameter2).subtract(ritterCenter).magnitudeSquared();
+    let ritterRadius = Math.sqrt(radiusSquared);
+    // Find the center of the sphere found using the Naive method.
+    const minBoxPt = fromPointsMinBoxPt;
+    minBoxPt.x = xMin.x;
+    minBoxPt.y = yMin.y;
+    minBoxPt.z = zMin.z;
+    const maxBoxPt = fromPointsMaxBoxPt;
+    maxBoxPt.x = xMax.x;
+    maxBoxPt.y = yMax.y;
+    maxBoxPt.z = zMax.z;
+    const naiveCenter = fromPointsNaiveCenterScratch
+        .copy(minBoxPt)
+        .add(maxBoxPt)
+        .multiplyByScalar(0.5);
+    // Begin 2nd pass to find naive radius and modify the ritter sphere.
+    let naiveRadius = 0;
+    for (const position of positions) {
+        currentPos.copy(position);
+        // Find the furthest point from the naive center to calculate the naive radius.
+        const r = fromPointsScratch.copy(currentPos).subtract(naiveCenter).magnitude();
+        if (r > naiveRadius) {
+            naiveRadius = r;
+        }
+        // Make adjustments to the Ritter Sphere to include all points.
+        const oldCenterToPointSquared = fromPointsScratch
+            .copy(currentPos)
+            .subtract(ritterCenter)
+            .magnitudeSquared();
+        if (oldCenterToPointSquared > radiusSquared) {
+            const oldCenterToPoint = Math.sqrt(oldCenterToPointSquared);
+            // Calculate new radius to include the point that lies outside
+            ritterRadius = (ritterRadius + oldCenterToPoint) * 0.5;
+            radiusSquared = ritterRadius * ritterRadius;
+            // Calculate center of new Ritter sphere
+            const oldToNew = oldCenterToPoint - ritterRadius;
+            ritterCenter.x = (ritterRadius * ritterCenter.x + oldToNew * currentPos.x) / oldCenterToPoint;
+            ritterCenter.y = (ritterRadius * ritterCenter.y + oldToNew * currentPos.y) / oldCenterToPoint;
+            ritterCenter.z = (ritterRadius * ritterCenter.z + oldToNew * currentPos.z) / oldCenterToPoint;
+        }
+    }
+    if (ritterRadius < naiveRadius) {
+        ritterCenter.to(result.center);
+        // @ts-ignore TS2540: Cannot assign to 'radius' because it is a read-only property.
+        result.radius = ritterRadius;
+    }
+    else {
+        naiveCenter.to(result.center);
+        // @ts-ignore TS2540: Cannot assign to 'radius' because it is a read-only property.
+        result.radius = naiveRadius;
+    }
+    return result;
+}

package/dist/{es5/lib → lib}/algorithms/compute-eigen-decomposition.d.ts

@@ -1,5 +1,8 @@
-import {Matrix3} from '@math.gl/core';
-
+import { Matrix3 } from '@math.gl/core';
+export declare type EigenDecomposition = {
+    unitary: Matrix3;
+    diagonal: Matrix3;
+};
 /**
  * Computes the eigenvectors and eigenvalues of a symmetric matrix.
  *
@@ -30,10 +33,5 @@ import {Matrix3} from '@math.gl/core';
  * 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: number[],
-  result?: object
-): {
-  unitary: Matrix3;
-  diagonal: Matrix3;
-};
+export default function computeEigenDecomposition(matrix: number[], result?: EigenDecomposition): EigenDecomposition;
+//# sourceMappingURL=compute-eigen-decomposition.d.ts.map

package/dist/lib/algorithms/compute-eigen-decomposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-eigen-decomposition.d.ts","sourceRoot":"","sources":["../../../src/lib/algorithms/compute-eigen-decomposition.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,OAAO,EAAa,MAAM,eAAe,CAAC;AASlD,oBAAY,kBAAkB,GAAG;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAC/C,MAAM,EAAE,MAAM,EAAE,EAEhB,MAAM,GAAE,kBAAuB,GAC9B,kBAAkB,CAkCpB"}

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

@@ -0,0 +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();
+/**
+ * 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.d.ts

@@ -0,0 +1,56 @@
+import { BoundingVolume } from './bounding-volume';
+import { Vector3 } from '@math.gl/core';
+import Plane from '../plane';
+import { INTERSECTION } from '../../constants';
+/**
+ * An axis aligned bounding box - aligned with coordinate axes
+ * @see BoundingVolume
+ * @see BoundingRectangle
+ * @see OrientedBoundingBox
+ */
+export default class AxisAlignedBoundingBox implements BoundingVolume {
+    /** The center point of the bounding box. */
+    readonly center: Vector3;
+    /** The positive half diagonal of the bounding box. */
+    readonly halfDiagonal: Vector3;
+    /** The minimum point defining the bounding box. [0, 0, 0] for empty box */
+    readonly minimum: Vector3;
+    /** The maximum point defining the bounding box. [0, 0, 0] for empty box */
+    readonly maximum: Vector3;
+    /**
+     * 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?: readonly number[], maximum?: readonly number[], center?: readonly number[]);
+    /**
+     * Duplicates a AxisAlignedBoundingBox instance.
+     *
+     * @returns {AxisAlignedBoundingBox} A new AxisAlignedBoundingBox instance.
+     */
+    clone(): AxisAlignedBoundingBox;
+    /**
+     * 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: any): boolean;
+    /**
+     * 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: readonly number[]): this;
+    /**
+     * Determines which side of a plane a box is located.
+     */
+    intersectPlane(plane: Plane): INTERSECTION;
+    /** Computes the estimated distance from the closest point on a bounding box to a point. */
+    distanceTo(point: readonly number[]): number;
+    /** 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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axis-aligned-bounding-box.d.ts","sourceRoot":"","sources":["../../../src/lib/bounding-volumes/axis-aligned-bounding-box.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AACtC,OAAO,KAAK,MAAM,UAAU,CAAC;AAC7B,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAK7C;;;;;GAKG;AACH,MAAM,CAAC,OAAO,OAAO,sBAAuB,YAAW,cAAc;IACnE,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,sDAAsD;IACtD,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B;;;;;OAKG;gBAED,OAAO,GAAE,SAAS,MAAM,EAAc,EACtC,OAAO,GAAE,SAAS,MAAM,EAAc,EACtC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE;IAsB5B;;;;OAIG;IACH,KAAK;IAIL;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,KAAA;IAOZ;;;;OAIG;IACH,SAAS,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAS7C;;OAEG;IACH,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,YAAY;IAqB1C,2FAA2F;IAC3F,UAAU,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM;IAI5C,mGAAmG;IACnG,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM;CAwBpD"}

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

@@ -0,0 +1,111 @@
+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.d.ts

@@ -0,0 +1,40 @@
+import { NumericArray, Vector3 } from '@math.gl/core';
+import { INTERSECTION } from '../../constants';
+import { BoundingVolume } from './bounding-volume';
+import Plane from '../plane';
+/** A BoundingSphere */
+export default class BoundingSphere implements BoundingVolume {
+    center: Vector3;
+    radius: number;
+    /** Creates a bounding sphere */
+    constructor(center?: readonly number[], radius?: number);
+    /** Sets the bounding sphere from `center` and `radius`. */
+    fromCenterRadius(center: readonly number[], radius: number): 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: readonly number[], oppositeCorner: readonly number[]): this;
+    /** Compares the provided BoundingSphere component wise */
+    equals(right: BoundingSphere): boolean;
+    /** Duplicates a BoundingSphere instance. */
+    clone(): BoundingSphere;
+    /** Computes a bounding sphere that contains both the left and right bounding spheres. */
+    union(boundingSphere: BoundingSphere): BoundingSphere;
+    /** Computes a bounding sphere by enlarging the provided sphere to contain the provided point. */
+    expand(point: readonly number[]): this;
+    /**
+     * 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: readonly number[]): this;
+    /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
+    distanceSquaredTo(point: Readonly<NumericArray>): number;
+    /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
+    distanceTo(point: Readonly<NumericArray>): number;
+    /** Determines which side of a plane a sphere is located. */
+    intersectPlane(plane: Plane): INTERSECTION;
+}
+//# sourceMappingURL=bounding-sphere.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bounding-sphere.d.ts","sourceRoot":"","sources":["../../../src/lib/bounding-volumes/bounding-sphere.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,YAAY,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAEpD,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,MAAM,UAAU,CAAC;AAK7B,uBAAuB;AACvB,MAAM,CAAC,OAAO,OAAO,cAAe,YAAW,cAAc;IAC3D,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IAEf,gCAAgC;gBACpB,MAAM,GAAE,SAAS,MAAM,EAAc,EAAE,MAAM,GAAE,MAAY;IAMvE,2DAA2D;IAC3D,gBAAgB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAMjE;;;OAGG;IACH,gBAAgB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,cAAc,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAOpF,0DAA0D;IAC1D,MAAM,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO;IAOtC,4CAA4C;IAC5C,KAAK,IAAI,cAAc;IAIvB,yFAAyF;IACzF,KAAK,CAAC,cAAc,EAAE,cAAc,GAAG,cAAc;IAkCrD,iGAAiG;IACjG,MAAM,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAWtC;;;;;OAKG;IACH,SAAS,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAO7C,sGAAsG;IACtG,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,MAAM;IAKxD,8FAA8F;IAC9F,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,MAAM;IAMjD,4DAA4D;IAC5D,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,YAAY;CAiB3C"}

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

@@ -0,0 +1,118 @@
+// 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.d.ts

@@ -0,0 +1,30 @@
+import { INTERSECTION } from '../../constants';
+import Plane from '../plane';
+/**
+ * Common interface for BoundingVolumes
+ * including BoundingSphere, AxisAlignedBoundingBox and OrientedBoundingBox
+ */
+export interface BoundingVolume {
+    /**
+     * 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 itself, i.e. the modified BoundingVolume.
+     */
+    transform(transform: readonly number[]): this;
+    /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
+    distanceSquaredTo(point: readonly number[]): number;
+    /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
+    distanceTo(point: readonly number[]): number;
+    /**
+     * Determines which side of a plane the oriented bounding box is located.
+     *
+     * @param plane The plane to test against.
+     * @returns
+     *  - `INTERSECTION.INSIDE` if the entire box is on the side of the plane the normal is pointing.
+     *  - `INTERSECTION.OUTSIDE` if the entire box is on the opposite side.
+     *  - `INTERSECTION.INTERSECTING` if the box intersects the plane.
+     */
+    intersectPlane(plane: Plane): INTERSECTION;
+}
+//# sourceMappingURL=bounding-volume.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bounding-volume.d.ts","sourceRoot":"","sources":["../../../src/lib/bounding-volumes/bounding-volume.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,MAAM,UAAU,CAAC;AAE7B;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,SAAS,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAE9C,sGAAsG;IACtG,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;IACpD,8FAA8F;IAC9F,UAAU,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;IAE7C;;;;;;;;OAQG;IACH,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,YAAY,CAAC;CAC5C"}