@math.gl/culling 3.6.0-alpha.8 → 3.6.2

package/dist/esm/lib/culling-volume.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/culling-volume.ts"],"names":["Vector3","assert","INTERSECTION","Plane","faces","scratchPlaneCenter","scratchPlaneNormal","scratchPlane","CullingVolume","constructor","planes","fromBoundingSphere","boundingSphere","length","center","radius","planeIndex","faceNormal","plane0","plane1","plane0Center","copy","scale","add","plane0Distance","dot","fromPointNormal","plane1Center","negatedFaceNormal","negate","plane1Distance","computeVisibility","boundingVolume","intersect","INSIDE","plane","result","intersectPlane","OUTSIDE","INTERSECTING","computeVisibilityWithPlaneMask","parentPlaneMask","Number","isFinite","MASK_OUTSIDE","MASK_INSIDE","mask","k","flag"],"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, assert} from '@math.gl/core';\nimport {INTERSECTION} from '../constants';\nimport Plane from './plane';\nimport type {BoundingVolume} from './bounding-volumes/bounding-volume';\nimport type BoundingSphere from './bounding-volumes/bounding-sphere';\n\n// X, Y, Z Unit vectors\nconst faces = [new Vector3([1, 0, 0]), new Vector3([0, 1, 0]), new Vector3([0, 0, 1])];\n\nconst scratchPlaneCenter = new Vector3();\nconst scratchPlaneNormal = new Vector3();\nconst scratchPlane = new Plane(new Vector3(1.0, 0.0, 0.0), 0.0);\n\n/** A culling volume defined by planes. */\nexport default class CullingVolume {\n  /**\n   * For plane masks (as used in {@link CullingVolume#computeVisibilityWithPlaneMask}), this special value\n   * represents the case where the object bounding volume is entirely outside the culling volume.\n   */\n  static MASK_OUTSIDE = 0xffffffff;\n\n  /**\n   * For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value\n   * represents the case where the object bounding volume is entirely inside the culling volume.\n   */\n  static MASK_INSIDE = 0x00000000;\n\n  /**\n   * For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value\n   * represents the case where the object bounding volume (may) intersect all planes of the culling volume.\n   */\n  static MASK_INDETERMINATE = 0x7fffffff;\n\n  /** Array of clipping planes. */\n  readonly planes: Plane[];\n\n  /**\n   * Create a new `CullingVolume` bounded by an array of clipping planed\n   * @param planes Array of clipping planes.\n   * */\n  constructor(planes: Plane[] = []) {\n    this.planes = planes;\n  }\n\n  /**\n   * Constructs a culling volume from a bounding sphere. Creates six planes that create a box containing the sphere.\n   * The planes are aligned to the x, y, and z axes in world coordinates.\n   */\n  fromBoundingSphere(boundingSphere: BoundingSphere): CullingVolume {\n    this.planes.length = 2 * faces.length;\n\n    const center = boundingSphere.center;\n    const radius = boundingSphere.radius;\n\n    let planeIndex = 0;\n\n    for (const faceNormal of faces) {\n      let plane0 = this.planes[planeIndex];\n      let plane1 = this.planes[planeIndex + 1];\n\n      if (!plane0) {\n        plane0 = this.planes[planeIndex] = new Plane();\n      }\n      if (!plane1) {\n        plane1 = this.planes[planeIndex + 1] = new Plane();\n      }\n\n      const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center);\n      const plane0Distance = -faceNormal.dot(plane0Center);\n\n      plane0.fromPointNormal(plane0Center, faceNormal);\n\n      const plane1Center = scratchPlaneCenter.copy(faceNormal).scale(radius).add(center);\n\n      const negatedFaceNormal = scratchPlaneNormal.copy(faceNormal).negate();\n\n      const plane1Distance = -negatedFaceNormal.dot(plane1Center);\n\n      plane1.fromPointNormal(plane1Center, negatedFaceNormal);\n\n      planeIndex += 2;\n    }\n\n    return this;\n  }\n\n  /** Determines whether a bounding volume intersects the culling volume. */\n  computeVisibility(boundingVolume: BoundingVolume): INTERSECTION {\n    // const planes = this.planes;\n    let intersect = INTERSECTION.INSIDE;\n    for (const plane of this.planes) {\n      const result = boundingVolume.intersectPlane(plane);\n      switch (result) {\n        case INTERSECTION.OUTSIDE:\n          // We are done\n          return INTERSECTION.OUTSIDE;\n\n        case INTERSECTION.INTERSECTING:\n          // If no other intersection is outside, return INTERSECTING\n          intersect = INTERSECTION.INTERSECTING;\n          break;\n\n        default:\n      }\n    }\n\n    return intersect;\n  }\n\n  /**\n   * Determines whether a bounding volume intersects the culling volume.\n   *\n   * @param parentPlaneMask A bit mask from the boundingVolume's parent's check against the same culling\n   *   volume, such that if (planeMask & (1 << planeIndex) === 0), for k < 31, then\n   *   the parent (and therefore this) volume is completely inside plane[planeIndex]\n   *   and that plane check can be skipped.\n   */\n  computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number {\n    assert(Number.isFinite(parentPlaneMask), 'parentPlaneMask is required.');\n\n    if (\n      parentPlaneMask === CullingVolume.MASK_OUTSIDE ||\n      parentPlaneMask === CullingVolume.MASK_INSIDE\n    ) {\n      // parent is completely outside or completely inside, so this child is as well.\n      return parentPlaneMask;\n    }\n\n    // Start with MASK_INSIDE (all zeros) so that after the loop, the return value can be compared with MASK_INSIDE.\n    // (Because if there are fewer than 31 planes, the upper bits wont be changed.)\n    let mask = CullingVolume.MASK_INSIDE;\n\n    const planes = this.planes;\n    for (let k = 0; k < this.planes.length; ++k) {\n      // For k greater than 31 (since 31 is the maximum number of INSIDE/INTERSECTING bits we can store), skip the optimization.\n      const flag = k < 31 ? 1 << k : 0;\n      if (k < 31 && (parentPlaneMask & flag) === 0) {\n        // boundingVolume is known to be INSIDE this plane.\n        continue;\n      }\n\n      const plane = planes[k];\n      const result = boundingVolume.intersectPlane(plane);\n      if (result === INTERSECTION.OUTSIDE) {\n        return CullingVolume.MASK_OUTSIDE;\n      } else if (result === INTERSECTION.INTERSECTING) {\n        mask |= flag;\n      }\n    }\n\n    return mask;\n  }\n}\n"],"file":"culling-volume.js"}
+{"version":3,"sources":["../../../src/lib/culling-volume.ts"],"names":["Vector3","assert","INTERSECTION","Plane","faces","scratchPlaneCenter","scratchPlaneNormal","scratchPlane","CullingVolume","constructor","planes","fromBoundingSphere","boundingSphere","length","center","radius","planeIndex","faceNormal","plane0","plane1","plane0Center","copy","scale","add","plane0Distance","dot","fromPointNormal","plane1Center","negatedFaceNormal","negate","plane1Distance","computeVisibility","boundingVolume","intersect","INSIDE","plane","result","intersectPlane","OUTSIDE","INTERSECTING","computeVisibilityWithPlaneMask","parentPlaneMask","Number","isFinite","MASK_OUTSIDE","MASK_INSIDE","mask","k","flag"],"mappings":";AAIA,SAAQA,OAAR,EAAiBC,MAAjB,QAA8B,eAA9B;AACA,SAAQC,YAAR,QAA2B,cAA3B;AACA,OAAOC,KAAP,MAAkB,SAAlB;AAKA,MAAMC,KAAK,GAAG,CAAC,IAAIJ,OAAJ,CAAY,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAZ,CAAD,EAAyB,IAAIA,OAAJ,CAAY,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAZ,CAAzB,EAAiD,IAAIA,OAAJ,CAAY,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAZ,CAAjD,CAAd;AAEA,MAAMK,kBAAkB,GAAG,IAAIL,OAAJ,EAA3B;AACA,MAAMM,kBAAkB,GAAG,IAAIN,OAAJ,EAA3B;AACA,MAAMO,YAAY,GAAG,IAAIJ,KAAJ,CAAU,IAAIH,OAAJ,CAAY,GAAZ,EAAiB,GAAjB,EAAsB,GAAtB,CAAV,EAAsC,GAAtC,CAArB;AAGA,eAAe,MAAMQ,aAAN,CAAoB;AA0BjCC,EAAAA,WAAW,CAACC,MAAe,GAAG,EAAnB,EAAuB;AAAA;;AAChC,SAAKA,MAAL,GAAcA,MAAd;AACD;;AAMDC,EAAAA,kBAAkB,CAACC,cAAD,EAAgD;AAChE,SAAKF,MAAL,CAAYG,MAAZ,GAAqB,IAAIT,KAAK,CAACS,MAA/B;AAEA,UAAMC,MAAM,GAAGF,cAAc,CAACE,MAA9B;AACA,UAAMC,MAAM,GAAGH,cAAc,CAACG,MAA9B;AAEA,QAAIC,UAAU,GAAG,CAAjB;;AAEA,SAAK,MAAMC,UAAX,IAAyBb,KAAzB,EAAgC;AAC9B,UAAIc,MAAM,GAAG,KAAKR,MAAL,CAAYM,UAAZ,CAAb;AACA,UAAIG,MAAM,GAAG,KAAKT,MAAL,CAAYM,UAAU,GAAG,CAAzB,CAAb;;AAEA,UAAI,CAACE,MAAL,EAAa;AACXA,QAAAA,MAAM,GAAG,KAAKR,MAAL,CAAYM,UAAZ,IAA0B,IAAIb,KAAJ,EAAnC;AACD;;AACD,UAAI,CAACgB,MAAL,EAAa;AACXA,QAAAA,MAAM,GAAG,KAAKT,MAAL,CAAYM,UAAU,GAAG,CAAzB,IAA8B,IAAIb,KAAJ,EAAvC;AACD;;AAED,YAAMiB,YAAY,GAAGf,kBAAkB,CAACgB,IAAnB,CAAwBJ,UAAxB,EAAoCK,KAApC,CAA0C,CAACP,MAA3C,EAAmDQ,GAAnD,CAAuDT,MAAvD,CAArB;AACA,YAAMU,cAAc,GAAG,CAACP,UAAU,CAACQ,GAAX,CAAeL,YAAf,CAAxB;AAEAF,MAAAA,MAAM,CAACQ,eAAP,CAAuBN,YAAvB,EAAqCH,UAArC;AAEA,YAAMU,YAAY,GAAGtB,kBAAkB,CAACgB,IAAnB,CAAwBJ,UAAxB,EAAoCK,KAApC,CAA0CP,MAA1C,EAAkDQ,GAAlD,CAAsDT,MAAtD,CAArB;AAEA,YAAMc,iBAAiB,GAAGtB,kBAAkB,CAACe,IAAnB,CAAwBJ,UAAxB,EAAoCY,MAApC,EAA1B;AAEA,YAAMC,cAAc,GAAG,CAACF,iBAAiB,CAACH,GAAlB,CAAsBE,YAAtB,CAAxB;AAEAR,MAAAA,MAAM,CAACO,eAAP,CAAuBC,YAAvB,EAAqCC,iBAArC;AAEAZ,MAAAA,UAAU,IAAI,CAAd;AACD;;AAED,WAAO,IAAP;AACD;;AAGDe,EAAAA,iBAAiB,CAACC,cAAD,EAAyC;AAExD,QAAIC,SAAiB,GAAG/B,YAAY,CAACgC,MAArC;;AACA,SAAK,MAAMC,KAAX,IAAoB,KAAKzB,MAAzB,EAAiC;AAC/B,YAAM0B,MAAM,GAAGJ,cAAc,CAACK,cAAf,CAA8BF,KAA9B,CAAf;;AACA,cAAQC,MAAR;AACE,aAAKlC,YAAY,CAACoC,OAAlB;AAEE,iBAAOpC,YAAY,CAACoC,OAApB;;AAEF,aAAKpC,YAAY,CAACqC,YAAlB;AAEEN,UAAAA,SAAS,GAAG/B,YAAY,CAACqC,YAAzB;AACA;;AAEF;AAVF;AAYD;;AAED,WAAON,SAAP;AACD;;AAUDO,EAAAA,8BAA8B,CAACR,cAAD,EAAiCS,eAAjC,EAAkE;AAC9FxC,IAAAA,MAAM,CAACyC,MAAM,CAACC,QAAP,CAAgBF,eAAhB,CAAD,EAAmC,8BAAnC,CAAN;;AAEA,QACEA,eAAe,KAAKjC,aAAa,CAACoC,YAAlC,IACAH,eAAe,KAAKjC,aAAa,CAACqC,WAFpC,EAGE;AAEA,aAAOJ,eAAP;AACD;;AAID,QAAIK,IAAI,GAAGtC,aAAa,CAACqC,WAAzB;AAEA,UAAMnC,MAAM,GAAG,KAAKA,MAApB;;AACA,SAAK,IAAIqC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,KAAKrC,MAAL,CAAYG,MAAhC,EAAwC,EAAEkC,CAA1C,EAA6C;AAE3C,YAAMC,IAAI,GAAGD,CAAC,GAAG,EAAJ,GAAS,KAAKA,CAAd,GAAkB,CAA/B;;AACA,UAAIA,CAAC,GAAG,EAAJ,IAAU,CAACN,eAAe,GAAGO,IAAnB,MAA6B,CAA3C,EAA8C;AAE5C;AACD;;AAED,YAAMb,KAAK,GAAGzB,MAAM,CAACqC,CAAD,CAApB;AACA,YAAMX,MAAM,GAAGJ,cAAc,CAACK,cAAf,CAA8BF,KAA9B,CAAf;;AACA,UAAIC,MAAM,KAAKlC,YAAY,CAACoC,OAA5B,EAAqC;AACnC,eAAO9B,aAAa,CAACoC,YAArB;AACD,OAFD,MAEO,IAAIR,MAAM,KAAKlC,YAAY,CAACqC,YAA5B,EAA0C;AAC/CO,QAAAA,IAAI,IAAIE,IAAR;AACD;AACF;;AAED,WAAOF,IAAP;AACD;;AAzIgC;;gBAAdtC,a,kBAKG,U;;gBALHA,a,iBAWE,U;;gBAXFA,a,wBAiBS,U","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, assert} from '@math.gl/core';\nimport {INTERSECTION} from '../constants';\nimport Plane from './plane';\nimport type {BoundingVolume} from './bounding-volumes/bounding-volume';\nimport type BoundingSphere from './bounding-volumes/bounding-sphere';\n\n// X, Y, Z Unit vectors\nconst faces = [new Vector3([1, 0, 0]), new Vector3([0, 1, 0]), new Vector3([0, 0, 1])];\n\nconst scratchPlaneCenter = new Vector3();\nconst scratchPlaneNormal = new Vector3();\nconst scratchPlane = new Plane(new Vector3(1.0, 0.0, 0.0), 0.0);\n\n/** A culling volume defined by planes. */\nexport default class CullingVolume {\n  /**\n   * For plane masks (as used in {@link CullingVolume#computeVisibilityWithPlaneMask}), this special value\n   * represents the case where the object bounding volume is entirely outside the culling volume.\n   */\n  static MASK_OUTSIDE = 0xffffffff;\n\n  /**\n   * For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value\n   * represents the case where the object bounding volume is entirely inside the culling volume.\n   */\n  static MASK_INSIDE = 0x00000000;\n\n  /**\n   * For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value\n   * represents the case where the object bounding volume (may) intersect all planes of the culling volume.\n   */\n  static MASK_INDETERMINATE = 0x7fffffff;\n\n  /** Array of clipping planes. */\n  readonly planes: Plane[];\n\n  /**\n   * Create a new `CullingVolume` bounded by an array of clipping planed\n   * @param planes Array of clipping planes.\n   * */\n  constructor(planes: Plane[] = []) {\n    this.planes = planes;\n  }\n\n  /**\n   * Constructs a culling volume from a bounding sphere. Creates six planes that create a box containing the sphere.\n   * The planes are aligned to the x, y, and z axes in world coordinates.\n   */\n  fromBoundingSphere(boundingSphere: BoundingSphere): CullingVolume {\n    this.planes.length = 2 * faces.length;\n\n    const center = boundingSphere.center;\n    const radius = boundingSphere.radius;\n\n    let planeIndex = 0;\n\n    for (const faceNormal of faces) {\n      let plane0 = this.planes[planeIndex];\n      let plane1 = this.planes[planeIndex + 1];\n\n      if (!plane0) {\n        plane0 = this.planes[planeIndex] = new Plane();\n      }\n      if (!plane1) {\n        plane1 = this.planes[planeIndex + 1] = new Plane();\n      }\n\n      const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center);\n      const plane0Distance = -faceNormal.dot(plane0Center);\n\n      plane0.fromPointNormal(plane0Center, faceNormal);\n\n      const plane1Center = scratchPlaneCenter.copy(faceNormal).scale(radius).add(center);\n\n      const negatedFaceNormal = scratchPlaneNormal.copy(faceNormal).negate();\n\n      const plane1Distance = -negatedFaceNormal.dot(plane1Center);\n\n      plane1.fromPointNormal(plane1Center, negatedFaceNormal);\n\n      planeIndex += 2;\n    }\n\n    return this;\n  }\n\n  /** Determines whether a bounding volume intersects the culling volume. */\n  computeVisibility(boundingVolume: BoundingVolume): number {\n    // const planes = this.planes;\n    let intersect: number = INTERSECTION.INSIDE;\n    for (const plane of this.planes) {\n      const result = boundingVolume.intersectPlane(plane);\n      switch (result) {\n        case INTERSECTION.OUTSIDE:\n          // We are done\n          return INTERSECTION.OUTSIDE;\n\n        case INTERSECTION.INTERSECTING:\n          // If no other intersection is outside, return INTERSECTING\n          intersect = INTERSECTION.INTERSECTING;\n          break;\n\n        default:\n      }\n    }\n\n    return intersect;\n  }\n\n  /**\n   * Determines whether a bounding volume intersects the culling volume.\n   *\n   * @param parentPlaneMask A bit mask from the boundingVolume's parent's check against the same culling\n   *   volume, such that if (planeMask & (1 << planeIndex) === 0), for k < 31, then\n   *   the parent (and therefore this) volume is completely inside plane[planeIndex]\n   *   and that plane check can be skipped.\n   */\n  computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number {\n    assert(Number.isFinite(parentPlaneMask), 'parentPlaneMask is required.');\n\n    if (\n      parentPlaneMask === CullingVolume.MASK_OUTSIDE ||\n      parentPlaneMask === CullingVolume.MASK_INSIDE\n    ) {\n      // parent is completely outside or completely inside, so this child is as well.\n      return parentPlaneMask;\n    }\n\n    // Start with MASK_INSIDE (all zeros) so that after the loop, the return value can be compared with MASK_INSIDE.\n    // (Because if there are fewer than 31 planes, the upper bits wont be changed.)\n    let mask = CullingVolume.MASK_INSIDE;\n\n    const planes = this.planes;\n    for (let k = 0; k < this.planes.length; ++k) {\n      // For k greater than 31 (since 31 is the maximum number of INSIDE/INTERSECTING bits we can store), skip the optimization.\n      const flag = k < 31 ? 1 << k : 0;\n      if (k < 31 && (parentPlaneMask & flag) === 0) {\n        // boundingVolume is known to be INSIDE this plane.\n        continue;\n      }\n\n      const plane = planes[k];\n      const result = boundingVolume.intersectPlane(plane);\n      if (result === INTERSECTION.OUTSIDE) {\n        return CullingVolume.MASK_OUTSIDE;\n      } else if (result === INTERSECTION.INTERSECTING) {\n        mask |= flag;\n      }\n    }\n\n    return mask;\n  }\n}\n"],"file":"culling-volume.js"}

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

@@ -1,7 +1,6 @@
 import { BoundingVolume } from './bounding-volume';
 import { Vector3 } from '@math.gl/core';
 import Plane from '../plane';
-import { INTERSECTION } from '../../constants';
 /**
  * An axis aligned bounding box - aligned with coordinate axes
  * @see BoundingVolume
@@ -47,7 +46,7 @@ export default class AxisAlignedBoundingBox implements BoundingVolume {
     /**
      * Determines which side of a plane a box is located.
      */
-    intersectPlane(plane: Plane): INTERSECTION;
+    intersectPlane(plane: Plane): number;
     /** Computes the estimated distance from the closest point on a bounding box to a point. */
     distanceTo(point: readonly number[]): number;
     /** Computes the estimated distance squared from the closest point on a bounding box to a point. */

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

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

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

@@ -1,5 +1,4 @@
 import { NumericArray, Vector3 } from '@math.gl/core';
-import { INTERSECTION } from '../../constants';
 import { BoundingVolume } from './bounding-volume';
 import Plane from '../plane';
 /** A BoundingSphere */
@@ -35,6 +34,6 @@ export default class BoundingSphere implements BoundingVolume {
     /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
     distanceTo(point: Readonly<NumericArray>): number;
     /** Determines which side of a plane a sphere is located. */
-    intersectPlane(plane: Plane): INTERSECTION;
+    intersectPlane(plane: Plane): number;
 }
 //# sourceMappingURL=bounding-sphere.d.ts.map

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

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

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

@@ -1,4 +1,3 @@
-import { INTERSECTION } from '../../constants';
 import Plane from '../plane';
 /**
  * Common interface for BoundingVolumes
@@ -25,6 +24,6 @@ export interface BoundingVolume {
      *  - `INTERSECTION.OUTSIDE` if the entire box is on the opposite side.
      *  - `INTERSECTION.INTERSECTING` if the box intersects the plane.
      */
-    intersectPlane(plane: Plane): INTERSECTION;
+    intersectPlane(plane: Plane): number;
 }
 //# sourceMappingURL=bounding-volume.d.ts.map

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

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

package/dist/lib/bounding-volumes/oriented-bounding-box.d.ts

@@ -2,7 +2,6 @@ import { Vector3, Matrix3, Matrix4, Quaternion } from '@math.gl/core';
 import type { BoundingVolume } from './bounding-volume';
 import BoundingSphere from './bounding-sphere';
 import type Plane from '../plane';
-import { INTERSECTION } from '../../constants';
 /**
  * An OrientedBoundingBox of some object is a closed and convex cuboid.
  * It can provide a tighter bounding volume than `BoundingSphere` or
@@ -32,7 +31,7 @@ export default class OrientedBoundingBox implements BoundingVolume {
     /** Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box. */
     getBoundingSphere(result?: BoundingSphere): BoundingSphere;
     /** Determines which side of a plane the oriented bounding box is located. */
-    intersectPlane(plane: Plane): INTERSECTION;
+    intersectPlane(plane: Plane): number;
     /** Computes the estimated distance from the closest point on a bounding box to a point. */
     distanceTo(point: readonly number[]): number;
     /**

package/dist/lib/bounding-volumes/oriented-bounding-box.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oriented-bounding-box.d.ts","sourceRoot":"","sources":["../../../src/lib/bounding-volumes/oriented-bounding-box.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AAClF,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACtD,OAAO,cAAc,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,KAAK,MAAM,UAAU,CAAC;AAClC,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAsB7C;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAoB,YAAW,cAAc;IAChE,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAElB;;;;OAIG;gBACS,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE;IAMpE,iEAAiE;IACjE,IAAI,QAAQ,IAAI,MAAM,EAAE,CAKvB;IAED,0EAA0E;IAC1E,IAAI,UAAU,IAAI,UAAU,CAQ3B;IAED;;OAEG;IACH,4BAA4B,CAC1B,MAAM,EAAE,MAAM,EAAE,EAChB,QAAQ,EAAE,MAAM,EAAE,EAClB,UAAU,EAAE,MAAM,EAAE,GACnB,mBAAmB;IAiBtB,iDAAiD;IACjD,KAAK,IAAI,mBAAmB;IAI5B,2EAA2E;IAC3E,MAAM,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO;IAO3C,6FAA6F;IAC7F,iBAAiB,CAAC,MAAM,iBAAuB,GAAG,cAAc;IAehE,6EAA6E;IAC7E,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,YAAY;IAsC1C,2FAA2F;IAC3F,UAAU,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM;IAI5C;;;;OAIG;IACH,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM;IAwCnD;;;;;;;;;;;;;OAaG;IAEH,qBAAqB,CACnB,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,SAAS,EAAE,OAAO,EAClB,MAAM,GAAE,MAAM,EAAa,GAC1B,MAAM,EAAE;IAwFX;;;;OAIG;IACH,SAAS,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAgBlD,YAAY,IAAI,OAAO;CAKxB"}
+{"version":3,"file":"oriented-bounding-box.d.ts","sourceRoot":"","sources":["../../../src/lib/bounding-volumes/oriented-bounding-box.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AAClF,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACtD,OAAO,cAAc,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,KAAK,MAAM,UAAU,CAAC;AAuBlC;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAoB,YAAW,cAAc;IAChE,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAElB;;;;OAIG;gBACS,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE;IAMpE,iEAAiE;IACjE,IAAI,QAAQ,IAAI,MAAM,EAAE,CAKvB;IAED,0EAA0E;IAC1E,IAAI,UAAU,IAAI,UAAU,CAQ3B;IAED;;OAEG;IACH,4BAA4B,CAC1B,MAAM,EAAE,MAAM,EAAE,EAChB,QAAQ,EAAE,MAAM,EAAE,EAClB,UAAU,EAAE,MAAM,EAAE,GACnB,mBAAmB;IAiBtB,iDAAiD;IACjD,KAAK,IAAI,mBAAmB;IAI5B,2EAA2E;IAC3E,MAAM,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO;IAO3C,6FAA6F;IAC7F,iBAAiB,CAAC,MAAM,iBAAuB,GAAG,cAAc;IAehE,6EAA6E;IAC7E,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAsCpC,2FAA2F;IAC3F,UAAU,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM;IAI5C;;;;OAIG;IACH,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM;IAwCnD;;;;;;;;;;;;;OAaG;IAEH,qBAAqB,CACnB,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,SAAS,EAAE,OAAO,EAClB,MAAM,GAAE,MAAM,EAAa,GAC1B,MAAM,EAAE;IAwFX;;;;OAIG;IACH,SAAS,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAgBlD,YAAY,IAAI,OAAO;CAKxB"}

package/dist/lib/culling-volume.d.ts

@@ -1,4 +1,3 @@
-import { INTERSECTION } from '../constants';
 import Plane from './plane';
 import type { BoundingVolume } from './bounding-volumes/bounding-volume';
 import type BoundingSphere from './bounding-volumes/bounding-sphere';
@@ -32,7 +31,7 @@ export default class CullingVolume {
      */
     fromBoundingSphere(boundingSphere: BoundingSphere): CullingVolume;
     /** Determines whether a bounding volume intersects the culling volume. */
-    computeVisibility(boundingVolume: BoundingVolume): INTERSECTION;
+    computeVisibility(boundingVolume: BoundingVolume): number;
     /**
      * Determines whether a bounding volume intersects the culling volume.
      *

package/dist/lib/culling-volume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"culling-volume.d.ts","sourceRoot":"","sources":["../../src/lib/culling-volume.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,oCAAoC,CAAC;AACvE,OAAO,KAAK,cAAc,MAAM,oCAAoC,CAAC;AASrE,0CAA0C;AAC1C,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC;;;OAGG;IACH,MAAM,CAAC,YAAY,SAAc;IAEjC;;;OAGG;IACH,MAAM,CAAC,WAAW,SAAc;IAEhC;;;OAGG;IACH,MAAM,CAAC,kBAAkB,SAAc;IAEvC,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;IAEzB;;;SAGK;gBACO,MAAM,GAAE,KAAK,EAAO;IAIhC;;;OAGG;IACH,kBAAkB,CAAC,cAAc,EAAE,cAAc,GAAG,aAAa;IAsCjE,0EAA0E;IAC1E,iBAAiB,CAAC,cAAc,EAAE,cAAc,GAAG,YAAY;IAsB/D;;;;;;;OAOG;IACH,8BAA8B,CAAC,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM;CAmChG"}
+{"version":3,"file":"culling-volume.d.ts","sourceRoot":"","sources":["../../src/lib/culling-volume.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,oCAAoC,CAAC;AACvE,OAAO,KAAK,cAAc,MAAM,oCAAoC,CAAC;AASrE,0CAA0C;AAC1C,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC;;;OAGG;IACH,MAAM,CAAC,YAAY,SAAc;IAEjC;;;OAGG;IACH,MAAM,CAAC,WAAW,SAAc;IAEhC;;;OAGG;IACH,MAAM,CAAC,kBAAkB,SAAc;IAEvC,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;IAEzB;;;SAGK;gBACO,MAAM,GAAE,KAAK,EAAO;IAIhC;;;OAGG;IACH,kBAAkB,CAAC,cAAc,EAAE,cAAc,GAAG,aAAa;IAsCjE,0EAA0E;IAC1E,iBAAiB,CAAC,cAAc,EAAE,cAAc,GAAG,MAAM;IAsBzD;;;;;;;OAOG;IACH,8BAA8B,CAAC,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM;CAmChG"}

package/package.json

@@ -5,7 +5,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.6.0-alpha.8",
+  "version": "3.6.2",
   "keywords": [
     "webgl",
     "javascript",
@@ -35,8 +35,8 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.12.0",
-    "@math.gl/core": "3.6.0-alpha.8",
+    "@math.gl/core": "3.6.2",
     "gl-matrix": "^3.4.0"
   },
-  "gitHead": "5354df2f3c4111d4e48f4a0508d8e8103dd5eaf4"
+  "gitHead": "517015873bbd7143bfc4bb761e70071c7a86771b"
 }

package/src/constants.ts

@@ -1,8 +1,8 @@
 // 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 enum INTERSECTION {
-  OUTSIDE = -1, // Represents that an object is not contained within the frustum.
-  INTERSECTING = 0, // Represents that an object intersects one of the frustum's planes.
-  INSIDE = 1 // Represents that an object is fully within the frustum.
-}
+export const INTERSECTION = {
+  OUTSIDE: -1, // Represents that an object is not contained within the frustum.
+  INTERSECTING: 0, // Represents that an object intersects one of the frustum's planes.
+  INSIDE: 1 // Represents that an object is fully within the frustum.
+} as const;

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

@@ -93,7 +93,7 @@ export default class AxisAlignedBoundingBox implements BoundingVolume {
   /**
    * Determines which side of a plane a box is located.
    */
-  intersectPlane(plane: Plane): INTERSECTION {
+  intersectPlane(plane: Plane): number {
     const {halfDiagonal} = this;
     const normal = scratchNormal.from(plane.normal);
     const e =

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

@@ -127,7 +127,7 @@ export default class BoundingSphere implements BoundingVolume {
   }
 
   /** Determines which side of a plane a sphere is located. */
-  intersectPlane(plane: Plane): INTERSECTION {
+  intersectPlane(plane: Plane): number {
     const center = this.center;
     const radius = this.radius;
     const normal = plane.normal;

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

@@ -28,5 +28,5 @@ export interface BoundingVolume {
    *  - `INTERSECTION.OUTSIDE` if the entire box is on the opposite side.
    *  - `INTERSECTION.INTERSECTING` if the box intersects the plane.
    */
-  intersectPlane(plane: Plane): INTERSECTION;
+  intersectPlane(plane: Plane): number;
 }

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

@@ -120,7 +120,7 @@ export default class OrientedBoundingBox implements BoundingVolume {
   }
 
   /** Determines which side of a plane the oriented bounding box is located. */
-  intersectPlane(plane: Plane): INTERSECTION {
+  intersectPlane(plane: Plane): number {
     const center = this.center;
     const normal = plane.normal;
     const halfAxes = this.halfAxes;

package/src/lib/culling-volume.ts

@@ -89,9 +89,9 @@ export default class CullingVolume {
   }
 
   /** Determines whether a bounding volume intersects the culling volume. */
-  computeVisibility(boundingVolume: BoundingVolume): INTERSECTION {
+  computeVisibility(boundingVolume: BoundingVolume): number {
     // const planes = this.planes;
-    let intersect = INTERSECTION.INSIDE;
+    let intersect: number = INTERSECTION.INSIDE;
     for (const plane of this.planes) {
       const result = boundingVolume.intersectPlane(plane);
       switch (result) {

package/dist/constants.js

@@ -1,8 +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 var INTERSECTION;
-(function (INTERSECTION) {
-    INTERSECTION[INTERSECTION["OUTSIDE"] = -1] = "OUTSIDE";
-    INTERSECTION[INTERSECTION["INTERSECTING"] = 0] = "INTERSECTING";
-    INTERSECTION[INTERSECTION["INSIDE"] = 1] = "INSIDE"; // Represents that an object is fully within the frustum.
-})(INTERSECTION || (INTERSECTION = {}));

package/dist/index.js

@@ -1,13 +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 { 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 { default as _PerspectiveOffCenterFrustum } from './lib/perspective-off-center-frustum';
-export { default as _PerspectiveFrustum } from './lib/perspective-frustum';
-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';

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

@@ -1,131 +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
-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';
-const scratchVector2 = new Vector3();
-const scratchVector3 = new Vector3();
-const scratchVector4 = new Vector3();
-const scratchVector5 = new Vector3();
-const scratchVector6 = new Vector3();
-const scratchCovarianceResult = new Matrix3();
-const scratchEigenResult = {
-    diagonal: new Matrix3(),
-    unitary: new Matrix3()
-};
-/**
- * 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
- */
-/* eslint-disable max-statements */
-export function makeOrientedBoundingBoxFromPoints(positions, result = new OrientedBoundingBox()) {
-    if (!positions || positions.length === 0) {
-        result.halfAxes = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);
-        result.center = new Vector3();
-        return result;
-    }
-    const length = positions.length;
-    const meanPoint = new Vector3(0, 0, 0);
-    for (const position of positions) {
-        meanPoint.add(position);
-    }
-    const invLength = 1.0 / length;
-    meanPoint.multiplyByScalar(invLength);
-    let exx = 0.0;
-    let exy = 0.0;
-    let exz = 0.0;
-    let eyy = 0.0;
-    let eyz = 0.0;
-    let ezz = 0.0;
-    for (const position of positions) {
-        const p = scratchVector2.copy(position).subtract(meanPoint);
-        exx += p.x * p.x;
-        exy += p.x * p.y;
-        exz += p.x * p.z;
-        eyy += p.y * p.y;
-        eyz += p.y * p.z;
-        ezz += p.z * p.z;
-    }
-    exx *= invLength;
-    exy *= invLength;
-    exz *= invLength;
-    eyy *= invLength;
-    eyz *= invLength;
-    ezz *= invLength;
-    const covarianceMatrix = scratchCovarianceResult;
-    covarianceMatrix[0] = exx;
-    covarianceMatrix[1] = exy;
-    covarianceMatrix[2] = exz;
-    covarianceMatrix[3] = exy;
-    covarianceMatrix[4] = eyy;
-    covarianceMatrix[5] = eyz;
-    covarianceMatrix[6] = exz;
-    covarianceMatrix[7] = eyz;
-    covarianceMatrix[8] = ezz;
-    const { unitary } = computeEigenDecomposition(covarianceMatrix, scratchEigenResult);
-    const rotation = result.halfAxes.copy(unitary);
-    let v1 = rotation.getColumn(0, scratchVector4);
-    let v2 = rotation.getColumn(1, scratchVector5);
-    let v3 = rotation.getColumn(2, scratchVector6);
-    let u1 = -Number.MAX_VALUE;
-    let u2 = -Number.MAX_VALUE;
-    let u3 = -Number.MAX_VALUE;
-    let l1 = Number.MAX_VALUE;
-    let l2 = Number.MAX_VALUE;
-    let l3 = Number.MAX_VALUE;
-    for (const position of positions) {
-        scratchVector2.copy(position);
-        u1 = Math.max(scratchVector2.dot(v1), u1);
-        u2 = Math.max(scratchVector2.dot(v2), u2);
-        u3 = Math.max(scratchVector2.dot(v3), u3);
-        l1 = Math.min(scratchVector2.dot(v1), l1);
-        l2 = Math.min(scratchVector2.dot(v2), l2);
-        l3 = Math.min(scratchVector2.dot(v3), l3);
-    }
-    v1 = v1.multiplyByScalar(0.5 * (l1 + u1));
-    v2 = v2.multiplyByScalar(0.5 * (l2 + u2));
-    v3 = v3.multiplyByScalar(0.5 * (l3 + u3));
-    result.center.copy(v1).add(v2).add(v3);
-    const scale = scratchVector3.set(u1 - l1, u2 - l2, u3 - l3).multiplyByScalar(0.5);
-    const scaleMatrix = new Matrix3([scale[0], 0, 0, 0, scale[1], 0, 0, 0, scale[2]]);
-    result.halfAxes.multiplyRight(scaleMatrix);
-    return result;
-}
-/**
- * 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, result = new AxisAlignedBoundingBox()) {
-    if (!positions || positions.length === 0) {
-        result.minimum.set(0, 0, 0);
-        result.maximum.set(0, 0, 0);
-        result.center.set(0, 0, 0);
-        result.halfDiagonal.set(0, 0, 0);
-        return result;
-    }
-    let minimumX = positions[0][0];
-    let minimumY = positions[0][1];
-    let minimumZ = positions[0][2];
-    let maximumX = positions[0][0];
-    let maximumY = positions[0][1];
-    let maximumZ = positions[0][2];
-    for (const p of positions) {
-        const x = p[0];
-        const y = p[1];
-        const z = p[2];
-        minimumX = Math.min(x, minimumX);
-        maximumX = Math.max(x, maximumX);
-        minimumY = Math.min(y, minimumY);
-        maximumY = Math.max(y, maximumY);
-        minimumZ = Math.min(z, minimumZ);
-        maximumZ = Math.max(z, maximumZ);
-    }
-    result.minimum.set(minimumX, minimumY, minimumZ);
-    result.maximum.set(maximumX, maximumY, maximumZ);
-    result.center.copy(result.minimum).add(result.maximum).scale(0.5);
-    result.halfDiagonal.copy(result.maximum).subtract(result.center);
-    return result;
-}

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

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