@math.gl/culling 4.1.0-alpha.9 → 4.2.0-alpha.3

package/dist/index.cjs

@@ -25,6 +25,7 @@ __export(dist_exports, {
   INTERSECTION: () => INTERSECTION,
   OrientedBoundingBox: () => OrientedBoundingBox,
   Plane: () => Plane,
+  Ray: () => Ray,
   _PerspectiveFrustum: () => PerspectiveFrustum,
   _PerspectiveOffCenterFrustum: () => PerspectiveOffCenterFrustum,
   computeEigenDecomposition: () => computeEigenDecomposition,
@@ -37,8 +38,11 @@ module.exports = __toCommonJS(dist_exports);
 // dist/constants.js
 var 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.
 };
 
 // dist/lib/bounding-volumes/axis-aligned-bounding-box.js
@@ -46,6 +50,12 @@ var import_core = require("@math.gl/core");
 var scratchVector = new import_core.Vector3();
 var scratchNormal = new import_core.Vector3();
 var AxisAlignedBoundingBox = class {
+  /**
+   * Creates an instance of an AxisAlignedBoundingBox from the minimum and maximum points along the x, y, and z axes.
+   * @param minimum=[0, 0, 0] The minimum point along the x, y, and z axes.
+   * @param maximum=[0, 0, 0] The maximum point along the x, y, and z axes.
+   * @param center The center of the box; automatically computed if not supplied.
+   */
   constructor(minimum = [0, 0, 0], maximum = [0, 0, 0], center) {
     center = center || scratchVector.copy(minimum).add(maximum).scale(0.5);
     this.center = new import_core.Vector3(center);
@@ -53,12 +63,29 @@ var AxisAlignedBoundingBox = class {
     this.minimum = new import_core.Vector3(minimum);
     this.maximum = new import_core.Vector3(maximum);
   }
+  /**
+   * Duplicates a AxisAlignedBoundingBox instance.
+   *
+   * @returns {AxisAlignedBoundingBox} A new AxisAlignedBoundingBox instance.
+   */
   clone() {
     return new AxisAlignedBoundingBox(this.minimum, this.maximum, this.center);
   }
+  /**
+   * Compares the provided AxisAlignedBoundingBox componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {AxisAlignedBoundingBox} [right] The second AxisAlignedBoundingBox to compare with.
+   * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+   */
   equals(right) {
     return this === right || Boolean(right) && this.minimum.equals(right.minimum) && this.maximum.equals(right.maximum);
   }
+  /**
+   * Applies a 4x4 affine transformation matrix to a bounding sphere.
+   * @param transform The transformation matrix to apply to the bounding sphere.
+   * @returns itself, i.e. the modified BoundingVolume.
+   */
   transform(transform) {
     this.center.transformAsPoint(transform);
     this.halfDiagonal.transform(transform);
@@ -66,6 +93,9 @@ var AxisAlignedBoundingBox = class {
     this.maximum.transform(transform);
     return this;
   }
+  /**
+   * Determines which side of a plane a box is located.
+   */
   intersectPlane(plane) {
     const { halfDiagonal } = this;
     const normal = scratchNormal.from(plane.normal);
@@ -79,9 +109,11 @@ var AxisAlignedBoundingBox = class {
     }
     return INTERSECTION.INTERSECTING;
   }
+  /** Computes the estimated distance from the closest point on a bounding box to a point. */
   distanceTo(point) {
     return Math.sqrt(this.distanceSquaredTo(point));
   }
+  /** Computes the estimated distance squared from the closest point on a bounding box to a point. */
   distanceSquaredTo(point) {
     const offset = scratchVector.from(point).subtract(this.center);
     const { halfDiagonal } = this;
@@ -108,28 +140,37 @@ var import_core2 = require("@math.gl/core");
 var scratchVector2 = new import_core2.Vector3();
 var scratchVector22 = new import_core2.Vector3();
 var BoundingSphere = class {
+  /** Creates a bounding sphere */
   constructor(center = [0, 0, 0], radius = 0) {
     this.radius = -0;
     this.center = new import_core2.Vector3();
     this.fromCenterRadius(center, radius);
   }
+  /** Sets the bounding sphere from `center` and `radius`. */
   fromCenterRadius(center, radius) {
     this.center.from(center);
     this.radius = radius;
     return this;
   }
+  /**
+   * Computes a bounding sphere from the corner points of an axis-aligned bounding box.  The sphere
+   * tightly and fully encompasses the box.
+   */
   fromCornerPoints(corner, oppositeCorner) {
     oppositeCorner = scratchVector2.from(oppositeCorner);
     this.center = new import_core2.Vector3().from(corner).add(oppositeCorner).scale(0.5);
     this.radius = this.center.distance(oppositeCorner);
     return this;
   }
+  /** Compares the provided BoundingSphere component wise */
   equals(right) {
     return this === right || Boolean(right) && this.center.equals(right.center) && this.radius === right.radius;
   }
+  /** Duplicates a BoundingSphere instance. */
   clone() {
     return new BoundingSphere(this.center, this.radius);
   }
+  /** Computes a bounding sphere that contains both the left and right bounding spheres. */
   union(boundingSphere) {
     const leftCenter = this.center;
     const leftRadius = this.radius;
@@ -149,6 +190,7 @@ var BoundingSphere = class {
     this.radius = halfDistanceBetweenTangentPoints;
     return this;
   }
+  /** Computes a bounding sphere by enlarging the provided sphere to contain the provided point. */
   expand(point) {
     const scratchPoint = scratchVector2.from(point);
     const radius = scratchPoint.subtract(this.center).magnitude();
@@ -157,21 +199,31 @@ var BoundingSphere = class {
     }
     return this;
   }
+  // BoundingVolume interface
+  /**
+   * Applies a 4x4 affine transformation matrix to a bounding sphere.
+   * @param sphere The bounding sphere to apply the transformation to.
+   * @param transform The transformation matrix to apply to the bounding sphere.
+   * @returns self.
+   */
   transform(transform) {
     this.center.transform(transform);
     const scale = import_core2.mat4.getScaling(scratchVector2, transform);
     this.radius = Math.max(scale[0], Math.max(scale[1], scale[2])) * this.radius;
     return this;
   }
+  /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
   distanceSquaredTo(point) {
     const d = this.distanceTo(point);
     return d * d;
   }
+  /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
   distanceTo(point) {
     const scratchPoint = scratchVector2.from(point);
     const delta = scratchPoint.subtract(this.center);
     return Math.max(0, delta.len() - this.radius);
   }
+  /** Determines which side of a plane a sphere is located. */
   intersectPlane(plane) {
     const center = this.center;
     const radius = this.radius;
@@ -212,12 +264,14 @@ var OrientedBoundingBox = class {
     this.center = new import_core3.Vector3().from(center);
     this.halfAxes = new import_core3.Matrix3(halfAxes);
   }
+  /** Returns an array with three halfSizes for the bounding box */
   get halfSize() {
     const xAxis = this.halfAxes.getColumn(0);
     const yAxis = this.halfAxes.getColumn(1);
     const zAxis = this.halfAxes.getColumn(2);
     return [new import_core3.Vector3(xAxis).len(), new import_core3.Vector3(yAxis).len(), new import_core3.Vector3(zAxis).len()];
   }
+  /** Returns a quaternion describing the orientation of the bounding box */
   get quaternion() {
     const xAxis = this.halfAxes.getColumn(0);
     const yAxis = this.halfAxes.getColumn(1);
@@ -227,6 +281,9 @@ var OrientedBoundingBox = class {
     const normZAxis = new import_core3.Vector3(zAxis).normalize();
     return new import_core3.Quaternion().fromMatrix3(new import_core3.Matrix3([...normXAxis, ...normYAxis, ...normZAxis]));
   }
+  /**
+   * Create OrientedBoundingBox from quaternion based OBB,
+   */
   fromCenterHalfSizeQuaternion(center, halfSize, quaternion) {
     const quaternionObject = new import_core3.Quaternion(quaternion);
     const directionsMatrix = new import_core3.Matrix3().fromQuaternion(quaternionObject);
@@ -243,12 +300,15 @@ var OrientedBoundingBox = class {
     this.halfAxes = directionsMatrix;
     return this;
   }
+  /** Duplicates a OrientedBoundingBox instance. */
   clone() {
     return new OrientedBoundingBox(this.center, this.halfAxes);
   }
+  /** Compares the provided OrientedBoundingBox component wise and returns */
   equals(right) {
     return this === right || Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes);
   }
+  /** Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box. */
   getBoundingSphere(result = new BoundingSphere()) {
     const halfAxes = this.halfAxes;
     const u = halfAxes.getColumn(0, scratchVectorU);
@@ -259,6 +319,7 @@ var OrientedBoundingBox = class {
     result.radius = cornerVector.magnitude();
     return result;
   }
+  /** Determines which side of a plane the oriented bounding box is located. */
   intersectPlane(plane) {
     const center = this.center;
     const normal = plane.normal;
@@ -275,9 +336,15 @@ var OrientedBoundingBox = class {
     }
     return INTERSECTION.INTERSECTING;
   }
+  /** Computes the estimated distance from the closest point on a bounding box to a point. */
   distanceTo(point) {
     return Math.sqrt(this.distanceSquaredTo(point));
   }
+  /**
+   * Computes the estimated distance squared from the closest point
+   * on a bounding box to a point.
+   * See Geometric Tools for Computer Graphics 10.4.2
+   */
   distanceSquaredTo(point) {
     const offset = scratchOffset.from(point).subtract(this.center);
     const halfAxes = this.halfAxes;
@@ -306,6 +373,21 @@ var OrientedBoundingBox = class {
     }
     return distanceSquared;
   }
+  /**
+   * The distances calculated by the vector from the center of the bounding box
+   * to position projected onto direction.
+   *
+   * - If you imagine the infinite number of planes with normal direction,
+   *   this computes the smallest distance to the closest and farthest planes
+   *   from `position` that intersect the bounding box.
+   *
+   * @param position The position to calculate the distance from.
+   * @param direction The direction from position.
+   * @param result An Interval (array of length 2) to store the nearest and farthest distances.
+   * @returns Interval (array of length 2) with nearest and farthest distances
+   *   on the bounding box from position in direction.
+   */
+  // eslint-disable-next-line max-statements
   computePlaneDistances(position, direction, result = [-0, -0]) {
     let minDist = Number.POSITIVE_INFINITY;
     let maxDist = Number.NEGATIVE_INFINITY;
@@ -358,6 +440,11 @@ var OrientedBoundingBox = class {
     result[1] = maxDist;
     return result;
   }
+  /**
+   * Applies a 4x4 affine transformation matrix to a bounding sphere.
+   * @param transform The transformation matrix to apply to the bounding sphere.
+   * @returns itself, i.e. the modified BoundingVolume.
+   */
   transform(transformation) {
     this.center.transformAsPoint(transformation);
     const xAxis = this.halfAxes.getColumn(0, scratchVectorU);
@@ -387,12 +474,14 @@ var Plane = class {
     this.distance = -0;
     this.fromNormalDistance(normal, distance);
   }
+  /** Creates a plane from a normal and a distance from the origin. */
   fromNormalDistance(normal, distance) {
     (0, import_core4.assert)(Number.isFinite(distance));
     this.normal.from(normal).normalize();
     this.distance = distance;
     return this;
   }
+  /** Creates a plane from a normal and a point on the plane. */
   fromPointNormal(point, normal) {
     point = scratchPosition.from(point);
     this.normal.from(normal).normalize();
@@ -400,21 +489,28 @@ var Plane = class {
     this.distance = distance;
     return this;
   }
+  /** Creates a plane from the general equation */
   fromCoefficients(a, b, c, d) {
     this.normal.set(a, b, c);
     (0, import_core4.assert)((0, import_core4.equals)(this.normal.len(), 1));
     this.distance = d;
     return this;
   }
+  /** Duplicates a Plane instance. */
   clone() {
     return new Plane(this.normal, this.distance);
   }
+  /** Compares the provided Planes by normal and distance */
   equals(right) {
     return (0, import_core4.equals)(this.distance, right.distance) && (0, import_core4.equals)(this.normal, right.normal);
   }
+  /** Computes the signed shortest distance of a point to a plane.
+   * The sign of the distance determines which side of the plane the point is on.
+   */
   getPointDistance(point) {
     return this.normal.dot(point) + this.distance;
   }
+  /** Transforms the plane by the given transformation matrix. */
   transform(matrix4) {
     const normal = scratchNormal2.copy(this.normal).transformAsVector(matrix4).normalize();
     const point = this.normal.scale(-this.distance).transform(matrix4);
@@ -426,6 +522,30 @@ var Plane = class {
     const scaledNormal = scratchNormal2.copy(this.normal).scale(pointDistance);
     return scratchPoint.subtract(scaledNormal).to(result);
   }
+  /**
+   * Computes the intersection of a ray and this plane.
+   *
+   * @param {Ray} ray The ray.
+   * @param {Vector3} [result] The object onto which to store the result.
+   * @returns {Vector3} The intersection point or undefined if there is no intersections.
+   */
+  intersectWithRay(ray, result) {
+    if (!result)
+      result = new import_core4.Vector3();
+    const origin = ray.origin;
+    const direction = ray.direction;
+    const normal = this.normal;
+    const denominator = normal.dot(direction);
+    if (Math.abs(denominator) < import_core4._MathUtils.EPSILON15) {
+      return void 0;
+    }
+    const t = (-this.distance - normal.dot(origin)) / denominator;
+    if (t < 0) {
+      return void 0;
+    }
+    result = result.copy(direction).multiplyByScalar(t);
+    return origin.add(result);
+  }
 };
 
 // dist/lib/culling-volume.js
@@ -433,9 +553,17 @@ var faces = [new import_core5.Vector3([1, 0, 0]), new import_core5.Vector3([0, 1
 var scratchPlaneCenter = new import_core5.Vector3();
 var scratchPlaneNormal = new import_core5.Vector3();
 var CullingVolume = class {
+  /**
+   * Create a new `CullingVolume` bounded by an array of clipping planed
+   * @param planes Array of clipping planes.
+   * */
   constructor(planes = []) {
     this.planes = planes;
   }
+  /**
+   * Constructs a culling volume from a bounding sphere. Creates six planes that create a box containing the sphere.
+   * The planes are aligned to the x, y, and z axes in world coordinates.
+   */
   fromBoundingSphere(boundingSphere) {
     this.planes.length = 2 * faces.length;
     const center = boundingSphere.center;
@@ -459,6 +587,7 @@ var CullingVolume = class {
     }
     return this;
   }
+  /** Determines whether a bounding volume intersects the culling volume. */
   computeVisibility(boundingVolume) {
     let intersect = INTERSECTION.INSIDE;
     for (const plane of this.planes) {
@@ -474,6 +603,14 @@ var CullingVolume = class {
     }
     return intersect;
   }
+  /**
+   * Determines whether a bounding volume intersects the culling volume.
+   *
+   * @param parentPlaneMask A bit mask from the boundingVolume's parent's check against the same culling
+   *   volume, such that if (planeMask & (1 << planeIndex) === 0), for k < 31, then
+   *   the parent (and therefore this) volume is completely inside plane[planeIndex]
+   *   and that plane check can be skipped.
+   */
   computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) {
     (0, import_core5.assert)(Number.isFinite(parentPlaneMask), "parentPlaneMask is required.");
     if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {
@@ -501,14 +638,57 @@ CullingVolume.MASK_OUTSIDE = 4294967295;
 CullingVolume.MASK_INSIDE = 0;
 CullingVolume.MASK_INDETERMINATE = 2147483647;
 
-// dist/lib/perspective-off-center-frustum.js
+// dist/lib/ray.js
 var import_core6 = require("@math.gl/core");
-var scratchPlaneUpVector = new import_core6.Vector3();
-var scratchPlaneRightVector = new import_core6.Vector3();
-var scratchPlaneNearCenter = new import_core6.Vector3();
-var scratchPlaneFarCenter = new import_core6.Vector3();
-var scratchPlaneNormal2 = new import_core6.Vector3();
+var Ray = class {
+  /**
+   * Creates a new ray that extends infinitely from the provided origin in the provided direction.
+   *
+   * @param [origin=Vector3] The origin of the ray.
+   * @param [direction=Vector3] The direction of the ray.
+   */
+  constructor(origin, direction) {
+    if (origin)
+      origin = origin.clone();
+    else
+      origin = new import_core6.Vector3();
+    if (direction)
+      direction = direction.clone().normalize();
+    else
+      direction = new import_core6.Vector3();
+    this.origin = origin;
+    this.direction = direction;
+  }
+};
+
+// dist/lib/perspective-off-center-frustum.js
+var import_core7 = require("@math.gl/core");
+var scratchPlaneUpVector = new import_core7.Vector3();
+var scratchPlaneRightVector = new import_core7.Vector3();
+var scratchPlaneNearCenter = new import_core7.Vector3();
+var scratchPlaneFarCenter = new import_core7.Vector3();
+var scratchPlaneNormal2 = new import_core7.Vector3();
 var PerspectiveOffCenterFrustum = class {
+  /**
+   * The viewing frustum is defined by 6 planes.
+   * Each plane is represented by a {@link Vector4} object, where the x, y, and z components
+   * define the unit vector normal to the plane, and the w component is the distance of the
+   * plane from the origin/camera position.
+   *
+   * @alias PerspectiveOffCenterFrustum
+   *
+   * @example
+   * const frustum = new PerspectiveOffCenterFrustum({
+   *     left : -1.0,
+   *     right : 1.0,
+   *     top : 1.0,
+   *     bottom : -1.0,
+   *     near : 1.0,
+   *     far : 100.0
+   * });
+   *
+   * @see PerspectiveFrustum
+   */
   constructor(options = {}) {
     this._cullingVolume = new CullingVolume([
       new Plane(),
@@ -518,8 +698,8 @@ var PerspectiveOffCenterFrustum = class {
       new Plane(),
       new Plane()
     ]);
-    this._perspectiveMatrix = new import_core6.Matrix4();
-    this._infinitePerspective = new import_core6.Matrix4();
+    this._perspectiveMatrix = new import_core7.Matrix4();
+    this._infinitePerspective = new import_core7.Matrix4();
     const { near = 1, far = 5e8 } = options;
     this.left = options.left;
     this._left = void 0;
@@ -534,6 +714,10 @@ var PerspectiveOffCenterFrustum = class {
     this.far = far;
     this._far = far;
   }
+  /**
+   * Returns a duplicate of a PerspectiveOffCenterFrustum instance.
+   * @returns {PerspectiveOffCenterFrustum} A new PerspectiveFrustum instance.
+   * */
   clone() {
     return new PerspectiveOffCenterFrustum({
       right: this.right,
@@ -544,21 +728,51 @@ var PerspectiveOffCenterFrustum = class {
       far: this.far
     });
   }
+  /**
+   * Compares the provided PerspectiveOffCenterFrustum componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
+   */
   equals(other) {
     return other && other instanceof PerspectiveOffCenterFrustum && this.right === other.right && this.left === other.left && this.top === other.top && this.bottom === other.bottom && this.near === other.near && this.far === other.far;
   }
+  /**
+   * Gets the perspective projection matrix computed from the view frustum.
+   * @memberof PerspectiveOffCenterFrustum.prototype
+   * @type {Matrix4}
+   *
+   * @see PerspectiveOffCenterFrustum#infiniteProjectionMatrix
+   */
   get projectionMatrix() {
     this._update();
     return this._perspectiveMatrix;
   }
+  /**
+   * Gets the perspective projection matrix computed from the view frustum with an infinite far plane.
+   * @memberof PerspectiveOffCenterFrustum.prototype
+   * @type {Matrix4}
+   *
+   * @see PerspectiveOffCenterFrustum#projectionMatrix
+   */
   get infiniteProjectionMatrix() {
     this._update();
     return this._infinitePerspective;
   }
+  /**
+   * Creates a culling volume for this frustum.
+   * @returns {CullingVolume} A culling volume at the given position and orientation.
+   *
+   * @example
+   * // Check if a bounding volume intersects the frustum.
+   * const cullingVolume = frustum.computeCullingVolume(cameraPosition, cameraDirection, cameraUp);
+   * const intersect = cullingVolume.computeVisibility(boundingVolume);
+   */
+  // eslint-disable-next-line complexity, max-statements
   computeCullingVolume(position, direction, up) {
-    (0, import_core6.assert)(position, "position is required.");
-    (0, import_core6.assert)(direction, "direction is required.");
-    (0, import_core6.assert)(up, "up is required.");
+    (0, import_core7.assert)(position, "position is required.");
+    (0, import_core7.assert)(direction, "direction is required.");
+    (0, import_core7.assert)(up, "up is required.");
     const planes = this._cullingVolume.planes;
     up = scratchPlaneUpVector.copy(up).normalize();
     const right = scratchPlaneRightVector.copy(direction).cross(up).normalize();
@@ -573,19 +787,43 @@ var PerspectiveOffCenterFrustum = class {
     planes[2].fromPointNormal(position, normal);
     normal.copy(up).multiplyByScalar(this.top).add(nearCenter).subtract(position).cross(right);
     planes[3].fromPointNormal(position, normal);
-    normal = new import_core6.Vector3().copy(direction);
+    normal = new import_core7.Vector3().copy(direction);
     planes[4].fromPointNormal(nearCenter, normal);
     normal.negate();
     planes[5].fromPointNormal(farCenter, normal);
     return this._cullingVolume;
   }
+  /**
+   * Returns the pixel's width and height in meters.
+   *
+   * @returns {Vector2} The modified result parameter or a new instance of {@link Vector2} with the pixel's width and height in the x and y properties, respectively.
+   *
+   * @exception {DeveloperError} drawingBufferWidth must be greater than zero.
+   * @exception {DeveloperError} drawingBufferHeight must be greater than zero.
+   *
+   * @example
+   * // Example 1
+   * // Get the width and height of a pixel.
+   * const pixelSize = camera.frustum.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, 1.0, new Vector2());
+   *
+   * @example
+   * // Example 2
+   * // Get the width and height of a pixel if the near plane was set to 'distance'.
+   * // For example, get the size of a pixel of an image on a billboard.
+   * const position = camera.position;
+   * const direction = camera.direction;
+   * const toCenter = Vector3.subtract(primitive.boundingVolume.center, position, new Vector3());      // vector from camera to a primitive
+   * const toCenterProj = Vector3.multiplyByScalar(direction, Vector3.dot(direction, toCenter), new Vector3()); // project vector onto camera direction vector
+   * const distance = Vector3.magnitude(toCenterProj);
+   * const pixelSize = camera.frustum.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, distance, new Vector2());
+   */
   getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result) {
     this._update();
-    (0, import_core6.assert)(Number.isFinite(drawingBufferWidth) && Number.isFinite(drawingBufferHeight));
-    (0, import_core6.assert)(drawingBufferWidth > 0);
-    (0, import_core6.assert)(drawingBufferHeight > 0);
-    (0, import_core6.assert)(distance > 0);
-    (0, import_core6.assert)(result);
+    (0, import_core7.assert)(Number.isFinite(drawingBufferWidth) && Number.isFinite(drawingBufferHeight));
+    (0, import_core7.assert)(drawingBufferWidth > 0);
+    (0, import_core7.assert)(drawingBufferHeight > 0);
+    (0, import_core7.assert)(distance > 0);
+    (0, import_core7.assert)(result);
     const inverseNear = 1 / this.near;
     let tanTheta = this.top * inverseNear;
     const pixelHeight = 2 * distance * tanTheta / drawingBufferHeight;
@@ -595,18 +833,19 @@ var PerspectiveOffCenterFrustum = class {
     result.y = pixelHeight;
     return result;
   }
+  // eslint-disable-next-line complexity, max-statements
   _update() {
-    (0, import_core6.assert)(Number.isFinite(this.right) && Number.isFinite(this.left) && Number.isFinite(this.top) && Number.isFinite(this.bottom) && Number.isFinite(this.near) && Number.isFinite(this.far));
+    (0, import_core7.assert)(Number.isFinite(this.right) && Number.isFinite(this.left) && Number.isFinite(this.top) && Number.isFinite(this.bottom) && Number.isFinite(this.near) && Number.isFinite(this.far));
     const { top, bottom, right, left, near, far } = this;
     if (top !== this._top || bottom !== this._bottom || left !== this._left || right !== this._right || near !== this._near || far !== this._far) {
-      (0, import_core6.assert)(this.near > 0 && this.near < this.far, "near must be greater than zero and less than far.");
+      (0, import_core7.assert)(this.near > 0 && this.near < this.far, "near must be greater than zero and less than far.");
       this._left = left;
       this._right = right;
       this._top = top;
       this._bottom = bottom;
       this._near = near;
       this._far = far;
-      this._perspectiveMatrix = new import_core6.Matrix4().frustum({
+      this._perspectiveMatrix = new import_core7.Matrix4().frustum({
         left,
         right,
         bottom,
@@ -614,7 +853,7 @@ var PerspectiveOffCenterFrustum = class {
         near,
         far
       });
-      this._infinitePerspective = new import_core6.Matrix4().frustum({
+      this._infinitePerspective = new import_core7.Matrix4().frustum({
         left,
         right,
         bottom,
@@ -627,7 +866,7 @@ var PerspectiveOffCenterFrustum = class {
 };
 
 // dist/lib/perspective-frustum.js
-var import_core7 = require("@math.gl/core");
+var import_core8 = require("@math.gl/core");
 var defined = (val) => val !== null && typeof val !== "undefined";
 var PerspectiveFrustum = class {
   constructor(options = {}) {
@@ -640,6 +879,9 @@ var PerspectiveFrustum = class {
     this.xOffset = xOffset;
     this.yOffset = yOffset;
   }
+  /**
+   * Returns a duplicate of a PerspectiveFrustum instance.
+   */
   clone() {
     return new PerspectiveFrustum({
       aspectRatio: this.aspectRatio,
@@ -648,6 +890,10 @@ var PerspectiveFrustum = class {
       far: this.far
     });
   }
+  /**
+   * Compares the provided PerspectiveFrustum componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   */
   equals(other) {
     if (!defined(other) || !(other instanceof PerspectiveFrustum)) {
       return false;
@@ -656,37 +902,82 @@ var PerspectiveFrustum = class {
     other._update();
     return this.fov === other.fov && this.aspectRatio === other.aspectRatio && this.near === other.near && this.far === other.far && this._offCenterFrustum.equals(other._offCenterFrustum);
   }
+  /**
+   * Gets the perspective projection matrix computed from the view this.
+   */
   get projectionMatrix() {
     this._update();
     return this._offCenterFrustum.projectionMatrix;
   }
+  /**
+   * The perspective projection matrix computed from the view frustum with an infinite far plane.
+   */
   get infiniteProjectionMatrix() {
     this._update();
     return this._offCenterFrustum.infiniteProjectionMatrix;
   }
+  /**
+   * Gets the angle of the vertical field of view, in radians.
+   */
   get fovy() {
     this._update();
     return this._fovy;
   }
+  /**
+   * @private
+   */
   get sseDenominator() {
     this._update();
     return this._sseDenominator;
   }
+  /**
+   * Creates a culling volume for this this.ion.
+   * @returns {CullingVolume} A culling volume at the given position and orientation.
+   *
+   * @example
+   * // Check if a bounding volume intersects the this.
+   * var cullingVolume = this.computeCullingVolume(cameraPosition, cameraDirection, cameraUp);
+   * var intersect = cullingVolume.computeVisibility(boundingVolume);
+   */
   computeCullingVolume(position, direction, up) {
     this._update();
     return this._offCenterFrustum.computeCullingVolume(position, direction, up);
   }
+  /**
+   * Returns the pixel's width and height in meters.
+   * @returns {Vector2} The modified result parameter or a new instance of {@link Vector2} with the pixel's width and height in the x and y properties, respectively.
+   *
+   * @exception {DeveloperError} drawingBufferWidth must be greater than zero.
+   * @exception {DeveloperError} drawingBufferHeight must be greater than zero.
+   *
+   * @example
+   * // Example 1
+   * // Get the width and height of a pixel.
+   * var pixelSize = camera.this.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, 1.0, new Vector2());
+   *
+   * @example
+   * // Example 2
+   * // Get the width and height of a pixel if the near plane was set to 'distance'.
+   * // For example, get the size of a pixel of an image on a billboard.
+   * var position = camera.position;
+   * var direction = camera.direction;
+   * var toCenter = Vector3.subtract(primitive.boundingVolume.center, position, new Vector3());      // vector from camera to a primitive
+   * var toCenterProj = Vector3.multiplyByScalar(direction, Vector3.dot(direction, toCenter), new Vector3()); // project vector onto camera direction vector
+   * var distance = Vector3.magnitude(toCenterProj);
+   * var pixelSize = camera.this.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, distance, new Vector2());
+   */
   getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result) {
     this._update();
-    return this._offCenterFrustum.getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result || new import_core7.Vector2());
+    return this._offCenterFrustum.getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result || new import_core8.Vector2());
   }
+  // eslint-disable-next-line complexity, max-statements
   _update() {
-    (0, import_core7.assert)(Number.isFinite(this.fov) && Number.isFinite(this.aspectRatio) && Number.isFinite(this.near) && Number.isFinite(this.far));
+    (0, import_core8.assert)(Number.isFinite(this.fov) && Number.isFinite(this.aspectRatio) && Number.isFinite(this.near) && Number.isFinite(this.far));
     const f = this._offCenterFrustum;
     if (this.fov !== this._fov || this.aspectRatio !== this._aspectRatio || this.near !== this._near || this.far !== this._far || this.xOffset !== this._xOffset || this.yOffset !== this._yOffset) {
-      (0, import_core7.assert)(this.fov >= 0 && this.fov < Math.PI);
-      (0, import_core7.assert)(this.aspectRatio > 0);
-      (0, import_core7.assert)(this.near >= 0 && this.near < this.far);
+      (0, import_core8.assert)(this.fov >= 0 && this.fov < Math.PI);
+      (0, import_core8.assert)(this.aspectRatio > 0);
+      (0, import_core8.assert)(this.near >= 0 && this.near < this.far);
       this._aspectRatio = this.aspectRatio;
       this._fov = this.fov;
       this._fovy = this.aspectRatio <= 1 ? this.fov : Math.atan(Math.tan(this.fov * 0.5) / this.aspectRatio) * 2;
@@ -710,19 +1001,19 @@ var PerspectiveFrustum = class {
 };
 
 // dist/lib/algorithms/bounding-sphere-from-points.js
-var import_core8 = require("@math.gl/core");
-var fromPointsXMin = new import_core8.Vector3();
-var fromPointsYMin = new import_core8.Vector3();
-var fromPointsZMin = new import_core8.Vector3();
-var fromPointsXMax = new import_core8.Vector3();
-var fromPointsYMax = new import_core8.Vector3();
-var fromPointsZMax = new import_core8.Vector3();
-var fromPointsCurrentPos = new import_core8.Vector3();
-var fromPointsScratch = new import_core8.Vector3();
-var fromPointsRitterCenter = new import_core8.Vector3();
-var fromPointsMinBoxPt = new import_core8.Vector3();
-var fromPointsMaxBoxPt = new import_core8.Vector3();
-var fromPointsNaiveCenterScratch = new import_core8.Vector3();
+var import_core9 = require("@math.gl/core");
+var fromPointsXMin = new import_core9.Vector3();
+var fromPointsYMin = new import_core9.Vector3();
+var fromPointsZMin = new import_core9.Vector3();
+var fromPointsXMax = new import_core9.Vector3();
+var fromPointsYMax = new import_core9.Vector3();
+var fromPointsZMax = new import_core9.Vector3();
+var fromPointsCurrentPos = new import_core9.Vector3();
+var fromPointsScratch = new import_core9.Vector3();
+var fromPointsRitterCenter = new import_core9.Vector3();
+var fromPointsMinBoxPt = new import_core9.Vector3();
+var fromPointsMaxBoxPt = new import_core9.Vector3();
+var fromPointsNaiveCenterScratch = new import_core9.Vector3();
 function makeBoundingSphereFromPoints(positions, result = new BoundingSphere()) {
   if (!positions || positions.length === 0) {
     return result.fromCenterRadius([0, 0, 0], 0);
@@ -818,17 +1109,17 @@ function makeBoundingSphereFromPoints(positions, result = new BoundingSphere())
 }
 
 // dist/lib/algorithms/bounding-box-from-points.js
-var import_core10 = require("@math.gl/core");
+var import_core11 = require("@math.gl/core");
 
 // dist/lib/algorithms/compute-eigen-decomposition.js
-var import_core9 = require("@math.gl/core");
-var scratchMatrix = new import_core9.Matrix3();
-var scratchUnitary = new import_core9.Matrix3();
-var scratchDiagonal = new import_core9.Matrix3();
-var jMatrix = new import_core9.Matrix3();
-var jMatrixTranspose = new import_core9.Matrix3();
+var import_core10 = require("@math.gl/core");
+var scratchMatrix = new import_core10.Matrix3();
+var scratchUnitary = new import_core10.Matrix3();
+var scratchDiagonal = new import_core10.Matrix3();
+var jMatrix = new import_core10.Matrix3();
+var jMatrixTranspose = new import_core10.Matrix3();
 function computeEigenDecomposition(matrix, result = {}) {
-  const EIGEN_TOLERANCE = import_core9._MathUtils.EPSILON20;
+  const EIGEN_TOLERANCE = import_core10._MathUtils.EPSILON20;
   const EIGEN_MAX_SWEEPS = 10;
   let count = 0;
   let sweep = 0;
@@ -871,7 +1162,7 @@ function offDiagonalFrobeniusNorm(matrix) {
   return Math.sqrt(norm);
 }
 function shurDecomposition(matrix, result) {
-  const tolerance = import_core9._MathUtils.EPSILON15;
+  const tolerance = import_core10._MathUtils.EPSILON15;
   let maxDiagonal = 0;
   let rotAxis = 1;
   for (let i = 0; i < 3; ++i) {
@@ -899,7 +1190,7 @@ function shurDecomposition(matrix, result) {
     c = 1 / Math.sqrt(1 + t * t);
     s = t * c;
   }
-  import_core9.Matrix3.IDENTITY.to(result);
+  import_core10.Matrix3.IDENTITY.to(result);
   result[scratchMatrix.getElementIndex(p, p)] = result[scratchMatrix.getElementIndex(q, q)] = c;
   result[scratchMatrix.getElementIndex(q, p)] = s;
   result[scratchMatrix.getElementIndex(p, q)] = -s;
@@ -907,24 +1198,24 @@ function shurDecomposition(matrix, result) {
 }
 
 // dist/lib/algorithms/bounding-box-from-points.js
-var scratchVector23 = new import_core10.Vector3();
-var scratchVector32 = new import_core10.Vector3();
-var scratchVector4 = new import_core10.Vector3();
-var scratchVector5 = new import_core10.Vector3();
-var scratchVector6 = new import_core10.Vector3();
-var scratchCovarianceResult = new import_core10.Matrix3();
+var scratchVector23 = new import_core11.Vector3();
+var scratchVector32 = new import_core11.Vector3();
+var scratchVector4 = new import_core11.Vector3();
+var scratchVector5 = new import_core11.Vector3();
+var scratchVector6 = new import_core11.Vector3();
+var scratchCovarianceResult = new import_core11.Matrix3();
 var scratchEigenResult = {
-  diagonal: new import_core10.Matrix3(),
-  unitary: new import_core10.Matrix3()
+  diagonal: new import_core11.Matrix3(),
+  unitary: new import_core11.Matrix3()
 };
 function makeOrientedBoundingBoxFromPoints(positions, result = new OrientedBoundingBox()) {
   if (!positions || positions.length === 0) {
-    result.halfAxes = new import_core10.Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);
-    result.center = new import_core10.Vector3();
+    result.halfAxes = new import_core11.Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    result.center = new import_core11.Vector3();
     return result;
   }
   const length = positions.length;
-  const meanPoint = new import_core10.Vector3(0, 0, 0);
+  const meanPoint = new import_core11.Vector3(0, 0, 0);
   for (const position of positions) {
     meanPoint.add(position);
   }
@@ -986,7 +1277,7 @@ function makeOrientedBoundingBoxFromPoints(positions, result = new OrientedBound
   v3 = v3.multiplyByScalar(0.5 * (l3 + u3));
   result.center.copy(v1).add(v2).add(v3);
   const scale = scratchVector32.set(u1 - l1, u2 - l2, u3 - l3).multiplyByScalar(0.5);
-  const scaleMatrix = new import_core10.Matrix3([scale[0], 0, 0, 0, scale[1], 0, 0, 0, scale[2]]);
+  const scaleMatrix = new import_core11.Matrix3([scale[0], 0, 0, 0, scale[1], 0, 0, 0, scale[2]]);
   result.halfAxes.multiplyRight(scaleMatrix);
   return result;
 }