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

package/src/lib/{culling-volume.js → culling-volume.ts}

@@ -2,9 +2,11 @@
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
 /* eslint-disable */
-import {Vector3, Vector4, assert} from '@math.gl/core';
+import {Vector3, assert} from '@math.gl/core';
 import {INTERSECTION} from '../constants';
 import Plane from './plane';
+import type {BoundingVolume} from './bounding-volumes/bounding-volume';
+import type BoundingSphere from './bounding-volumes/bounding-sphere';
 
 // X, Y, Z Unit vectors
 const faces = [new Vector3([1, 0, 0]), new Vector3([0, 1, 0]), new Vector3([0, 0, 1])];
@@ -13,35 +15,42 @@ const scratchPlaneCenter = new Vector3();
 const scratchPlaneNormal = new Vector3();
 const scratchPlane = new Plane(new Vector3(1.0, 0.0, 0.0), 0.0);
 
-// A culling volume defined by planes.
+/** A culling volume defined by planes. */
 export default class CullingVolume {
-  // For plane masks (as used in {@link CullingVolume#computeVisibilityWithPlaneMask}), this special value
-  // represents the case where the object bounding volume is entirely outside the culling volume.
-  static get MASK_OUTSIDE() {
-    return 0xffffffff;
-  }
+  /**
+   * For plane masks (as used in {@link CullingVolume#computeVisibilityWithPlaneMask}), this special value
+   * represents the case where the object bounding volume is entirely outside the culling volume.
+   */
+  static MASK_OUTSIDE = 0xffffffff;
 
-  // For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value
-  // represents the case where the object bounding volume is entirely inside the culling volume.
-  static get MASK_INSIDE() {
-    return 0x00000000;
-  }
+  /**
+   * For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value
+   * represents the case where the object bounding volume is entirely inside the culling volume.
+   */
+  static MASK_INSIDE = 0x00000000;
 
-  // For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value
-  // represents the case where the object bounding volume (may) intersect all planes of the culling volume.
-  static get MASK_INDETERMINATE() {
-    return 0x7fffffff;
-  }
+  /**
+   * For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value
+   * represents the case where the object bounding volume (may) intersect all planes of the culling volume.
+   */
+  static MASK_INDETERMINATE = 0x7fffffff;
 
-  constructor(planes = []) {
-    // {Cartesian4[]} [planes] An array of clipping planes.
+  /** Array of clipping planes. */
+  readonly planes: Plane[];
+
+  /**
+   * Create a new `CullingVolume` bounded by an array of clipping planed
+   * @param planes Array of clipping planes.
+   * */
+  constructor(planes: Plane[] = []) {
     this.planes = planes;
-    assert(this.planes.every((plane) => plane instanceof Plane));
   }
 
-  // Constructs a culling volume from a bounding sphere. Creates six planes that create a box containing the sphere.
-  // The planes are aligned to the x, y, and z axes in world coordinates.
-  fromBoundingSphere(boundingSphere) {
+  /**
+   * Constructs a culling volume from a bounding sphere. Creates six planes that create a box containing the sphere.
+   * The planes are aligned to the x, y, and z axes in world coordinates.
+   */
+  fromBoundingSphere(boundingSphere: BoundingSphere): CullingVolume {
     this.planes.length = 2 * faces.length;
 
     const center = boundingSphere.center;
@@ -79,9 +88,8 @@ export default class CullingVolume {
     return this;
   }
 
-  // Determines whether a bounding volume intersects the culling volume.
-  computeVisibility(boundingVolume) {
-    assert(boundingVolume);
+  /** Determines whether a bounding volume intersects the culling volume. */
+  computeVisibility(boundingVolume: BoundingVolume): INTERSECTION {
     // const planes = this.planes;
     let intersect = INTERSECTION.INSIDE;
     for (const plane of this.planes) {
@@ -103,15 +111,15 @@ export default class CullingVolume {
     return intersect;
   }
 
-  // Determines whether a bounding volume intersects the culling volume.
-  /*
-   * @param {Number} parentPlaneMask A bit mask from the boundingVolume's parent's check against the same culling
-   *                                 volume, such that if (planeMask & (1 << planeIndex) === 0), for k < 31, then
-   *                                 the parent (and therefore this) volume is completely inside plane[planeIndex]
-   *                                 and that plane check can be skipped.
+  /**
+   * Determines whether a bounding volume intersects the culling volume.
+   *
+   * @param parentPlaneMask A bit mask from the boundingVolume's parent's check against the same culling
+   *   volume, such that if (planeMask & (1 << planeIndex) === 0), for k < 31, then
+   *   the parent (and therefore this) volume is completely inside plane[planeIndex]
+   *   and that plane check can be skipped.
    */
-  computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) {
-    assert(boundingVolume, 'boundingVolume is required.');
+  computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number {
     assert(Number.isFinite(parentPlaneMask), 'parentPlaneMask is required.');
 
     if (

package/src/lib/{perspective-frustum.js → perspective-frustum.ts}

@@ -7,7 +7,7 @@
 
 // @ts-nocheck
 
-import {assert} from '@math.gl/core';
+import {assert, Matrix4} from '@math.gl/core';
 import PerspectiveOffCenterFrustum from './perspective-off-center-frustum';
 
 const defined = (val) => val !== null && typeof val !== 'undefined';
@@ -40,7 +40,47 @@ const defined = (val) => val !== null && typeof val !== 'undefined';
  * @see PerspectiveOffCenterFrustum
  */
 export default class PerspectiveFrustum {
-  constructor(options = {}) {
+  _offCenterFrustum = new PerspectiveOffCenterFrustum();
+  /**
+   * The angle of the field of view (FOV), in radians.  This angle will be used
+   * as the horizontal FOV if the width is greater than the height, otherwise
+   * it will be the vertical FOV.
+   */
+  fov: number;
+  _fov;
+  _fovy;
+  _sseDenominator;
+  /**
+   * The aspect ratio of the frustum's width to it's height.
+   */
+  aspectRatio: number;
+  _aspectRatio;
+  /**
+   * The distance of the near plane.
+   * @default 1.0
+   */
+  near: number;
+  _near;
+  /**
+   * The distance of the far plane.
+   * @default 500000000.0
+   */
+  far: number;
+  _far;
+  /**
+   * Offsets the frustum in the x direction.
+   * @default 0.0
+   */
+  xOffset: number;
+  _xOffset;
+  /**
+   * Offsets the frustum in the y direction.
+   * @default 0.0
+   */
+  yOffset: number;
+  _yOffset;
+
+  constructor(options: Record<string, any> = {}) {
     options = {
       near: 1.0,
       far: 500000000.0,
@@ -49,69 +89,27 @@ export default class PerspectiveFrustum {
       ...options
     };
 
-    this._offCenterFrustum = new PerspectiveOffCenterFrustum();
-
-    /**
-     * The angle of the field of view (FOV), in radians.  This angle will be used
-     * as the horizontal FOV if the width is greater than the height, otherwise
-     * it will be the vertical FOV.
-     * @type {Number}
-     * @default undefined
-     */
     this.fov = options.fov;
-    this._fov = undefined;
-    this._fovy = undefined;
 
-    this._sseDenominator = undefined;
-
-    /**
-     * The aspect ratio of the frustum's width to it's height.
-     * @type {Number}
-     * @default undefined
-     */
     this.aspectRatio = options.aspectRatio;
-    this._aspectRatio = undefined;
 
-    /**
-     * The distance of the near plane.
-     * @type {Number}
-     * @default 1.0
-     */
     this.near = options.near;
     this._near = this.near;
 
-    /**
-     * The distance of the far plane.
-     * @type {Number}
-     * @default 500000000.0
-     */
     this.far = options.far;
     this._far = this.far;
 
-    /**
-     * Offsets the frustum in the x direction.
-     * @type {Number}
-     * @default 0.0
-     */
     this.xOffset = options.xOffset;
     this._xOffset = this.xOffset;
 
-    /**
-     * Offsets the frustum in the y direction.
-     * @type {Number}
-     * @default 0.0
-     */
     this.yOffset = options.yOffset;
     this._yOffset = this.yOffset;
   }
 
   /**
    * Returns a duplicate of a PerspectiveFrustum instance.
-   *
-   * @param {PerspectiveFrustum} [result] The object onto which to store the result.
-   * @returns {PerspectiveFrustum} The modified result parameter or a new PerspectiveFrustum instance if one was not provided.
    */
-  clone() {
+  clone(): PerspectiveFrustum {
     return new PerspectiveFrustum({
       aspectRatio: this.aspectRatio,
       fov: this.fov,
@@ -123,11 +121,8 @@ export default class PerspectiveFrustum {
   /**
    * Compares the provided PerspectiveFrustum componentwise and returns
    * <code>true</code> if they are equal, <code>false</code> otherwise.
-   *
-   * @param {PerspectiveFrustum} [other] The right hand side PerspectiveFrustum.
-   * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
    */
-  equals(other) {
+  equals(other: PerspectiveFrustum): boolean {
     if (!defined(other) || !(other instanceof PerspectiveFrustum)) {
       return false;
     }
@@ -146,45 +141,32 @@ export default class PerspectiveFrustum {
 
   /**
    * Gets the perspective projection matrix computed from the view frustum.
-   * @memberof PerspectiveFrustum.prototype
-   * @type {Matrix4}
-   * @readonly
    */
-  get projectionMatrix() {
+  get projectionMatrix(): Matrix4 {
     update(this);
     return this._offCenterFrustum.projectionMatrix;
   }
 
   /**
    * The perspective projection matrix computed from the view frustum with an infinite far plane.
-   * @memberof PerspectiveFrustum.prototype
-   * @type {Matrix4}
-   * @readonly
-   *
-   * @see PerspectiveFrustum#projectionMatrix
    */
-  get infiniteProjectionMatrix() {
+  get infiniteProjectionMatrix(): Matrix4 {
     update(this);
     return this._offCenterFrustum.infiniteProjectionMatrix;
   }
 
   /**
    * Gets the angle of the vertical field of view, in radians.
-   * @memberof PerspectiveFrustum.prototype
-   * @type {Number}
-   * @readonly
-   * @default undefined
    */
-  get fovy() {
+  get fovy(): number {
     update(this);
     return this._fovy;
   }
 
   /**
-   * @readonly
    * @private
    */
-  get sseDenominator() {
+  get sseDenominator(): number {
     update(this);
     return this._sseDenominator;
   }

package/src/lib/{perspective-off-center-frustum.js → perspective-off-center-frustum.ts}

@@ -18,6 +18,29 @@ const scratchPlaneFarCenter = new Vector3();
 const scratchPlaneNormal = new Vector3();
 
 export default class PerspectiveOffCenterFrustum {
+  left;
+  _left;
+  right;
+  _right;
+  top;
+  _top;
+  bottom;
+  _bottom;
+  near;
+  _near;
+  far;
+  _far;
+  _cullingVolume = new CullingVolume([
+    new Plane(),
+    new Plane(),
+    new Plane(),
+    new Plane(),
+    new Plane(),
+    new Plane()
+  ]);
+  _perspectiveMatrix = new Matrix4();
+  _infinitePerspective = new Matrix4();
+
   /**
    * The viewing frustum is defined by 6 planes.
    * Each plane is represented by a {@link Vector4} object, where the x, y, and z components
@@ -47,7 +70,7 @@ export default class PerspectiveOffCenterFrustum {
    *
    * @see PerspectiveFrustum
    */
-  constructor(options = {}) {
+  constructor(options: Record<string, any> = {}) {
     options = {near: 1.0, far: 500000000.0, ...options};
 
     /**
@@ -97,17 +120,6 @@ export default class PerspectiveOffCenterFrustum {
      */
     this.far = options.far;
     this._far = this.far;
-
-    this._cullingVolume = new CullingVolume([
-      new Plane(),
-      new Plane(),
-      new Plane(),
-      new Plane(),
-      new Plane(),
-      new Plane()
-    ]);
-    this._perspectiveMatrix = new Matrix4();
-    this._infinitePerspective = new Matrix4();
   }
 
   /**
@@ -149,7 +161,6 @@ export default class PerspectiveOffCenterFrustum {
    * Gets the perspective projection matrix computed from the view frustum.
    * @memberof PerspectiveOffCenterFrustum.prototype
    * @type {Matrix4}
-   * @readonly
    *
    * @see PerspectiveOffCenterFrustum#infiniteProjectionMatrix
    */
@@ -162,7 +173,6 @@ export default class PerspectiveOffCenterFrustum {
    * Gets the perspective projection matrix computed from the view frustum with an infinite far plane.
    * @memberof PerspectiveOffCenterFrustum.prototype
    * @type {Matrix4}
-   * @readonly
    *
    * @see PerspectiveOffCenterFrustum#projectionMatrix
    */

package/src/lib/{plane.js → plane.ts}

@@ -9,61 +9,68 @@ const scratchNormal = new Vector3();
 
 // A plane in Hessian Normal Form
 export default class Plane {
-  constructor(normal = [0, 0, 1], distance = 0) {
+  readonly normal: Vector3;
+  distance: number;
+
+  constructor(normal: readonly number[] = [0, 0, 1], distance: number = 0) {
     this.normal = new Vector3();
     this.distance = -0;
     this.fromNormalDistance(normal, distance);
   }
 
-  fromNormalDistance(normal, distance) {
+  /** Creates a plane from a normal and a distance from the origin. */
+  fromNormalDistance(normal: readonly number[], distance: number): this {
     assert(Number.isFinite(distance));
     this.normal.from(normal).normalize();
     this.distance = distance;
     return this;
   }
 
-  // Creates a plane from a normal and a point on the plane.
-  fromPointNormal(point, normal) {
+  /** Creates a plane from a normal and a point on the plane. */
+  fromPointNormal(point: readonly number[], normal: readonly number[]): this {
     point = scratchPosition.from(point);
     this.normal.from(normal).normalize();
     const distance = -this.normal.dot(point);
     this.distance = distance;
-
     return this;
   }
 
-  // Creates a plane from the general equation
-  fromCoefficients(a, b, c, d) {
+  /** Creates a plane from the general equation */
+  fromCoefficients(a: number, b: number, c: number, d: number): this {
     this.normal.set(a, b, c);
     assert(equals(this.normal.len(), 1));
     this.distance = d;
     return this;
   }
 
-  // Duplicates a Plane instance.
-  clone(plane) {
+  /** Duplicates a Plane instance. */
+  clone(): Plane {
     return new Plane(this.normal, this.distance);
   }
 
-  // Compares the provided Planes by normal and distance
-  equals(right) {
+  /** Compares the provided Planes by normal and distance */
+  equals(right: Plane): boolean {
     return equals(this.distance, right.distance) && equals(this.normal, right.normal);
   }
 
-  // Computes the signed shortest distance of a point to a plane.
-  // The sign of the distance determines which side of the plane the point is on.
-  getPointDistance(point) {
+  /** Computes the signed shortest distance of a point to a plane.
+   * The sign of the distance determines which side of the plane the point is on.
+   */
+  getPointDistance(point: readonly number[]): number {
     return this.normal.dot(point) + this.distance;
   }
 
-  // Transforms the plane by the given transformation matrix.
-  transform(matrix4) {
+  /** Transforms the plane by the given transformation matrix. */
+  transform(matrix4: readonly number[]): this {
     const normal = scratchNormal.copy(this.normal).transformAsVector(matrix4).normalize();
     const point = this.normal.scale(-this.distance).transform(matrix4);
     return this.fromPointNormal(point, normal);
   }
 
-  // Projects a point onto the plane.
+  /** Projects a point onto the plane. */
+  projectPointOntoPlane(point: readonly number[], result: Vector3): Vector3;
+  projectPointOntoPlane(point: readonly number[], result?: readonly number[]): readonly number[];
+
   projectPointOntoPlane(point, result = [0, 0, 0]) {
     point = scratchPosition.from(point);
     // projectedPoint = point - (normal.point + scale) * normal

package/dist/es5/constants.d.ts

@@ -1,6 +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
-
-export type INTERSECTION_ENUM = number;
-
-export const INTERSECTION: {[id: string]: number};

package/dist/es5/index.d.ts

@@ -1,20 +0,0 @@
-export {default as BoundingVolume} from './lib/bounding-volumes/bounding-volume';
-export {default as BoundingSphere} from './lib/bounding-volumes/bounding-sphere';
-export {default as AxisAlignedBoundingBox} from './lib/bounding-volumes/axis-aligned-bounding-box';
-export {default as OrientedBoundingBox} from './lib/bounding-volumes/oriented-bounding-box';
-
-export {default as CullingVolume} from './lib/culling-volume';
-export {default as Plane} from './lib/plane';
-
-export {default as makeBoundingSphereFromPoints} from './lib/algorithms/bounding-sphere-from-points';
-export {
-  makeAxisAlignedBoundingBoxFromPoints,
-  makeOrientedBoundingBoxFromPoints
-} from './lib/algorithms/bounding-box-from-points';
-export {default as computeEigenDecomposition} from './lib/algorithms/compute-eigen-decomposition';
-
-// Experimental, decide how to handle enums in typescript
-export {INTERSECTION_ENUM, INTERSECTION} from './constants';
-
-export type _PerspectiveFrustum = object;
-export type _PerspectiveOffCenterFrustum = object;

package/dist/es5/lib/algorithms/bounding-box-from-points.d.ts

@@ -1,22 +0,0 @@
-import OrientedBoundingBox from '../bounding-volumes/oriented-bounding-box';
-import AxisAlignedBoundingBox from '../bounding-volumes/axis-aligned-bounding-box';
-
-/**
- * Computes an instance of an OrientedBoundingBox of the given positions.
- *
- * This is an implementation of Stefan Gottschalk's Collision Queries using Oriented Bounding Boxes solution (PHD thesis).
- * Reference: http://gamma.cs.unc.edu/users/gottschalk/main.pdf
- */
-export function makeOrientedBoundingBoxFromPoints(
-  positions: number[][],
-  result?: OrientedBoundingBox
-): OrientedBoundingBox;
-
-/**
- * Computes an instance of an AxisAlignedBoundingBox. The box is determined by
- * finding the points spaced the farthest apart on the x, y, and z axes.
- */
-export function makeAxisAlignedBoundingBoxFromPoints(
-  positions: readonly number[][],
-  result?: AxisAlignedBoundingBox
-): AxisAlignedBoundingBox;

package/dist/es5/lib/algorithms/bounding-sphere-from-points.d.ts

@@ -1,17 +0,0 @@
-import BoundingSphere from '../bounding-volumes/bounding-sphere';
-
-/**
- * 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: number[][],
-  result?: BoundingSphere
-): BoundingSphere;

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

@@ -1,51 +0,0 @@
-import {BoundingVolume} from './bounding-volume';
-import {Vector3} from '@math.gl/core';
-import Plane from '../plane';
-import {INTERSECTION_ENUM} 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. */
-  clone(): AxisAlignedBoundingBox;
-  /** Compares the provided AxisAlignedBoundingBox component wise */
-  equals(right: AxisAlignedBoundingBox): boolean;
-
-  // BoundingVolume interface
-
-  /**
-   * 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;
-
-  /** 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;
-
-  /** Determines which side of a plane a box is located. */
-  intersectPlane(plane: Plane): INTERSECTION_ENUM;
-}

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

@@ -1,52 +0,0 @@
-import {BoundingVolume} from './bounding-volume';
-import {Vector3} from '@math.gl/core';
-import {INTERSECTION_ENUM} from '../../constants';
-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(): this;
-
-  /** Computes a bounding sphere that contains both the left and right bounding spheres. */
-  union(boundingSphere: BoundingSphere): this;
-
-  /** Computes a bounding sphere by enlarging the provided sphere to contain the provided point. */
-  expand(point: readonly number[]): 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: 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 a sphere is located. */
-  intersectPlane(plane: Plane): INTERSECTION_ENUM;
-}

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

@@ -1,32 +0,0 @@
-import {INTERSECTION_ENUM} 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_ENUM;
-}