@math.gl/culling 3.5.7 → 3.6.0-alpha.3

package/dist/lib/perspective-frustum.js

@@ -0,0 +1,205 @@
+// This file is derived from the Cesium math library under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+// Note: This class is still an experimental export, mainly used by other test cases
+// - It has not been fully adapted to math.gl conventions
+// - Documentation has not been ported
+// @ts-nocheck
+import { assert } from '@math.gl/core';
+import PerspectiveOffCenterFrustum from './perspective-off-center-frustum';
+const defined = (val) => val !== null && typeof val !== 'undefined';
+/**
+ * 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 PerspectiveFrustum
+ * @constructor
+ *
+ * @param {Object} [options] An object with the following properties:
+ * @param {Number} [options.fov] The angle of the field of view (FOV), in radians.
+ * @param {Number} [options.aspectRatio] The aspect ratio of the frustum's width to it's height.
+ * @param {Number} [options.near=1.0] The distance of the near plane.
+ * @param {Number} [options.far=500000000.0] The distance of the far plane.
+ * @param {Number} [options.xOffset=0.0] The offset in the x direction.
+ * @param {Number} [options.yOffset=0.0] The offset in the y direction.
+ *
+ * @example
+ * var frustum = new PerspectiveFrustum({
+ *     fov : Math.PI_OVER_THREE,
+ *     aspectRatio : canvas.clientWidth / canvas.clientHeight
+ *     near : 1.0,
+ *     far : 1000.0
+ * });
+ *
+ * @see PerspectiveOffCenterFrustum
+ */
+export default class PerspectiveFrustum {
+    constructor(options = {}) {
+        this._offCenterFrustum = new PerspectiveOffCenterFrustum();
+        options = {
+            near: 1.0,
+            far: 500000000.0,
+            xOffset: 0.0,
+            yOffset: 0.0,
+            ...options
+        };
+        this.fov = options.fov;
+        this.aspectRatio = options.aspectRatio;
+        this.near = options.near;
+        this._near = this.near;
+        this.far = options.far;
+        this._far = this.far;
+        this.xOffset = options.xOffset;
+        this._xOffset = this.xOffset;
+        this.yOffset = options.yOffset;
+        this._yOffset = this.yOffset;
+    }
+    /**
+     * Returns a duplicate of a PerspectiveFrustum instance.
+     */
+    clone() {
+        return new PerspectiveFrustum({
+            aspectRatio: this.aspectRatio,
+            fov: this.fov,
+            near: this.near,
+            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;
+        }
+        update(this);
+        update(other);
+        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 frustum.
+     */
+    get projectionMatrix() {
+        update(this);
+        return this._offCenterFrustum.projectionMatrix;
+    }
+    /**
+     * The perspective projection matrix computed from the view frustum with an infinite far plane.
+     */
+    get infiniteProjectionMatrix() {
+        update(this);
+        return this._offCenterFrustum.infiniteProjectionMatrix;
+    }
+    /**
+     * Gets the angle of the vertical field of view, in radians.
+     */
+    get fovy() {
+        update(this);
+        return this._fovy;
+    }
+    /**
+     * @private
+     */
+    get sseDenominator() {
+        update(this);
+        return this._sseDenominator;
+    }
+    /**
+     * Creates a culling volume for this frustum.
+     *
+     * @param {Vector3} position The eye position.
+     * @param {Vector3} direction The view direction.
+     * @param {Vector3} up The up direction.
+     * @returns {CullingVolume} A culling volume at the given position and orientation.
+     *
+     * @example
+     * // Check if a bounding volume intersects the frustum.
+     * var cullingVolume = frustum.computeCullingVolume(cameraPosition, cameraDirection, cameraUp);
+     * var intersect = cullingVolume.computeVisibility(boundingVolume);
+     */
+    computeCullingVolume(position, direction, up) {
+        update(this);
+        return this._offCenterFrustum.computeCullingVolume(position, direction, up);
+    }
+    /**
+     * Returns the pixel's width and height in meters.
+     *
+     * @param {Number} drawingBufferWidth The width of the drawing buffer.
+     * @param {Number} drawingBufferHeight The height of the drawing buffer.
+     * @param {Number} distance The distance to the near plane in meters.
+     * @param {Vector2} result The object onto which to store the result.
+     * @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.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.
+     * 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.frustum.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, distance, new Vector2());
+     */
+    getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result) {
+        update(this);
+        return this._offCenterFrustum.getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result);
+    }
+}
+// eslint-disable-next-line complexity, max-statements
+function update(frustum) {
+    assert(Number.isFinite(frustum.fov) &&
+        Number.isFinite(frustum.aspectRatio) &&
+        Number.isFinite(frustum.near) &&
+        Number.isFinite(frustum.far));
+    // 'fov, aspectRatio, near, or far parameters are not set.'
+    const f = frustum._offCenterFrustum;
+    if (frustum.fov !== frustum._fov ||
+        frustum.aspectRatio !== frustum._aspectRatio ||
+        frustum.near !== frustum._near ||
+        frustum.far !== frustum._far ||
+        frustum.xOffset !== frustum._xOffset ||
+        frustum.yOffset !== frustum._yOffset) {
+        assert(frustum.fov >= 0 && frustum.fov < Math.PI);
+        // throw new DeveloperError('fov must be in the range [0, PI).');
+        assert(frustum.aspectRatio > 0);
+        // throw new DeveloperError('aspectRatio must be positive.');
+        assert(frustum.near >= 0 && frustum.near < frustum.far);
+        // throw new DeveloperError('near must be greater than zero and less than far.');
+        frustum._aspectRatio = frustum.aspectRatio;
+        frustum._fov = frustum.fov;
+        frustum._fovy =
+            frustum.aspectRatio <= 1
+                ? frustum.fov
+                : Math.atan(Math.tan(frustum.fov * 0.5) / frustum.aspectRatio) * 2.0;
+        frustum._near = frustum.near;
+        frustum._far = frustum.far;
+        frustum._sseDenominator = 2.0 * Math.tan(0.5 * frustum._fovy);
+        frustum._xOffset = frustum.xOffset;
+        frustum._yOffset = frustum.yOffset;
+        f.top = frustum.near * Math.tan(0.5 * frustum._fovy);
+        f.bottom = -f.top;
+        f.right = frustum.aspectRatio * f.top;
+        f.left = -f.right;
+        f.near = frustum.near;
+        f.far = frustum.far;
+        f.right += frustum.xOffset;
+        f.left += frustum.xOffset;
+        f.top += frustum.yOffset;
+        f.bottom += frustum.yOffset;
+    }
+}

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

@@ -0,0 +1,122 @@
+import { Matrix4 } from '@math.gl/core';
+import CullingVolume from './culling-volume';
+export default class PerspectiveOffCenterFrustum {
+    left: any;
+    _left: any;
+    right: any;
+    _right: any;
+    top: any;
+    _top: any;
+    bottom: any;
+    _bottom: any;
+    near: any;
+    _near: any;
+    far: any;
+    _far: any;
+    _cullingVolume: CullingVolume;
+    _perspectiveMatrix: Matrix4;
+    _infinitePerspective: Matrix4;
+    /**
+     * 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
+     * @constructor
+     *
+     * @param {Object} [options] An object with the following properties:
+     * @param {Number} [options.left] The left clipping plane distance.
+     * @param {Number} [options.right] The right clipping plane distance.
+     * @param {Number} [options.top] The top clipping plane distance.
+     * @param {Number} [options.bottom] The bottom clipping plane distance.
+     * @param {Number} [options.near=1.0] The near clipping plane distance.
+     * @param {Number} [options.far=500000000.0] The far clipping plane distance.
+     *
+     * @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?: Record<string, any>);
+    /**
+     * Returns a duplicate of a PerspectiveOffCenterFrustum instance.
+     * @returns {PerspectiveOffCenterFrustum} A new PerspectiveFrustum instance.
+     * */
+    clone(): PerspectiveOffCenterFrustum;
+    /**
+     * Compares the provided PerspectiveOffCenterFrustum componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     *
+     * @param {PerspectiveOffCenterFrustum} [other] The right hand side PerspectiveOffCenterFrustum.
+     * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
+     */
+    equals(other: any): boolean;
+    /**
+     * Gets the perspective projection matrix computed from the view frustum.
+     * @memberof PerspectiveOffCenterFrustum.prototype
+     * @type {Matrix4}
+     *
+     * @see PerspectiveOffCenterFrustum#infiniteProjectionMatrix
+     */
+    get projectionMatrix(): Matrix4;
+    /**
+     * 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(): Matrix4;
+    /**
+     * Creates a culling volume for this frustum.
+     *
+     * @param {Vector3} position The eye position.
+     * @param {Vector3} direction The view direction.
+     * @param {Vector3} up The up direction.
+     * @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);
+     */
+    computeCullingVolume(position: any, direction: any, up: any): CullingVolume;
+    /**
+     * Returns the pixel's width and height in meters.
+     *
+     * @param {Number} drawingBufferWidth The width of the drawing buffer.
+     * @param {Number} drawingBufferHeight The height of the drawing buffer.
+     * @param {Number} distance The distance to the near plane in meters.
+     * @param {Vector2} result The object onto which to store the result.
+     * @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: any, drawingBufferHeight: any, distance: any, result: any): any;
+}
+//# sourceMappingURL=perspective-off-center-frustum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"perspective-off-center-frustum.d.ts","sourceRoot":"","sources":["../../src/lib/perspective-off-center-frustum.ts"],"names":[],"mappings":"AASA,OAAO,EAAU,OAAO,EAAS,MAAM,eAAe,CAAC;AACvD,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAS7C,MAAM,CAAC,OAAO,OAAO,2BAA2B;IAC9C,IAAI,MAAC;IACL,KAAK,MAAC;IACN,KAAK,MAAC;IACN,MAAM,MAAC;IACP,GAAG,MAAC;IACJ,IAAI,MAAC;IACL,MAAM,MAAC;IACP,OAAO,MAAC;IACR,IAAI,MAAC;IACL,KAAK,MAAC;IACN,GAAG,MAAC;IACJ,IAAI,MAAC;IACL,cAAc,gBAOX;IACH,kBAAkB,UAAiB;IACnC,oBAAoB,UAAiB;IAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;gBACS,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM;IAoD7C;;;SAGK;IACL,KAAK;IAWL;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,KAAA;IAaZ;;;;;;OAMG;IACH,IAAI,gBAAgB,YAGnB;IAED;;;;;;OAMG;IACH,IAAI,wBAAwB,YAG3B;IAED;;;;;;;;;;;;OAYG;IAEH,oBAAoB,CAAC,QAAQ,KAAA,EAAE,SAAS,KAAA,EAAE,EAAE,KAAA;IAmE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,kBAAkB,CAAC,kBAAkB,KAAA,EAAE,mBAAmB,KAAA,EAAE,QAAQ,KAAA,EAAE,MAAM,KAAA;CAwB7E"}

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

@@ -0,0 +1,305 @@
+// This file is derived from the Cesium math library under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+// Note: This class is still an experimental export, mainly used by other test cases
+// - It has not been fully adapted to math.gl conventions
+// - Documentation has not been ported
+// @ts-nocheck
+import { Vector3, Matrix4, assert } from '@math.gl/core';
+import CullingVolume from './culling-volume';
+import Plane from './plane';
+const scratchPlaneUpVector = new Vector3();
+const scratchPlaneRightVector = new Vector3();
+const scratchPlaneNearCenter = new Vector3();
+const scratchPlaneFarCenter = new Vector3();
+const scratchPlaneNormal = new Vector3();
+export default class PerspectiveOffCenterFrustum {
+    /**
+     * 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
+     * @constructor
+     *
+     * @param {Object} [options] An object with the following properties:
+     * @param {Number} [options.left] The left clipping plane distance.
+     * @param {Number} [options.right] The right clipping plane distance.
+     * @param {Number} [options.top] The top clipping plane distance.
+     * @param {Number} [options.bottom] The bottom clipping plane distance.
+     * @param {Number} [options.near=1.0] The near clipping plane distance.
+     * @param {Number} [options.far=500000000.0] The far clipping plane distance.
+     *
+     * @example
+     * const frustum = new PerspectiveOffCenterFrustum({
+     *     left : -1.0,
+     *     right : 1.0,
+     *     top : 1.0,
+     *     bottom : -1.0,
+     *     near : 1.0,
+     *     far : 100.0
+     * });
+     *
+     * @see PerspectiveFrustum
+     */
+    constructor(options = {}) {
+        this._cullingVolume = new CullingVolume([
+            new Plane(),
+            new Plane(),
+            new Plane(),
+            new Plane(),
+            new Plane(),
+            new Plane()
+        ]);
+        this._perspectiveMatrix = new Matrix4();
+        this._infinitePerspective = new Matrix4();
+        options = { near: 1.0, far: 500000000.0, ...options };
+        /**
+         * Defines the left clipping plane.
+         * @type {Number}
+         * @default undefined
+         */
+        this.left = options.left;
+        this._left = undefined;
+        /**
+         * Defines the right clipping plane.
+         * @type {Number}
+         * @default undefined
+         */
+        this.right = options.right;
+        this._right = undefined;
+        /**
+         * Defines the top clipping plane.
+         * @type {Number}
+         * @default undefined
+         */
+        this.top = options.top;
+        this._top = undefined;
+        /**
+         * Defines the bottom clipping plane.
+         * @type {Number}
+         * @default undefined
+         */
+        this.bottom = options.bottom;
+        this._bottom = undefined;
+        /**
+         * The distance of the near plane.
+         * @type {Number}
+         * @default 1.0
+         */
+        this.near = options.near;
+        this._near = this.near;
+        /**
+         * The distance of the far plane.
+         * @type {Number}
+         * @default 500000000.0
+         */
+        this.far = options.far;
+        this._far = this.far;
+    }
+    /**
+     * Returns a duplicate of a PerspectiveOffCenterFrustum instance.
+     * @returns {PerspectiveOffCenterFrustum} A new PerspectiveFrustum instance.
+     * */
+    clone() {
+        return new PerspectiveOffCenterFrustum({
+            right: this.right,
+            left: this.left,
+            top: this.top,
+            bottom: this.bottom,
+            near: this.near,
+            far: this.far
+        });
+    }
+    /**
+     * Compares the provided PerspectiveOffCenterFrustum componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     *
+     * @param {PerspectiveOffCenterFrustum} [other] The right hand side PerspectiveOffCenterFrustum.
+     * @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() {
+        update(this);
+        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() {
+        update(this);
+        return this._infinitePerspective;
+    }
+    /**
+     * Creates a culling volume for this frustum.
+     *
+     * @param {Vector3} position The eye position.
+     * @param {Vector3} direction The view direction.
+     * @param {Vector3} up The up direction.
+     * @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) {
+        assert(position, 'position is required.');
+        assert(direction, 'direction is required.');
+        assert(up, 'up is required.');
+        const planes = this._cullingVolume.planes;
+        up = scratchPlaneUpVector.copy(up).normalize();
+        const right = scratchPlaneRightVector.copy(direction).cross(up).normalize();
+        const nearCenter = scratchPlaneNearCenter
+            .copy(direction)
+            .multiplyByScalar(this.near)
+            .add(position);
+        const farCenter = scratchPlaneFarCenter
+            .copy(direction)
+            .multiplyByScalar(this.far)
+            .add(position);
+        let normal = scratchPlaneNormal;
+        // Left plane computation
+        normal.copy(right).multiplyByScalar(this.left).add(nearCenter).subtract(position).cross(up);
+        planes[0].fromPointNormal(position, normal);
+        // Right plane computation
+        normal
+            .copy(right)
+            .multiplyByScalar(this.right)
+            .add(nearCenter)
+            .subtract(position)
+            .cross(up)
+            .negate();
+        planes[1].fromPointNormal(position, normal);
+        // Bottom plane computation
+        normal
+            .copy(up)
+            .multiplyByScalar(this.bottom)
+            .add(nearCenter)
+            .subtract(position)
+            .cross(right)
+            .negate();
+        planes[2].fromPointNormal(position, normal);
+        // Top plane computation
+        normal.copy(up).multiplyByScalar(this.top).add(nearCenter).subtract(position).cross(right);
+        planes[3].fromPointNormal(position, normal);
+        normal = new Vector3().copy(direction);
+        // Near plane computation
+        planes[4].fromPointNormal(nearCenter, normal);
+        // Far plane computation
+        normal.negate();
+        planes[5].fromPointNormal(farCenter, normal);
+        return this._cullingVolume;
+    }
+    /**
+     * Returns the pixel's width and height in meters.
+     *
+     * @param {Number} drawingBufferWidth The width of the drawing buffer.
+     * @param {Number} drawingBufferHeight The height of the drawing buffer.
+     * @param {Number} distance The distance to the near plane in meters.
+     * @param {Vector2} result The object onto which to store the result.
+     * @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) {
+        update(this);
+        assert(Number.isFinite(drawingBufferWidth) && Number.isFinite(drawingBufferHeight));
+        // 'Both drawingBufferWidth and drawingBufferHeight are required.'
+        assert(drawingBufferWidth > 0);
+        // 'drawingBufferWidth must be greater than zero.'
+        assert(drawingBufferHeight > 0);
+        // 'drawingBufferHeight must be greater than zero.'
+        assert(distance > 0);
+        // 'distance is required.');
+        assert(result);
+        // 'A result object is required.');
+        const inverseNear = 1.0 / this.near;
+        let tanTheta = this.top * inverseNear;
+        const pixelHeight = (2.0 * distance * tanTheta) / drawingBufferHeight;
+        tanTheta = this.right * inverseNear;
+        const pixelWidth = (2.0 * distance * tanTheta) / drawingBufferWidth;
+        result.x = pixelWidth;
+        result.y = pixelHeight;
+        return result;
+    }
+}
+// eslint-disable-next-line complexity, max-statements
+function update(frustum) {
+    assert(Number.isFinite(frustum.right) &&
+        Number.isFinite(frustum.left) &&
+        Number.isFinite(frustum.top) &&
+        Number.isFinite(frustum.bottom) &&
+        Number.isFinite(frustum.near) &&
+        Number.isFinite(frustum.far));
+    // throw new DeveloperError('right, left, top, bottom, near, or far parameters are not set.');
+    const { top, bottom, right, left, near, far } = frustum;
+    if (top !== frustum._top ||
+        bottom !== frustum._bottom ||
+        left !== frustum._left ||
+        right !== frustum._right ||
+        near !== frustum._near ||
+        far !== frustum._far) {
+        assert(frustum.near > 0 && frustum.near < frustum.far, 'near must be greater than zero and less than far.');
+        frustum._left = left;
+        frustum._right = right;
+        frustum._top = top;
+        frustum._bottom = bottom;
+        frustum._near = near;
+        frustum._far = far;
+        frustum._perspectiveMatrix = new Matrix4().frustum({
+            left,
+            right,
+            bottom,
+            top,
+            near,
+            far
+        });
+        frustum._infinitePerspective = new Matrix4().frustum({
+            left,
+            right,
+            bottom,
+            top,
+            near,
+            far: Infinity
+        });
+    }
+}

package/dist/lib/plane.d.ts

@@ -0,0 +1,26 @@
+import { Vector3 } from '@math.gl/core';
+export default class Plane {
+    readonly normal: Vector3;
+    distance: number;
+    constructor(normal?: readonly number[], distance?: number);
+    /** Creates a plane from a normal and a distance from the origin. */
+    fromNormalDistance(normal: readonly number[], distance: number): this;
+    /** Creates a plane from a normal and a point on the plane. */
+    fromPointNormal(point: readonly number[], normal: readonly number[]): this;
+    /** Creates a plane from the general equation */
+    fromCoefficients(a: number, b: number, c: number, d: number): this;
+    /** Duplicates a Plane instance. */
+    clone(): Plane;
+    /** Compares the provided Planes by normal and distance */
+    equals(right: Plane): boolean;
+    /** 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: readonly number[]): number;
+    /** Transforms the plane by the given transformation matrix. */
+    transform(matrix4: readonly number[]): this;
+    /** Projects a point onto the plane. */
+    projectPointOntoPlane(point: readonly number[], result: Vector3): Vector3;
+    projectPointOntoPlane(point: readonly number[], result?: readonly number[]): readonly number[];
+}
+//# sourceMappingURL=plane.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plane.d.ts","sourceRoot":"","sources":["../../src/lib/plane.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,OAAO,EAAiB,MAAM,eAAe,CAAC;AAMtD,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;gBAEL,MAAM,GAAE,SAAS,MAAM,EAAc,EAAE,QAAQ,GAAE,MAAU;IAMvE,oEAAoE;IACpE,kBAAkB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAOrE,8DAA8D;IAC9D,eAAe,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAQ1E,gDAAgD;IAChD,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAOlE,mCAAmC;IACnC,KAAK,IAAI,KAAK;IAId,0DAA0D;IAC1D,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAI7B;;OAEG;IACH,gBAAgB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM;IAIlD,+DAA+D;IAC/D,SAAS,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAM3C,uCAAuC;IACvC,qBAAqB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO;IACzE,qBAAqB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE;CAU/F"}