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

package/dist/constants.d.ts

@@ -3,3 +3,4 @@ export declare const INTERSECTION: {
     readonly INTERSECTING: 0;
     readonly INSIDE: 1;
 };
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

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

package/dist/constants.js

@@ -6,3 +6,4 @@ export const INTERSECTION = {
     INTERSECTING: 0, // Represents that an object intersects one of the frustum's planes.
     INSIDE: 1 // Represents that an object is fully within the frustum.
 };
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,OAAO,EAAE,CAAC,CAAC,EAAE,iEAAiE;IAC9E,YAAY,EAAE,CAAC,EAAE,oEAAoE;IACrF,MAAM,EAAE,CAAC,CAAC,yDAAyD;CAC3D,CAAC"}

package/dist/index.cjs

@@ -37,8 +37,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 +49,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 +62,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 +92,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 +108,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 +139,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 +189,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 +198,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 +263,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 +280,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 +299,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 +318,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 +335,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 +372,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 +439,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 +473,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 +488,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);
@@ -433,9 +528,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 +562,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 +578,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) {
@@ -509,6 +621,26 @@ var scratchPlaneNearCenter = new import_core6.Vector3();
 var scratchPlaneFarCenter = new import_core6.Vector3();
 var scratchPlaneNormal2 = new import_core6.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(),
@@ -534,6 +666,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,17 +680,47 @@ 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.");
@@ -579,6 +745,30 @@ var PerspectiveOffCenterFrustum = class {
     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));
@@ -595,6 +785,7 @@ 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));
     const { top, bottom, right, left, near, far } = this;
@@ -640,6 +831,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 +842,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,30 +854,75 @@ 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());
   }
+  // 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));
     const f = this._offCenterFrustum;