@math.gl/culling 4.0.0 → 4.0.1

package/dist/lib/perspective-off-center-frustum.js

@@ -1,4 +1,8 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// This file is derived from the Cesium math library under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+// Note: This class is still an experimental export, mainly used by other test cases
+// - It has not been fully adapted to math.gl conventions
+// - Documentation has not been ported
 import { Vector3, Matrix4, assert } from '@math.gl/core';
 import { CullingVolume } from "./culling-volume.js";
 import { Plane } from "./plane.js";
@@ -8,162 +12,259 @@ const scratchPlaneNearCenter = new Vector3();
 const scratchPlaneFarCenter = new Vector3();
 const scratchPlaneNormal = new Vector3();
 export class PerspectiveOffCenterFrustum {
-  constructor(options = {}) {
-    _defineProperty(this, "left", void 0);
-
-    _defineProperty(this, "_left", void 0);
-
-    _defineProperty(this, "right", void 0);
-
-    _defineProperty(this, "_right", void 0);
-
-    _defineProperty(this, "top", void 0);
-
-    _defineProperty(this, "_top", void 0);
-
-    _defineProperty(this, "bottom", void 0);
-
-    _defineProperty(this, "_bottom", void 0);
-
-    _defineProperty(this, "near", void 0);
-
-    _defineProperty(this, "_near", void 0);
-
-    _defineProperty(this, "far", void 0);
-
-    _defineProperty(this, "_far", void 0);
-
-    _defineProperty(this, "_cullingVolume", new CullingVolume([new Plane(), new Plane(), new Plane(), new Plane(), new Plane(), new Plane()]));
-
-    _defineProperty(this, "_perspectiveMatrix", new Matrix4());
-
-    _defineProperty(this, "_infinitePerspective", new Matrix4());
-
-    const {
-      near = 1.0,
-      far = 500000000.0
-    } = options;
-    this.left = options.left;
-    this._left = undefined;
-    this.right = options.right;
-    this._right = undefined;
-    this.top = options.top;
-    this._top = undefined;
-    this.bottom = options.bottom;
-    this._bottom = undefined;
-    this.near = near;
-    this._near = near;
-    this.far = far;
-    this._far = far;
-  }
-
-  clone() {
-    return new PerspectiveOffCenterFrustum({
-      right: this.right,
-      left: this.left,
-      top: this.top,
-      bottom: this.bottom,
-      near: this.near,
-      far: this.far
-    });
-  }
-
-  equals(other) {
-    return other && other instanceof PerspectiveOffCenterFrustum && this.right === other.right && this.left === other.left && this.top === other.top && this.bottom === other.bottom && this.near === other.near && this.far === other.far;
-  }
-
-  get projectionMatrix() {
-    this._update();
-
-    return this._perspectiveMatrix;
-  }
-
-  get infiniteProjectionMatrix() {
-    this._update();
-
-    return this._infinitePerspective;
-  }
-
-  computeCullingVolume(position, direction, up) {
-    assert(position, 'position is required.');
-    assert(direction, 'direction is required.');
-    assert(up, 'up is required.');
-    const planes = this._cullingVolume.planes;
-    up = scratchPlaneUpVector.copy(up).normalize();
-    const right = scratchPlaneRightVector.copy(direction).cross(up).normalize();
-    const nearCenter = scratchPlaneNearCenter.copy(direction).multiplyByScalar(this.near).add(position);
-    const farCenter = scratchPlaneFarCenter.copy(direction).multiplyByScalar(this.far).add(position);
-    let normal = scratchPlaneNormal;
-    normal.copy(right).multiplyByScalar(this.left).add(nearCenter).subtract(position).cross(up);
-    planes[0].fromPointNormal(position, normal);
-    normal.copy(right).multiplyByScalar(this.right).add(nearCenter).subtract(position).cross(up).negate();
-    planes[1].fromPointNormal(position, normal);
-    normal.copy(up).multiplyByScalar(this.bottom).add(nearCenter).subtract(position).cross(right).negate();
-    planes[2].fromPointNormal(position, normal);
-    normal.copy(up).multiplyByScalar(this.top).add(nearCenter).subtract(position).cross(right);
-    planes[3].fromPointNormal(position, normal);
-    normal = new Vector3().copy(direction);
-    planes[4].fromPointNormal(nearCenter, normal);
-    normal.negate();
-    planes[5].fromPointNormal(farCenter, normal);
-    return this._cullingVolume;
-  }
-
-  getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result) {
-    this._update();
-
-    assert(Number.isFinite(drawingBufferWidth) && Number.isFinite(drawingBufferHeight));
-    assert(drawingBufferWidth > 0);
-    assert(drawingBufferHeight > 0);
-    assert(distance > 0);
-    assert(result);
-    const inverseNear = 1.0 / this.near;
-    let tanTheta = this.top * inverseNear;
-    const pixelHeight = 2.0 * distance * tanTheta / drawingBufferHeight;
-    tanTheta = this.right * inverseNear;
-    const pixelWidth = 2.0 * distance * tanTheta / drawingBufferWidth;
-    result.x = pixelWidth;
-    result.y = pixelHeight;
-    return result;
-  }
-
-  _update() {
-    assert(Number.isFinite(this.right) && Number.isFinite(this.left) && Number.isFinite(this.top) && Number.isFinite(this.bottom) && Number.isFinite(this.near) && Number.isFinite(this.far));
-    const {
-      top,
-      bottom,
-      right,
-      left,
-      near,
-      far
-    } = this;
-
-    if (top !== this._top || bottom !== this._bottom || left !== this._left || right !== this._right || near !== this._near || far !== this._far) {
-      assert(this.near > 0 && this.near < this.far, 'near must be greater than zero and less than far.');
-      this._left = left;
-      this._right = right;
-      this._top = top;
-      this._bottom = bottom;
-      this._near = near;
-      this._far = far;
-      this._perspectiveMatrix = new Matrix4().frustum({
-        left,
-        right,
-        bottom,
-        top,
-        near,
-        far
-      });
-      this._infinitePerspective = new Matrix4().frustum({
-        left,
-        right,
-        bottom,
-        top,
-        near,
-        far: Infinity
-      });
+    /**
+     * The viewing frustum is defined by 6 planes.
+     * Each plane is represented by a {@link Vector4} object, where the x, y, and z components
+     * define the unit vector normal to the plane, and the w component is the distance of the
+     * plane from the origin/camera position.
+     *
+     * @alias PerspectiveOffCenterFrustum
+     *
+     * @example
+     * const frustum = new PerspectiveOffCenterFrustum({
+     *     left : -1.0,
+     *     right : 1.0,
+     *     top : 1.0,
+     *     bottom : -1.0,
+     *     near : 1.0,
+     *     far : 100.0
+     * });
+     *
+     * @see PerspectiveFrustum
+     */
+    constructor(options = {}) {
+        this._cullingVolume = new CullingVolume([
+            new Plane(),
+            new Plane(),
+            new Plane(),
+            new Plane(),
+            new Plane(),
+            new Plane()
+        ]);
+        this._perspectiveMatrix = new Matrix4();
+        this._infinitePerspective = new Matrix4();
+        const { near = 1.0, far = 500000000.0 } = options;
+        this.left = options.left;
+        this._left = undefined;
+        this.right = options.right;
+        this._right = undefined;
+        this.top = options.top;
+        this._top = undefined;
+        this.bottom = options.bottom;
+        this._bottom = undefined;
+        this.near = near;
+        this._near = near;
+        this.far = far;
+        this._far = far;
+    }
+    /**
+     * Returns a duplicate of a PerspectiveOffCenterFrustum instance.
+     * @returns {PerspectiveOffCenterFrustum} A new PerspectiveFrustum instance.
+     * */
+    clone() {
+        return new PerspectiveOffCenterFrustum({
+            right: this.right,
+            left: this.left,
+            top: this.top,
+            bottom: this.bottom,
+            near: this.near,
+            far: this.far
+        });
+    }
+    /**
+     * Compares the provided PerspectiveOffCenterFrustum componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     *
+     * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
+     */
+    equals(other) {
+        return (other &&
+            other instanceof PerspectiveOffCenterFrustum &&
+            this.right === other.right &&
+            this.left === other.left &&
+            this.top === other.top &&
+            this.bottom === other.bottom &&
+            this.near === other.near &&
+            this.far === other.far);
+    }
+    /**
+     * Gets the perspective projection matrix computed from the view frustum.
+     * @memberof PerspectiveOffCenterFrustum.prototype
+     * @type {Matrix4}
+     *
+     * @see PerspectiveOffCenterFrustum#infiniteProjectionMatrix
+     */
+    get projectionMatrix() {
+        this._update();
+        return this._perspectiveMatrix;
+    }
+    /**
+     * Gets the perspective projection matrix computed from the view frustum with an infinite far plane.
+     * @memberof PerspectiveOffCenterFrustum.prototype
+     * @type {Matrix4}
+     *
+     * @see PerspectiveOffCenterFrustum#projectionMatrix
+     */
+    get infiniteProjectionMatrix() {
+        this._update();
+        return this._infinitePerspective;
+    }
+    /**
+     * Creates a culling volume for this frustum.
+     * @returns {CullingVolume} A culling volume at the given position and orientation.
+     *
+     * @example
+     * // Check if a bounding volume intersects the frustum.
+     * const cullingVolume = frustum.computeCullingVolume(cameraPosition, cameraDirection, cameraUp);
+     * const intersect = cullingVolume.computeVisibility(boundingVolume);
+     */
+    // eslint-disable-next-line complexity, max-statements
+    computeCullingVolume(
+    /** A Vector3 defines the eye position. */
+    position, 
+    /** A Vector3 defines the view direction. */
+    direction, 
+    /** A Vector3 defines the up direction. */
+    up) {
+        assert(position, 'position is required.');
+        assert(direction, 'direction is required.');
+        assert(up, 'up is required.');
+        const planes = this._cullingVolume.planes;
+        up = scratchPlaneUpVector.copy(up).normalize();
+        const right = scratchPlaneRightVector.copy(direction).cross(up).normalize();
+        const nearCenter = scratchPlaneNearCenter
+            .copy(direction)
+            .multiplyByScalar(this.near)
+            .add(position);
+        const farCenter = scratchPlaneFarCenter
+            .copy(direction)
+            .multiplyByScalar(this.far)
+            .add(position);
+        let normal = scratchPlaneNormal;
+        // Left plane computation
+        normal.copy(right).multiplyByScalar(this.left).add(nearCenter).subtract(position).cross(up);
+        planes[0].fromPointNormal(position, normal);
+        // Right plane computation
+        normal
+            .copy(right)
+            .multiplyByScalar(this.right)
+            .add(nearCenter)
+            .subtract(position)
+            .cross(up)
+            .negate();
+        planes[1].fromPointNormal(position, normal);
+        // Bottom plane computation
+        normal
+            .copy(up)
+            .multiplyByScalar(this.bottom)
+            .add(nearCenter)
+            .subtract(position)
+            .cross(right)
+            .negate();
+        planes[2].fromPointNormal(position, normal);
+        // Top plane computation
+        normal.copy(up).multiplyByScalar(this.top).add(nearCenter).subtract(position).cross(right);
+        planes[3].fromPointNormal(position, normal);
+        normal = new Vector3().copy(direction);
+        // Near plane computation
+        planes[4].fromPointNormal(nearCenter, normal);
+        // Far plane computation
+        normal.negate();
+        planes[5].fromPointNormal(farCenter, normal);
+        return this._cullingVolume;
+    }
+    /**
+     * Returns the pixel's width and height in meters.
+     *
+     * @returns {Vector2} The modified result parameter or a new instance of {@link Vector2} with the pixel's width and height in the x and y properties, respectively.
+     *
+     * @exception {DeveloperError} drawingBufferWidth must be greater than zero.
+     * @exception {DeveloperError} drawingBufferHeight must be greater than zero.
+     *
+     * @example
+     * // Example 1
+     * // Get the width and height of a pixel.
+     * const pixelSize = camera.frustum.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, 1.0, new Vector2());
+     *
+     * @example
+     * // Example 2
+     * // Get the width and height of a pixel if the near plane was set to 'distance'.
+     * // For example, get the size of a pixel of an image on a billboard.
+     * const position = camera.position;
+     * const direction = camera.direction;
+     * const toCenter = Vector3.subtract(primitive.boundingVolume.center, position, new Vector3());      // vector from camera to a primitive
+     * const toCenterProj = Vector3.multiplyByScalar(direction, Vector3.dot(direction, toCenter), new Vector3()); // project vector onto camera direction vector
+     * const distance = Vector3.magnitude(toCenterProj);
+     * const pixelSize = camera.frustum.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, distance, new Vector2());
+     */
+    getPixelDimensions(
+    /** The width of the drawing buffer. */
+    drawingBufferWidth, 
+    /** The height of the drawing buffer. */
+    drawingBufferHeight, 
+    /** The distance to the near plane in meters. */
+    distance, 
+    /** The object onto which to store the result. */
+    result) {
+        this._update();
+        assert(Number.isFinite(drawingBufferWidth) && Number.isFinite(drawingBufferHeight));
+        // 'Both drawingBufferWidth and drawingBufferHeight are required.'
+        assert(drawingBufferWidth > 0);
+        // 'drawingBufferWidth must be greater than zero.'
+        assert(drawingBufferHeight > 0);
+        // 'drawingBufferHeight must be greater than zero.'
+        assert(distance > 0);
+        // 'distance is required.');
+        assert(result);
+        // 'A result object is required.');
+        const inverseNear = 1.0 / this.near;
+        let tanTheta = this.top * inverseNear;
+        const pixelHeight = (2.0 * distance * tanTheta) / drawingBufferHeight;
+        tanTheta = this.right * inverseNear;
+        const pixelWidth = (2.0 * distance * tanTheta) / drawingBufferWidth;
+        result.x = pixelWidth;
+        result.y = pixelHeight;
+        return result;
+    }
+    // eslint-disable-next-line complexity, max-statements
+    _update() {
+        assert(Number.isFinite(this.right) &&
+            Number.isFinite(this.left) &&
+            Number.isFinite(this.top) &&
+            Number.isFinite(this.bottom) &&
+            Number.isFinite(this.near) &&
+            Number.isFinite(this.far));
+        // throw new DeveloperError('right, left, top, bottom, near, or far parameters are not set.');
+        const { top, bottom, right, left, near, far } = this;
+        if (top !== this._top ||
+            bottom !== this._bottom ||
+            left !== this._left ||
+            right !== this._right ||
+            near !== this._near ||
+            far !== this._far) {
+            assert(this.near > 0 && this.near < this.far, 'near must be greater than zero and less than far.');
+            this._left = left;
+            this._right = right;
+            this._top = top;
+            this._bottom = bottom;
+            this._near = near;
+            this._far = far;
+            this._perspectiveMatrix = new Matrix4().frustum({
+                left,
+                right,
+                bottom,
+                top,
+                near,
+                far
+            });
+            this._infinitePerspective = new Matrix4().frustum({
+                left,
+                right,
+                bottom,
+                top,
+                near,
+                far: Infinity
+            });
+        }
     }
-  }
-
 }
-//# sourceMappingURL=perspective-off-center-frustum.js.map

package/dist/lib/plane.d.ts

@@ -23,4 +23,3 @@ export declare class Plane {
     projectPointOntoPlane(point: Readonly<NumericArray>, result: Vector3): Vector3;
     projectPointOntoPlane(point: Readonly<NumericArray>, result?: readonly number[]): readonly number[];
 }
-//# sourceMappingURL=plane.d.ts.map

package/dist/lib/plane.js

@@ -1,64 +1,63 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// This file is derived from the Cesium math library under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+/* eslint-disable */
 import { Vector3, equals, assert } from '@math.gl/core';
 const scratchPosition = new Vector3();
 const scratchNormal = new Vector3();
+// A plane in Hessian Normal Form
 export class Plane {
-  constructor(normal = [0, 0, 1], distance = 0) {
-    _defineProperty(this, "normal", void 0);
-
-    _defineProperty(this, "distance", void 0);
-
-    this.normal = new Vector3();
-    this.distance = -0;
-    this.fromNormalDistance(normal, distance);
-  }
-
-  fromNormalDistance(normal, distance) {
-    assert(Number.isFinite(distance));
-    this.normal.from(normal).normalize();
-    this.distance = distance;
-    return this;
-  }
-
-  fromPointNormal(point, normal) {
-    point = scratchPosition.from(point);
-    this.normal.from(normal).normalize();
-    const distance = -this.normal.dot(point);
-    this.distance = distance;
-    return this;
-  }
-
-  fromCoefficients(a, b, c, d) {
-    this.normal.set(a, b, c);
-    assert(equals(this.normal.len(), 1));
-    this.distance = d;
-    return this;
-  }
-
-  clone() {
-    return new Plane(this.normal, this.distance);
-  }
-
-  equals(right) {
-    return equals(this.distance, right.distance) && equals(this.normal, right.normal);
-  }
-
-  getPointDistance(point) {
-    return this.normal.dot(point) + this.distance;
-  }
-
-  transform(matrix4) {
-    const normal = scratchNormal.copy(this.normal).transformAsVector(matrix4).normalize();
-    const point = this.normal.scale(-this.distance).transform(matrix4);
-    return this.fromPointNormal(point, normal);
-  }
-
-  projectPointOntoPlane(point, result = [0, 0, 0]) {
-    const scratchPoint = scratchPosition.from(point);
-    const pointDistance = this.getPointDistance(scratchPoint);
-    const scaledNormal = scratchNormal.copy(this.normal).scale(pointDistance);
-    return scratchPoint.subtract(scaledNormal).to(result);
-  }
-
+    constructor(normal = [0, 0, 1], distance = 0) {
+        this.normal = new Vector3();
+        this.distance = -0;
+        this.fromNormalDistance(normal, distance);
+    }
+    /** Creates a plane from a normal and a distance from the origin. */
+    fromNormalDistance(normal, distance) {
+        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) {
+        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) {
+        this.normal.set(a, b, c);
+        assert(equals(this.normal.len(), 1));
+        this.distance = d;
+        return this;
+    }
+    /** Duplicates a Plane instance. */
+    clone() {
+        return new Plane(this.normal, this.distance);
+    }
+    /** Compares the provided Planes by normal and distance */
+    equals(right) {
+        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) {
+        return this.normal.dot(point) + this.distance;
+    }
+    /** Transforms the plane by the given transformation matrix. */
+    transform(matrix4) {
+        const normal = scratchNormal.copy(this.normal).transformAsVector(matrix4).normalize();
+        const point = this.normal.scale(-this.distance).transform(matrix4);
+        return this.fromPointNormal(point, normal);
+    }
+    projectPointOntoPlane(point, result = [0, 0, 0]) {
+        const scratchPoint = scratchPosition.from(point);
+        // projectedPoint = point - (normal.point + scale) * normal
+        const pointDistance = this.getPointDistance(scratchPoint);
+        const scaledNormal = scratchNormal.copy(this.normal).scale(pointDistance);
+        return scratchPoint.subtract(scaledNormal).to(result);
+    }
 }
-//# sourceMappingURL=plane.js.map

package/package.json

@@ -6,7 +6,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "4.0.0",
+  "version": "4.0.1",
   "keywords": [
     "webgl",
     "javascript",
@@ -32,9 +32,9 @@
   "module": "dist/index.js",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.cjs"
     }
   },
   "files": [
@@ -42,8 +42,7 @@
     "src"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.12.0",
-    "@math.gl/core": "4.0.0"
+    "@math.gl/core": "4.0.1"
   },
-  "gitHead": "b7af99a25965af5112307552084fbaf5d4d53b7d"
+  "gitHead": "33f369ba3a259f79acc3fa8181190c9da8841648"
 }

package/dist/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;CAIf,CAAC"}

package/dist/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/constants.ts"],"names":["INTERSECTION","OUTSIDE","INTERSECTING","INSIDE"],"mappings":"AAGA,OAAO,MAAMA,YAAY,GAAG;AAC1BC,EAAAA,OAAO,EAAE,CAAC,CADgB;AAE1BC,EAAAA,YAAY,EAAE,CAFY;AAG1BC,EAAAA,MAAM,EAAE;AAHkB,CAArB","sourcesContent":["// This file is derived from the Cesium math library under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nexport const INTERSECTION = {\n  OUTSIDE: -1, // Represents that an object is not contained within the frustum.\n  INTERSECTING: 0, // Represents that an object intersects one of the frustum's planes.\n  INSIDE: 1 // Represents that an object is fully within the frustum.\n} as const;\n"],"file":"constants.js"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAC,sBAAsB,EAAC,MAAM,kDAAkD,CAAC;AACxF,OAAO,EAAC,cAAc,EAAC,MAAM,wCAAwC,CAAC;AACtE,OAAO,EAAC,mBAAmB,EAAC,MAAM,8CAA8C,CAAC;AACjF,OAAO,EAAC,aAAa,EAAC,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAC,KAAK,EAAC,MAAM,aAAa,CAAC;AAElC,OAAO,EAAC,2BAA2B,IAAI,4BAA4B,EAAC,MAAM,sCAAsC,CAAC;AACjH,OAAO,EAAC,kBAAkB,IAAI,mBAAmB,EAAC,MAAM,2BAA2B,CAAC;AAEpF,OAAO,EAAC,4BAA4B,EAAC,MAAM,8CAA8C,CAAC;AAC1F,OAAO,EACL,oCAAoC,EACpC,iCAAiC,EAClC,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAC,yBAAyB,EAAC,MAAM,8CAA8C,CAAC"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"names":["INTERSECTION","AxisAlignedBoundingBox","BoundingSphere","OrientedBoundingBox","CullingVolume","Plane","PerspectiveOffCenterFrustum","_PerspectiveOffCenterFrustum","PerspectiveFrustum","_PerspectiveFrustum","makeBoundingSphereFromPoints","makeAxisAlignedBoundingBoxFromPoints","makeOrientedBoundingBoxFromPoints","computeEigenDecomposition"],"mappings":"SAGQA,Y;SAEAC,sB;SACAC,c;SACAC,mB;SACAC,a;SACAC,K;SAEAC,2BAA2B,IAAIC,4B;SAC/BC,kBAAkB,IAAIC,mB;SAEtBC,4B;SAENC,oC,EACAC,iC;SAEMC,yB","sourcesContent":["// This file is derived from the Cesium math library under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nexport {INTERSECTION} from './constants';\n\nexport {AxisAlignedBoundingBox} from './lib/bounding-volumes/axis-aligned-bounding-box';\nexport {BoundingSphere} from './lib/bounding-volumes/bounding-sphere';\nexport {OrientedBoundingBox} from './lib/bounding-volumes/oriented-bounding-box';\nexport {CullingVolume} from './lib/culling-volume';\nexport {Plane} from './lib/plane';\n\nexport {PerspectiveOffCenterFrustum as _PerspectiveOffCenterFrustum} from './lib/perspective-off-center-frustum';\nexport {PerspectiveFrustum as _PerspectiveFrustum} from './lib/perspective-frustum';\n\nexport {makeBoundingSphereFromPoints} from './lib/algorithms/bounding-sphere-from-points';\nexport {\n  makeAxisAlignedBoundingBoxFromPoints,\n  makeOrientedBoundingBoxFromPoints\n} from './lib/algorithms/bounding-box-from-points';\nexport {computeEigenDecomposition} from './lib/algorithms/compute-eigen-decomposition';\n"],"file":"index.js"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"bounding-box-from-points.d.ts","sourceRoot":"","sources":["../../../src/lib/algorithms/bounding-box-from-points.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,mBAAmB,EAAC,MAAM,2CAA2C,CAAC;AAC9E,OAAO,EAAC,sBAAsB,EAAC,MAAM,+CAA+C,CAAC;AAmBrF;;;;;GAKG;AAEH,wBAAgB,iCAAiC,CAC/C,SAAS,EAAE,MAAM,EAAE,EAAE,EACrB,MAAM,GAAE,mBAA+C,GACtD,mBAAmB,CAuFrB;AAED;;;GAGG;AACH,wBAAgB,oCAAoC,CAClD,SAAS,EAAE,SAAS,MAAM,EAAE,EAAE,EAC9B,MAAM,GAAE,sBAAqD,GAC5D,sBAAsB,CAoCxB"}