@math.gl/culling 3.6.3 → 4.0.0-alpha.2

package/dist/lib/perspective-frustum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"perspective-frustum.d.ts","sourceRoot":"","sources":["../../src/lib/perspective-frustum.ts"],"names":[],"mappings":"AAOA,OAAO,EAAS,OAAO,EAAE,YAAY,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAErE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAI7C,aAAK,yBAAyB,GAAG;IAC/B,wDAAwD;IACxD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAkB;IACrC,OAAO,CAAC,iBAAiB,CAAqC;IAC9D;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,eAAe,CAAS;IAChC;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,YAAY,CAAS;IAC7B;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,KAAK,CAAS;IACtB;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,IAAI,CAAS;IACrB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,QAAQ,CAAS;IACzB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,QAAQ,CAAS;gBAEb,OAAO,GAAE,yBAA8B;IAWnD;;OAEG;IACH,KAAK,IAAI,kBAAkB;IAS3B;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO;IAiB1C;;OAEG;IACH,IAAI,gBAAgB,IAAI,OAAO,CAG9B;IAED;;OAEG;IACH,IAAI,wBAAwB,IAAI,OAAO,CAGtC;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAGjB;IAED;;OAEG;IACH,IAAI,cAAc,IAAI,MAAM,CAG3B;IAED;;;;;;;;OAQG;IACH,oBAAoB;IAClB,0CAA0C;IAC1C,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC;IAChC,4CAA4C;IAC5C,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC;IACjC,0CAA0C;IAC1C,EAAE,EAAE,QAAQ,CAAC,YAAY,CAAC,GACzB,aAAa;IAKhB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,kBAAkB;IAChB,uCAAuC;IACvC,kBAAkB,EAAE,MAAM;IAC1B,wCAAwC;IACxC,mBAAmB,EAAE,MAAM;IAC3B,gDAAgD;IAChD,QAAQ,EAAE,MAAM;IAChB,iDAAiD;IACjD,MAAM,CAAC,EAAE,OAAO,GACf,OAAO;IAWV,OAAO,CAAC,OAAO;CAqDhB"}
+{"version":3,"file":"perspective-frustum.d.ts","sourceRoot":"","sources":["../../src/lib/perspective-frustum.ts"],"names":[],"mappings":"AAOA,OAAO,EAAS,OAAO,EAAE,YAAY,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAErE,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAI/C,aAAK,yBAAyB,GAAG;IAC/B,wDAAwD;IACxD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,iBAAiB,CAAqC;IAC9D;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,eAAe,CAAS;IAChC;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,YAAY,CAAS;IAC7B;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,KAAK,CAAS;IACtB;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,IAAI,CAAS;IACrB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,QAAQ,CAAS;IACzB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,QAAQ,CAAS;gBAEb,OAAO,GAAE,yBAA8B;IAWnD;;OAEG;IACH,KAAK,IAAI,kBAAkB;IAS3B;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO;IAiB1C;;OAEG;IACH,IAAI,gBAAgB,IAAI,OAAO,CAG9B;IAED;;OAEG;IACH,IAAI,wBAAwB,IAAI,OAAO,CAGtC;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAGjB;IAED;;OAEG;IACH,IAAI,cAAc,IAAI,MAAM,CAG3B;IAED;;;;;;;;OAQG;IACH,oBAAoB;IAClB,0CAA0C;IAC1C,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC;IAChC,4CAA4C;IAC5C,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC;IACjC,0CAA0C;IAC1C,EAAE,EAAE,QAAQ,CAAC,YAAY,CAAC,GACzB,aAAa;IAKhB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,kBAAkB;IAChB,uCAAuC;IACvC,kBAAkB,EAAE,MAAM;IAC1B,wCAAwC;IACxC,mBAAmB,EAAE,MAAM;IAC3B,gDAAgD;IAChD,QAAQ,EAAE,MAAM;IAChB,iDAAiD;IACjD,MAAM,CAAC,EAAE,OAAO,GACf,OAAO;IAWV,OAAO,CAAC,OAAO;CAqDhB"}

package/dist/{esm/lib → lib}/perspective-frustum.js

@@ -1,10 +1,10 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { assert, Vector2 } from '@math.gl/core';
-import PerspectiveOffCenterFrustum from './perspective-off-center-frustum';
+import { PerspectiveOffCenterFrustum } from "./perspective-off-center-frustum.js";
 
 const defined = val => val !== null && typeof val !== 'undefined';
 
-export default class PerspectiveFrustum {
+export class PerspectiveFrustum {
   constructor(options = {}) {
     _defineProperty(this, "_offCenterFrustum", new PerspectiveOffCenterFrustum());
 

package/dist/lib/perspective-frustum.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/perspective-frustum.ts"],"names":["assert","Vector2","PerspectiveOffCenterFrustum","defined","val","PerspectiveFrustum","constructor","options","fov","aspectRatio","near","far","xOffset","yOffset","clone","equals","other","_update","_offCenterFrustum","projectionMatrix","infiniteProjectionMatrix","fovy","_fovy","sseDenominator","_sseDenominator","computeCullingVolume","position","direction","up","getPixelDimensions","drawingBufferWidth","drawingBufferHeight","distance","result","Number","isFinite","f","_fov","_aspectRatio","_near","_far","_xOffset","_yOffset","Math","PI","atan","tan","top","bottom","right","left"],"mappings":"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","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\n// Note: This class is still an experimental export, mainly used by other test cases\n// - It has not been fully adapted to math.gl conventions\n// - Documentation has not been ported\n\nimport {assert, Matrix4, NumericArray, Vector2} from '@math.gl/core';\nimport {PerspectiveOffCenterFrustum} from './perspective-off-center-frustum';\nimport {CullingVolume} from './culling-volume';\n\nconst defined = (val: unknown) => val !== null && typeof val !== 'undefined';\n\ntype PerspectiveFrustumOptions = {\n  /** The angle of the field of view (FOV), in radians. */\n  fov?: number;\n  /** The aspect ratio of the frustum's width to it's height. */\n  aspectRatio?: number;\n  /** The distance of the near plane. */\n  near?: number;\n  /** The distance of the far plane. */\n  far?: number;\n  /** The offset in the x direction. */\n  xOffset?: number;\n  /** The offset in the y direction. */\n  yOffset?: number;\n};\n\n/**\n * The viewing frustum is defined by 6 planes.\n * Each plane is represented by a {@link Vector4} object, where the x, y, and z components\n * define the unit vector normal to the plane, and the w component is the distance of the\n * plane from the origin/camera position.\n *\n * @alias PerspectiveFrustum\n *\n * @example\n * var frustum = new PerspectiveFrustum({\n *     fov : Math.PI_OVER_THREE,\n *     aspectRatio : canvas.clientWidth / canvas.clientHeight\n *     near : 1.0,\n *     far : 1000.0\n * });\n *\n * @see PerspectiveOffCenterFrustum\n */\nexport class PerspectiveFrustum {\n  private _offCenterFrustum = new PerspectiveOffCenterFrustum();\n  /**\n   * The angle of the field of view (FOV), in radians.  This angle will be used\n   * as the horizontal FOV if the width is greater than the height, otherwise\n   * it will be the vertical FOV.\n   */\n  fov?: number;\n  private _fov: number;\n  private _fovy: number;\n  private _sseDenominator: number;\n  /**\n   * The aspect ratio of the frustum's width to it's height.\n   */\n  aspectRatio?: number;\n  private _aspectRatio: number;\n  /**\n   * The distance of the near plane.\n   * @default 1.0\n   */\n  near: number;\n  private _near: number;\n  /**\n   * The distance of the far plane.\n   * @default 500000000.0\n   */\n  far: number;\n  private _far: number;\n  /**\n   * Offsets the frustum in the x direction.\n   * @default 0.0\n   */\n  xOffset: number;\n  private _xOffset: number;\n  /**\n   * Offsets the frustum in the y direction.\n   * @default 0.0\n   */\n  yOffset: number;\n  private _yOffset: number;\n\n  constructor(options: PerspectiveFrustumOptions = {}) {\n    const {fov, aspectRatio, near = 1.0, far = 500000000.0, xOffset = 0.0, yOffset = 0.0} = options;\n\n    this.fov = fov;\n    this.aspectRatio = aspectRatio;\n    this.near = near;\n    this.far = far;\n    this.xOffset = xOffset;\n    this.yOffset = yOffset;\n  }\n\n  /**\n   * Returns a duplicate of a PerspectiveFrustum instance.\n   */\n  clone(): PerspectiveFrustum {\n    return new PerspectiveFrustum({\n      aspectRatio: this.aspectRatio,\n      fov: this.fov,\n      near: this.near,\n      far: this.far\n    });\n  }\n\n  /**\n   * Compares the provided PerspectiveFrustum componentwise and returns\n   * <code>true</code> if they are equal, <code>false</code> otherwise.\n   */\n  equals(other: PerspectiveFrustum): boolean {\n    if (!defined(other) || !(other instanceof PerspectiveFrustum)) {\n      return false;\n    }\n\n    this._update();\n    other._update();\n\n    return (\n      this.fov === other.fov &&\n      this.aspectRatio === other.aspectRatio &&\n      this.near === other.near &&\n      this.far === other.far &&\n      this._offCenterFrustum.equals(other._offCenterFrustum)\n    );\n  }\n\n  /**\n   * Gets the perspective projection matrix computed from the view this.\n   */\n  get projectionMatrix(): Matrix4 {\n    this._update();\n    return this._offCenterFrustum.projectionMatrix;\n  }\n\n  /**\n   * The perspective projection matrix computed from the view frustum with an infinite far plane.\n   */\n  get infiniteProjectionMatrix(): Matrix4 {\n    this._update();\n    return this._offCenterFrustum.infiniteProjectionMatrix;\n  }\n\n  /**\n   * Gets the angle of the vertical field of view, in radians.\n   */\n  get fovy(): number {\n    this._update();\n    return this._fovy;\n  }\n\n  /**\n   * @private\n   */\n  get sseDenominator(): number {\n    this._update();\n    return this._sseDenominator;\n  }\n\n  /**\n   * Creates a culling volume for this this.ion.\n   * @returns {CullingVolume} A culling volume at the given position and orientation.\n   *\n   * @example\n   * // Check if a bounding volume intersects the this.\n   * var cullingVolume = this.computeCullingVolume(cameraPosition, cameraDirection, cameraUp);\n   * var intersect = cullingVolume.computeVisibility(boundingVolume);\n   */\n  computeCullingVolume(\n    /** A Vector3 defines the eye position. */\n    position: Readonly<NumericArray>,\n    /** A Vector3 defines the view direction. */\n    direction: Readonly<NumericArray>,\n    /** A Vector3 defines the up direction. */\n    up: Readonly<NumericArray>\n  ): CullingVolume {\n    this._update();\n    return this._offCenterFrustum.computeCullingVolume(position, direction, up);\n  }\n\n  /**\n   * Returns the pixel's width and height in meters.\n   * @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.\n   *\n   * @exception {DeveloperError} drawingBufferWidth must be greater than zero.\n   * @exception {DeveloperError} drawingBufferHeight must be greater than zero.\n   *\n   * @example\n   * // Example 1\n   * // Get the width and height of a pixel.\n   * var pixelSize = camera.this.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, 1.0, new Vector2());\n   *\n   * @example\n   * // Example 2\n   * // Get the width and height of a pixel if the near plane was set to 'distance'.\n   * // For example, get the size of a pixel of an image on a billboard.\n   * var position = camera.position;\n   * var direction = camera.direction;\n   * var toCenter = Vector3.subtract(primitive.boundingVolume.center, position, new Vector3());      // vector from camera to a primitive\n   * var toCenterProj = Vector3.multiplyByScalar(direction, Vector3.dot(direction, toCenter), new Vector3()); // project vector onto camera direction vector\n   * var distance = Vector3.magnitude(toCenterProj);\n   * var pixelSize = camera.this.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, distance, new Vector2());\n   */\n  getPixelDimensions(\n    /** The width of the drawing buffer. */\n    drawingBufferWidth: number,\n    /** The height of the drawing buffer. */\n    drawingBufferHeight: number,\n    /** The distance to the near plane in meters. */\n    distance: number,\n    /** The object onto which to store the result. */\n    result?: Vector2\n  ): Vector2 {\n    this._update();\n    return this._offCenterFrustum.getPixelDimensions(\n      drawingBufferWidth,\n      drawingBufferHeight,\n      distance,\n      result || new Vector2()\n    );\n  }\n\n  // eslint-disable-next-line complexity, max-statements\n  private _update(): void {\n    assert(\n      Number.isFinite(this.fov) &&\n        Number.isFinite(this.aspectRatio) &&\n        Number.isFinite(this.near) &&\n        Number.isFinite(this.far)\n    );\n    // 'fov, aspectRatio, near, or far parameters are not set.'\n\n    const f = this._offCenterFrustum;\n\n    if (\n      this.fov !== this._fov ||\n      this.aspectRatio !== this._aspectRatio ||\n      this.near !== this._near ||\n      this.far !== this._far ||\n      this.xOffset !== this._xOffset ||\n      this.yOffset !== this._yOffset\n    ) {\n      assert(this.fov >= 0 && this.fov < Math.PI);\n      // throw new DeveloperError('fov must be in the range [0, PI).');\n\n      assert(this.aspectRatio > 0);\n      // throw new DeveloperError('aspectRatio must be positive.');\n\n      assert(this.near >= 0 && this.near < this.far);\n      // throw new DeveloperError('near must be greater than zero and less than far.');\n\n      this._aspectRatio = this.aspectRatio;\n      this._fov = this.fov;\n      this._fovy =\n        this.aspectRatio <= 1\n          ? this.fov\n          : Math.atan(Math.tan(this.fov * 0.5) / this.aspectRatio) * 2.0;\n      this._near = this.near;\n      this._far = this.far;\n      this._sseDenominator = 2.0 * Math.tan(0.5 * this._fovy);\n      this._xOffset = this.xOffset;\n      this._yOffset = this.yOffset;\n\n      f.top = this.near * Math.tan(0.5 * this._fovy);\n      f.bottom = -f.top;\n      f.right = this.aspectRatio * f.top;\n      f.left = -f.right;\n      f.near = this.near;\n      f.far = this.far;\n\n      f.right += this.xOffset;\n      f.left += this.xOffset;\n      f.top += this.yOffset;\n      f.bottom += this.yOffset;\n    }\n  }\n}\n"],"file":"perspective-frustum.js"}

package/dist/lib/perspective-off-center-frustum.d.ts

@@ -1,5 +1,5 @@
 import { Vector2, Matrix4, NumericArray } from '@math.gl/core';
-import CullingVolume from './culling-volume';
+import { CullingVolume } from './culling-volume';
 declare type PerspectiveOffCenterFrustumOptions = {
     left?: number;
     right?: number;
@@ -8,7 +8,7 @@ declare type PerspectiveOffCenterFrustumOptions = {
     near?: number;
     far?: number;
 };
-export default class PerspectiveOffCenterFrustum {
+export declare class PerspectiveOffCenterFrustum {
     /**
      * Defines the left clipping plane.
      * @type {Number}

package/dist/lib/perspective-off-center-frustum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"perspective-off-center-frustum.d.ts","sourceRoot":"","sources":["../../src/lib/perspective-off-center-frustum.ts"],"names":[],"mappings":"AAOA,OAAO,EAAU,OAAO,EAAE,OAAO,EAAU,YAAY,EAAC,MAAM,eAAe,CAAC;AAC9E,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAS7C,aAAK,kCAAkC,GAAG;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,2BAA2B;IAC9C;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,KAAK,CAAC,CAAS;IACvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,KAAK,CAAS;IACtB;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,IAAI,CAAS;IAErB,OAAO,CAAC,cAAc,CAOnB;IACH,OAAO,CAAC,kBAAkB,CAAiB;IAC3C,OAAO,CAAC,oBAAoB,CAAiB;IAE7C;;;;;;;;;;;;;;;;;;;OAmBG;gBACS,OAAO,GAAE,kCAAuC;IAsB5D;;;SAGK;IACL,KAAK,IAAI,2BAA2B;IAWpC;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,2BAA2B,GAAG,OAAO;IAanD;;;;;;OAMG;IACH,IAAI,gBAAgB,IAAI,OAAO,CAG9B;IAED;;;;;;OAMG;IACH,IAAI,wBAAwB,IAAI,OAAO,CAGtC;IAED;;;;;;;;OAQG;IAEH,oBAAoB;IAClB,0CAA0C;IAC1C,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC;IAChC,4CAA4C;IAC5C,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC;IACjC,0CAA0C;IAC1C,EAAE,EAAE,QAAQ,CAAC,YAAY,CAAC,GACzB,aAAa;IAmEhB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,kBAAkB;IAChB,uCAAuC;IACvC,kBAAkB,EAAE,MAAM;IAC1B,wCAAwC;IACxC,mBAAmB,EAAE,MAAM;IAC3B,gDAAgD;IAChD,QAAQ,EAAE,MAAM;IAChB,iDAAiD;IACjD,MAAM,EAAE,OAAO,GACd,OAAO;IA0BV,OAAO,CAAC,OAAO;CAkDhB"}
+{"version":3,"file":"perspective-off-center-frustum.d.ts","sourceRoot":"","sources":["../../src/lib/perspective-off-center-frustum.ts"],"names":[],"mappings":"AAOA,OAAO,EAAU,OAAO,EAAE,OAAO,EAAU,YAAY,EAAC,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAS/C,aAAK,kCAAkC,GAAG;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,qBAAa,2BAA2B;IACtC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,KAAK,CAAC,CAAS;IACvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,KAAK,CAAS;IACtB;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,IAAI,CAAS;IAErB,OAAO,CAAC,cAAc,CAOnB;IACH,OAAO,CAAC,kBAAkB,CAAiB;IAC3C,OAAO,CAAC,oBAAoB,CAAiB;IAE7C;;;;;;;;;;;;;;;;;;;OAmBG;gBACS,OAAO,GAAE,kCAAuC;IAsB5D;;;SAGK;IACL,KAAK,IAAI,2BAA2B;IAWpC;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,2BAA2B,GAAG,OAAO;IAanD;;;;;;OAMG;IACH,IAAI,gBAAgB,IAAI,OAAO,CAG9B;IAED;;;;;;OAMG;IACH,IAAI,wBAAwB,IAAI,OAAO,CAGtC;IAED;;;;;;;;OAQG;IAEH,oBAAoB;IAClB,0CAA0C;IAC1C,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC;IAChC,4CAA4C;IAC5C,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC;IACjC,0CAA0C;IAC1C,EAAE,EAAE,QAAQ,CAAC,YAAY,CAAC,GACzB,aAAa;IAmEhB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,kBAAkB;IAChB,uCAAuC;IACvC,kBAAkB,EAAE,MAAM;IAC1B,wCAAwC;IACxC,mBAAmB,EAAE,MAAM;IAC3B,gDAAgD;IAChD,QAAQ,EAAE,MAAM;IAChB,iDAAiD;IACjD,MAAM,EAAE,OAAO,GACd,OAAO;IA0BV,OAAO,CAAC,OAAO;CAkDhB"}

package/dist/{esm/lib → lib}/perspective-off-center-frustum.js

@@ -1,13 +1,13 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { Vector3, Matrix4, assert } from '@math.gl/core';
-import CullingVolume from './culling-volume';
-import Plane from './plane';
+import { CullingVolume } from "./culling-volume.js";
+import { Plane } from "./plane.js";
 const scratchPlaneUpVector = new Vector3();
 const scratchPlaneRightVector = new Vector3();
 const scratchPlaneNearCenter = new Vector3();
 const scratchPlaneFarCenter = new Vector3();
 const scratchPlaneNormal = new Vector3();
-export default class PerspectiveOffCenterFrustum {
+export class PerspectiveOffCenterFrustum {
   constructor(options = {}) {
     _defineProperty(this, "left", void 0);
 

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

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

package/dist/lib/plane.d.ts

@@ -1,5 +1,5 @@
 import { Vector3, NumericArray } from '@math.gl/core';
-export default class Plane {
+export declare class Plane {
     readonly normal: Vector3;
     distance: number;
     constructor(normal?: Readonly<NumericArray>, distance?: number);

package/dist/lib/plane.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plane.d.ts","sourceRoot":"","sources":["../../src/lib/plane.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,OAAO,EAAkB,YAAY,EAAC,MAAM,eAAe,CAAC;AAMpE,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;gBAEL,MAAM,GAAE,QAAQ,CAAC,YAAY,CAAa,EAAE,QAAQ,GAAE,MAAU;IAM5E,oEAAoE;IACpE,kBAAkB,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAO1E,8DAA8D;IAC9D,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAQpF,gDAAgD;IAChD,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAOlE,mCAAmC;IACnC,KAAK,IAAI,KAAK;IAId,0DAA0D;IAC1D,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAI7B;;OAEG;IACH,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,MAAM;IAIvD,+DAA+D;IAC/D,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAMhD,uCAAuC;IACvC,qBAAqB,CAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO;IAC9E,qBAAqB,CACnB,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC7B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,GACzB,SAAS,MAAM,EAAE;CAUrB"}
+{"version":3,"file":"plane.d.ts","sourceRoot":"","sources":["../../src/lib/plane.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,OAAO,EAAkB,YAAY,EAAC,MAAM,eAAe,CAAC;AAMpE,qBAAa,KAAK;IAChB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;gBAEL,MAAM,GAAE,QAAQ,CAAC,YAAY,CAAa,EAAE,QAAQ,GAAE,MAAU;IAM5E,oEAAoE;IACpE,kBAAkB,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAO1E,8DAA8D;IAC9D,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAQpF,gDAAgD;IAChD,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAOlE,mCAAmC;IACnC,KAAK,IAAI,KAAK;IAId,0DAA0D;IAC1D,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAI7B;;OAEG;IACH,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,MAAM;IAIvD,+DAA+D;IAC/D,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAMhD,uCAAuC;IACvC,qBAAqB,CAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO;IAC9E,qBAAqB,CACnB,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC7B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,GACzB,SAAS,MAAM,EAAE;CAUrB"}

package/dist/{esm/lib → lib}/plane.js

@@ -2,7 +2,7 @@ import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { Vector3, equals, assert } from '@math.gl/core';
 const scratchPosition = new Vector3();
 const scratchNormal = new Vector3();
-export default class Plane {
+export class Plane {
   constructor(normal = [0, 0, 1], distance = 0) {
     _defineProperty(this, "normal", void 0);
 
@@ -54,10 +54,10 @@ export default class Plane {
   }
 
   projectPointOntoPlane(point, result = [0, 0, 0]) {
-    point = scratchPosition.from(point);
-    const pointDistance = this.getPointDistance(point);
+    const scratchPoint = scratchPosition.from(point);
+    const pointDistance = this.getPointDistance(scratchPoint);
     const scaledNormal = scratchNormal.copy(this.normal).scale(pointDistance);
-    return point.subtract(scaledNormal).to(result);
+    return scratchPoint.subtract(scaledNormal).to(result);
   }
 
 }

package/dist/lib/plane.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/plane.ts"],"names":["Vector3","equals","assert","scratchPosition","scratchNormal","Plane","constructor","normal","distance","fromNormalDistance","Number","isFinite","from","normalize","fromPointNormal","point","dot","fromCoefficients","a","b","c","d","set","len","clone","right","getPointDistance","transform","matrix4","copy","transformAsVector","scale","projectPointOntoPlane","result","scratchPoint","pointDistance","scaledNormal","subtract","to"],"mappings":"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","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\n/* eslint-disable */\nimport {Vector3, equals, assert, NumericArray} from '@math.gl/core';\n\nconst scratchPosition = new Vector3();\nconst scratchNormal = new Vector3();\n\n// A plane in Hessian Normal Form\nexport class Plane {\n  readonly normal: Vector3;\n  distance: number;\n\n  constructor(normal: Readonly<NumericArray> = [0, 0, 1], distance: number = 0) {\n    this.normal = new Vector3();\n    this.distance = -0;\n    this.fromNormalDistance(normal, distance);\n  }\n\n  /** Creates a plane from a normal and a distance from the origin. */\n  fromNormalDistance(normal: Readonly<NumericArray>, distance: number): this {\n    assert(Number.isFinite(distance));\n    this.normal.from(normal).normalize();\n    this.distance = distance;\n    return this;\n  }\n\n  /** Creates a plane from a normal and a point on the plane. */\n  fromPointNormal(point: Readonly<NumericArray>, normal: Readonly<NumericArray>): this {\n    point = scratchPosition.from(point);\n    this.normal.from(normal).normalize();\n    const distance = -this.normal.dot(point);\n    this.distance = distance;\n    return this;\n  }\n\n  /** Creates a plane from the general equation */\n  fromCoefficients(a: number, b: number, c: number, d: number): this {\n    this.normal.set(a, b, c);\n    assert(equals(this.normal.len(), 1));\n    this.distance = d;\n    return this;\n  }\n\n  /** Duplicates a Plane instance. */\n  clone(): Plane {\n    return new Plane(this.normal, this.distance);\n  }\n\n  /** Compares the provided Planes by normal and distance */\n  equals(right: Plane): boolean {\n    return equals(this.distance, right.distance) && equals(this.normal, right.normal);\n  }\n\n  /** Computes the signed shortest distance of a point to a plane.\n   * The sign of the distance determines which side of the plane the point is on.\n   */\n  getPointDistance(point: Readonly<NumericArray>): number {\n    return this.normal.dot(point) + this.distance;\n  }\n\n  /** Transforms the plane by the given transformation matrix. */\n  transform(matrix4: Readonly<NumericArray>): this {\n    const normal = scratchNormal.copy(this.normal).transformAsVector(matrix4).normalize();\n    const point = this.normal.scale(-this.distance).transform(matrix4);\n    return this.fromPointNormal(point, normal);\n  }\n\n  /** Projects a point onto the plane. */\n  projectPointOntoPlane(point: Readonly<NumericArray>, result: Vector3): Vector3;\n  projectPointOntoPlane(\n    point: Readonly<NumericArray>,\n    result?: readonly number[]\n  ): readonly number[];\n\n  projectPointOntoPlane(point: Readonly<NumericArray>, result = [0, 0, 0]) {\n    const scratchPoint = scratchPosition.from(point);\n    // projectedPoint = point - (normal.point + scale) * normal\n    const pointDistance = this.getPointDistance(scratchPoint);\n    const scaledNormal = scratchNormal.copy(this.normal).scale(pointDistance);\n\n    return scratchPoint.subtract(scaledNormal).to(result);\n  }\n}\n"],"file":"plane.js"}

package/package.json

@@ -2,10 +2,11 @@
   "name": "@math.gl/culling",
   "description": "Culling Functionality for 3D Classes",
   "license": "MIT",
+  "type": "module",
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.6.3",
+  "version": "4.0.0-alpha.2",
   "keywords": [
     "webgl",
     "javascript",
@@ -27,16 +28,16 @@
     "url": "https://github.com/uber-web/math.gl.git"
   },
   "types": "dist/index.d.ts",
-  "main": "dist/es5/index.js",
-  "module": "dist/esm/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
     "@babel/runtime": "^7.12.0",
-    "@math.gl/core": "3.6.3",
-    "gl-matrix": "^3.4.0"
+    "@math.gl/core": "4.0.0-alpha.2",
+    "gl-matrix": "^3.4.3"
   },
-  "gitHead": "0efab394df9babad7ed93027c1003f30528b2090"
+  "gitHead": "2e693639e3cf898fee8e323c93efdd07be7c2ca7"
 }

package/src/index.ts

@@ -3,18 +3,18 @@
 
 export {INTERSECTION} from './constants';
 
-export {default as AxisAlignedBoundingBox} from './lib/bounding-volumes/axis-aligned-bounding-box';
-export {default as BoundingSphere} from './lib/bounding-volumes/bounding-sphere';
-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 {AxisAlignedBoundingBox} from './lib/bounding-volumes/axis-aligned-bounding-box';
+export {BoundingSphere} from './lib/bounding-volumes/bounding-sphere';
+export {OrientedBoundingBox} from './lib/bounding-volumes/oriented-bounding-box';
+export {CullingVolume} from './lib/culling-volume';
+export {Plane} from './lib/plane';
 
-export {default as _PerspectiveOffCenterFrustum} from './lib/perspective-off-center-frustum';
-export {default as _PerspectiveFrustum} from './lib/perspective-frustum';
+export {PerspectiveOffCenterFrustum as _PerspectiveOffCenterFrustum} from './lib/perspective-off-center-frustum';
+export {PerspectiveFrustum as _PerspectiveFrustum} from './lib/perspective-frustum';
 
-export {default as makeBoundingSphereFromPoints} from './lib/algorithms/bounding-sphere-from-points';
+export {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';
+export {computeEigenDecomposition} from './lib/algorithms/compute-eigen-decomposition';

package/src/lib/algorithms/bounding-box-from-points.ts

@@ -2,9 +2,9 @@
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
 import {Vector3, Matrix3} from '@math.gl/core';
-import computeEigenDecomposition from './compute-eigen-decomposition';
-import OrientedBoundingBox from '../bounding-volumes/oriented-bounding-box';
-import AxisAlignedBoundingBox from '../bounding-volumes/axis-aligned-bounding-box';
+import {computeEigenDecomposition} from './compute-eigen-decomposition';
+import {OrientedBoundingBox} from '../bounding-volumes/oriented-bounding-box';
+import {AxisAlignedBoundingBox} from '../bounding-volumes/axis-aligned-bounding-box';
 
 const scratchVector2 = new Vector3();
 

package/src/lib/algorithms/bounding-sphere-from-points.ts

@@ -2,7 +2,7 @@
 // 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';
+import {BoundingSphere} from '../bounding-volumes/bounding-sphere';
 
 /* eslint-disable */
 const fromPointsXMin = new Vector3();
@@ -17,7 +17,7 @@ const fromPointsRitterCenter = new Vector3();
 const fromPointsMinBoxPt = new Vector3();
 const fromPointsMaxBoxPt = new Vector3();
 const fromPointsNaiveCenterScratch = new Vector3();
-const volumeConstant = (4.0 / 3.0) * Math.PI;
+// const volumeConstant = (4.0 / 3.0) * Math.PI;
 
 /**
  * Computes a tight-fitting bounding sphere enclosing a list of 3D Cartesian points.
@@ -30,7 +30,7 @@ const volumeConstant = (4.0 / 3.0) * Math.PI;
  * @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(
+export function makeBoundingSphereFromPoints(
   positions: number[][],
   result: BoundingSphere = new BoundingSphere()
 ): BoundingSphere {

package/src/lib/algorithms/compute-eigen-decomposition.ts

@@ -45,7 +45,7 @@ export type EigenDecomposition = {
  * const v = result.unitary.getColumn(0, new Vector3());          // first eigenvector
  * const c = v.multiplyByScalar(lambda);                          // equal to v.transformByMatrix3(a)
  */
-export default function computeEigenDecomposition(
+export function computeEigenDecomposition(
   matrix: number[],
   // @ts-expect-error accept empty object type
   result: EigenDecomposition = {}

package/src/lib/bounding-volumes/axis-aligned-bounding-box.ts

@@ -1,6 +1,6 @@
 import {BoundingVolume} from './bounding-volume';
 import {Vector3} from '@math.gl/core';
-import Plane from '../plane';
+import {Plane} from '../plane';
 import {INTERSECTION} from '../../constants';
 
 const scratchVector = new Vector3();
@@ -12,7 +12,7 @@ const scratchNormal = new Vector3();
  * @see BoundingRectangle
  * @see OrientedBoundingBox
  */
-export default class AxisAlignedBoundingBox implements BoundingVolume {
+export class AxisAlignedBoundingBox implements BoundingVolume {
   /** The center point of the bounding box. */
   readonly center: Vector3;
   /** The positive half diagonal of the bounding box. */

package/src/lib/bounding-volumes/bounding-sphere.ts

@@ -2,16 +2,18 @@
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
 import {NumericArray, Vector3} from '@math.gl/core';
+// @ts-ignore gl-matrix typings...
 import * as mat4 from 'gl-matrix/mat4';
+
 import {INTERSECTION} from '../../constants';
 import {BoundingVolume} from './bounding-volume';
-import Plane from '../plane';
+import {Plane} from '../plane';
 
 const scratchVector = new Vector3();
 const scratchVector2 = new Vector3();
 
 /** A BoundingSphere */
-export default class BoundingSphere implements BoundingVolume {
+export class BoundingSphere implements BoundingVolume {
   center: Vector3;
   radius: number;
 

package/src/lib/bounding-volumes/bounding-volume.ts

@@ -1,5 +1,5 @@
-import {INTERSECTION} from '../../constants';
-import Plane from '../plane';
+// import {INTERSECTION} from '../../constants';
+import {Plane} from '../plane';
 
 /**
  * Common interface for BoundingVolumes

package/src/lib/bounding-volumes/oriented-bounding-box.ts

@@ -3,8 +3,8 @@
 
 import {Vector3, Matrix3, Matrix4, Quaternion, NumericArray} from '@math.gl/core';
 import type {BoundingVolume} from './bounding-volume';
-import BoundingSphere from './bounding-sphere';
-import type Plane from '../plane';
+import {BoundingSphere} from './bounding-sphere';
+import type {Plane} from '../plane';
 import {INTERSECTION} from '../../constants';
 
 const scratchVector3 = new Vector3();
@@ -32,7 +32,7 @@ const MATRIX3 = {
  * It can provide a tighter bounding volume than `BoundingSphere` or
  * `AxisAlignedBoundingBox` in many cases.
  */
-export default class OrientedBoundingBox implements BoundingVolume {
+export class OrientedBoundingBox implements BoundingVolume {
   center: Vector3;
   halfAxes: Matrix3;
 
@@ -41,8 +41,11 @@ export default class OrientedBoundingBox implements BoundingVolume {
    * 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]) {
+  constructor(center?: Readonly<NumericArray>, halfAxes?: Readonly<NumericArray>);
+  constructor(
+    center: Readonly<NumericArray> = [0, 0, 0],
+    halfAxes: Readonly<NumericArray> = [0, 0, 0, 0, 0, 0, 0, 0, 0]
+  ) {
     this.center = new Vector3().from(center);
     this.halfAxes = new Matrix3(halfAxes);
   }

package/src/lib/culling-volume.ts

@@ -4,19 +4,19 @@
 /* eslint-disable */
 import {Vector3, assert} from '@math.gl/core';
 import {INTERSECTION} from '../constants';
-import Plane from './plane';
+import {Plane} from './plane';
 import type {BoundingVolume} from './bounding-volumes/bounding-volume';
-import type BoundingSphere from './bounding-volumes/bounding-sphere';
+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])];
 
 const scratchPlaneCenter = new Vector3();
 const scratchPlaneNormal = new Vector3();
-const scratchPlane = new Plane(new Vector3(1.0, 0.0, 0.0), 0.0);
+// const scratchPlane = new Plane(new Vector3(1.0, 0.0, 0.0), 0.0);
 
 /** A culling volume defined by planes. */
-export default class CullingVolume {
+export 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.
@@ -70,7 +70,7 @@ export default class CullingVolume {
       }
 
       const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center);
-      const plane0Distance = -faceNormal.dot(plane0Center);
+      // const plane0Distance = -faceNormal.dot(plane0Center);
 
       plane0.fromPointNormal(plane0Center, faceNormal);
 
@@ -78,7 +78,7 @@ export default class CullingVolume {
 
       const negatedFaceNormal = scratchPlaneNormal.copy(faceNormal).negate();
 
-      const plane1Distance = -negatedFaceNormal.dot(plane1Center);
+      // const plane1Distance = -negatedFaceNormal.dot(plane1Center);
 
       plane1.fromPointNormal(plane1Center, negatedFaceNormal);
 

package/src/lib/perspective-frustum.ts

@@ -6,10 +6,10 @@
 // - Documentation has not been ported
 
 import {assert, Matrix4, NumericArray, Vector2} from '@math.gl/core';
-import PerspectiveOffCenterFrustum from './perspective-off-center-frustum';
-import CullingVolume from './culling-volume';
+import {PerspectiveOffCenterFrustum} from './perspective-off-center-frustum';
+import {CullingVolume} from './culling-volume';
 
-const defined = (val) => val !== null && typeof val !== 'undefined';
+const defined = (val: unknown) => val !== null && typeof val !== 'undefined';
 
 type PerspectiveFrustumOptions = {
   /** The angle of the field of view (FOV), in radians. */
@@ -44,7 +44,7 @@ type PerspectiveFrustumOptions = {
  *
  * @see PerspectiveOffCenterFrustum
  */
-export default class PerspectiveFrustum {
+export class PerspectiveFrustum {
   private _offCenterFrustum = new PerspectiveOffCenterFrustum();
   /**
    * The angle of the field of view (FOV), in radians.  This angle will be used

package/src/lib/perspective-off-center-frustum.ts

@@ -6,8 +6,8 @@
 // - Documentation has not been ported
 
 import {Vector3, Vector2, Matrix4, assert, NumericArray} from '@math.gl/core';
-import CullingVolume from './culling-volume';
-import Plane from './plane';
+import {CullingVolume} from './culling-volume';
+import {Plane} from './plane';
 
 const scratchPlaneUpVector = new Vector3();
 const scratchPlaneRightVector = new Vector3();
@@ -24,7 +24,7 @@ type PerspectiveOffCenterFrustumOptions = {
   far?: number;
 };
 
-export default class PerspectiveOffCenterFrustum {
+export class PerspectiveOffCenterFrustum {
   /**
    * Defines the left clipping plane.
    * @type {Number}

package/src/lib/plane.ts

@@ -8,7 +8,7 @@ const scratchPosition = new Vector3();
 const scratchNormal = new Vector3();
 
 // A plane in Hessian Normal Form
-export default class Plane {
+export class Plane {
   readonly normal: Vector3;
   distance: number;
 
@@ -74,12 +74,12 @@ export default class Plane {
     result?: readonly number[]
   ): readonly number[];
 
-  projectPointOntoPlane(point, result = [0, 0, 0]) {
-    point = scratchPosition.from(point);
+  projectPointOntoPlane(point: Readonly<NumericArray>, result = [0, 0, 0]) {
+    const scratchPoint = scratchPosition.from(point);
     // projectedPoint = point - (normal.point + scale) * normal
-    const pointDistance = this.getPointDistance(point);
+    const pointDistance = this.getPointDistance(scratchPoint);
     const scaledNormal = scratchNormal.copy(this.normal).scale(pointDistance);
 
-    return point.subtract(scaledNormal).to(result);
+    return scratchPoint.subtract(scaledNormal).to(result);
   }
 }

package/dist/es5/constants.js

@@ -1,13 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.INTERSECTION = void 0;
-var INTERSECTION = {
-  OUTSIDE: -1,
-  INTERSECTING: 0,
-  INSIDE: 1
-};
-exports.INTERSECTION = INTERSECTION;
-//# sourceMappingURL=constants.js.map

package/dist/es5/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/constants.ts"],"names":["INTERSECTION","OUTSIDE","INTERSECTING","INSIDE"],"mappings":";;;;;;AAGO,IAAMA,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"}