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

package/src/lib/bounding-volumes/{oriented-bounding-box.js → oriented-bounding-box.ts}

@@ -1,8 +1,10 @@
 // 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 {Vector3, Matrix3, Quaternion, NumericArray} from '@math.gl/core';
+import type {BoundingVolume} from './bounding-volume';
 import BoundingSphere from './bounding-sphere';
+import type Plane from '../plane';
 import {INTERSECTION} from '../../constants';
 
 const scratchVector3 = new Vector3();
@@ -25,20 +27,36 @@ const MATRIX3 = {
   COLUMN2ROW2: 8
 };
 
-export default class OrientedBoundingBox {
-  constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
+/**
+ * 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 implements BoundingVolume {
+  center: Vector3;
+  halfAxes: Matrix3;
+
+  /**
+   * 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.
+   */
+  constructor(center?: readonly number[], halfAxes?: readonly number[]);
+  constructor(center: Readonly<NumericArray> = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
     this.center = new Vector3().from(center);
     this.halfAxes = new Matrix3(halfAxes);
   }
 
-  get halfSize() {
+  /** Returns an array with three halfSizes for the bounding box */
+  get halfSize(): number[] {
     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()];
   }
 
-  get quaternion() {
+  /** Returns a quaternion describing the orientation of the bounding box */
+  get quaternion(): Quaternion {
     const xAxis = this.halfAxes.getColumn(0);
     const yAxis = this.halfAxes.getColumn(1);
     const zAxis = this.halfAxes.getColumn(2);
@@ -48,7 +66,14 @@ export default class OrientedBoundingBox {
     return new Quaternion().fromMatrix3(new Matrix3([...normXAxis, ...normYAxis, ...normZAxis]));
   }
 
-  fromCenterHalfSizeQuaternion(center, halfSize, quaternion) {
+  /**
+   * Create OrientedBoundingBox from quaternion based OBB,
+   */
+  fromCenterHalfSizeQuaternion(
+    center: number[],
+    halfSize: number[],
+    quaternion: number[]
+  ): OrientedBoundingBox {
     const quaternionObject = new Quaternion(quaternion);
     const directionsMatrix = new Matrix3().fromQuaternion(quaternionObject);
     directionsMatrix[0] = directionsMatrix[0] * halfSize[0];
@@ -65,18 +90,21 @@ export default class OrientedBoundingBox {
     return this;
   }
 
-  clone() {
+  /** Duplicates a OrientedBoundingBox instance. */
+  clone(): OrientedBoundingBox {
     return new OrientedBoundingBox(this.center, this.halfAxes);
   }
 
-  equals(right) {
+  /** Compares the provided OrientedBoundingBox component wise and returns */
+  equals(right: OrientedBoundingBox): boolean {
     return (
       this === right ||
       (Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes))
     );
   }
 
-  getBoundingSphere(result = new BoundingSphere()) {
+  /** Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box. */
+  getBoundingSphere(result = new BoundingSphere()): BoundingSphere {
     const halfAxes = this.halfAxes;
     const u = halfAxes.getColumn(0, scratchVectorU);
     const v = halfAxes.getColumn(1, scratchVectorV);
@@ -91,7 +119,8 @@ export default class OrientedBoundingBox {
     return result;
   }
 
-  intersectPlane(plane) {
+  /** Determines which side of a plane the oriented bounding box is located. */
+  intersectPlane(plane: Plane): INTERSECTION {
     const center = this.center;
     const normal = plane.normal;
     const halfAxes = this.halfAxes;
@@ -129,11 +158,17 @@ export default class OrientedBoundingBox {
     return INTERSECTION.INTERSECTING;
   }
 
-  distanceTo(point) {
+  /** Computes the estimated distance from the closest point on a bounding box to a point. */
+  distanceTo(point: readonly number[]): number {
     return Math.sqrt(this.distanceSquaredTo(point));
   }
 
-  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: readonly number[]): number {
     // 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
@@ -173,8 +208,26 @@ export default class OrientedBoundingBox {
     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]) {
+  computePlaneDistances(
+    position: readonly number[],
+    direction: Vector3,
+    result: number[] = [-0, -0]
+  ): number[] {
     let minDist = Number.POSITIVE_INFINITY;
     let maxDist = Number.NEGATIVE_INFINITY;
 
@@ -262,7 +315,12 @@ export default class OrientedBoundingBox {
     return result;
   }
 
-  transform(transformation) {
+  /**
+   * 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: readonly number[]): this {
     this.center.transformAsPoint(transformation);
 
     const xAxis = this.halfAxes.getColumn(0, scratchVectorU);

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;