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

package/dist/lib/culling-volume.js

@@ -1,121 +0,0 @@
-// This file is derived from the Cesium math library under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-/* eslint-disable */
-import { Vector3, assert } from '@math.gl/core';
-import { INTERSECTION } from '../constants';
-import Plane from './plane';
-// X, Y, Z Unit vectors
-const faces = [new Vector3([1, 0, 0]), new Vector3([0, 1, 0]), new Vector3([0, 0, 1])];
-const scratchPlaneCenter = new Vector3();
-const scratchPlaneNormal = new Vector3();
-const scratchPlane = new Plane(new Vector3(1.0, 0.0, 0.0), 0.0);
-/** A culling volume defined by planes. */
-export default class CullingVolume {
-    /**
-     * 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;
-        const radius = boundingSphere.radius;
-        let planeIndex = 0;
-        for (const faceNormal of faces) {
-            let plane0 = this.planes[planeIndex];
-            let plane1 = this.planes[planeIndex + 1];
-            if (!plane0) {
-                plane0 = this.planes[planeIndex] = new Plane();
-            }
-            if (!plane1) {
-                plane1 = this.planes[planeIndex + 1] = new Plane();
-            }
-            const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center);
-            const plane0Distance = -faceNormal.dot(plane0Center);
-            plane0.fromPointNormal(plane0Center, faceNormal);
-            const plane1Center = scratchPlaneCenter.copy(faceNormal).scale(radius).add(center);
-            const negatedFaceNormal = scratchPlaneNormal.copy(faceNormal).negate();
-            const plane1Distance = -negatedFaceNormal.dot(plane1Center);
-            plane1.fromPointNormal(plane1Center, negatedFaceNormal);
-            planeIndex += 2;
-        }
-        return this;
-    }
-    /** Determines whether a bounding volume intersects the culling volume. */
-    computeVisibility(boundingVolume) {
-        // const planes = this.planes;
-        let intersect = INTERSECTION.INSIDE;
-        for (const plane of this.planes) {
-            const result = boundingVolume.intersectPlane(plane);
-            switch (result) {
-                case INTERSECTION.OUTSIDE:
-                    // We are done
-                    return INTERSECTION.OUTSIDE;
-                case INTERSECTION.INTERSECTING:
-                    // If no other intersection is outside, return INTERSECTING
-                    intersect = INTERSECTION.INTERSECTING;
-                    break;
-                default:
-            }
-        }
-        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) {
-        assert(Number.isFinite(parentPlaneMask), 'parentPlaneMask is required.');
-        if (parentPlaneMask === CullingVolume.MASK_OUTSIDE ||
-            parentPlaneMask === CullingVolume.MASK_INSIDE) {
-            // parent is completely outside or completely inside, so this child is as well.
-            return parentPlaneMask;
-        }
-        // Start with MASK_INSIDE (all zeros) so that after the loop, the return value can be compared with MASK_INSIDE.
-        // (Because if there are fewer than 31 planes, the upper bits wont be changed.)
-        let mask = CullingVolume.MASK_INSIDE;
-        const planes = this.planes;
-        for (let k = 0; k < this.planes.length; ++k) {
-            // For k greater than 31 (since 31 is the maximum number of INSIDE/INTERSECTING bits we can store), skip the optimization.
-            const flag = k < 31 ? 1 << k : 0;
-            if (k < 31 && (parentPlaneMask & flag) === 0) {
-                // boundingVolume is known to be INSIDE this plane.
-                continue;
-            }
-            const plane = planes[k];
-            const result = boundingVolume.intersectPlane(plane);
-            if (result === INTERSECTION.OUTSIDE) {
-                return CullingVolume.MASK_OUTSIDE;
-            }
-            else if (result === INTERSECTION.INTERSECTING) {
-                mask |= flag;
-            }
-        }
-        return mask;
-    }
-}
-/**
- * For plane masks (as used in {@link CullingVolume#computeVisibilityWithPlaneMask}), this special value
- * represents the case where the object bounding volume is entirely outside the culling volume.
- */
-CullingVolume.MASK_OUTSIDE = 0xffffffff;
-/**
- * For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value
- * represents the case where the object bounding volume is entirely inside the culling volume.
- */
-CullingVolume.MASK_INSIDE = 0x00000000;
-/**
- * For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value
- * represents the case where the object bounding volume (may) intersect all planes of the culling volume.
- */
-CullingVolume.MASK_INDETERMINATE = 0x7fffffff;

package/dist/lib/perspective-frustum.js

@@ -1,190 +0,0 @@
-// This file is derived from the Cesium math library under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-// 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
-import { assert, Vector2 } 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
- *
- * @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();
-        const { fov, aspectRatio, near = 1.0, far = 500000000.0, xOffset = 0.0, yOffset = 0.0 } = options;
-        this.fov = fov;
-        this.aspectRatio = aspectRatio;
-        this.near = near;
-        this.far = far;
-        this.xOffset = xOffset;
-        this.yOffset = 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;
-        }
-        this._update();
-        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(
-    /** A Vector3 defines the eye position. */
-    position, 
-    /** A Vector3 defines the view direction. */
-    direction, 
-    /** A Vector3 defines the up 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(
-    /** The width of the drawing buffer. */
-    drawingBufferWidth, 
-    /** The height of the drawing buffer. */
-    drawingBufferHeight, 
-    /** The distance to the near plane in meters. */
-    distance, 
-    /** The object onto which to store the result. */
-    result) {
-        this._update();
-        return this._offCenterFrustum.getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result || new Vector2());
-    }
-    // eslint-disable-next-line complexity, max-statements
-    _update() {
-        assert(Number.isFinite(this.fov) &&
-            Number.isFinite(this.aspectRatio) &&
-            Number.isFinite(this.near) &&
-            Number.isFinite(this.far));
-        // 'fov, aspectRatio, near, or far parameters are not set.'
-        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) {
-            assert(this.fov >= 0 && this.fov < Math.PI);
-            // throw new DeveloperError('fov must be in the range [0, PI).');
-            assert(this.aspectRatio > 0);
-            // throw new DeveloperError('aspectRatio must be positive.');
-            assert(this.near >= 0 && this.near < this.far);
-            // throw new DeveloperError('near must be greater than zero and less than 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.0;
-            this._near = this.near;
-            this._far = this.far;
-            this._sseDenominator = 2.0 * Math.tan(0.5 * this._fovy);
-            this._xOffset = this.xOffset;
-            this._yOffset = this.yOffset;
-            f.top = this.near * Math.tan(0.5 * this._fovy);
-            f.bottom = -f.top;
-            f.right = this.aspectRatio * f.top;
-            f.left = -f.right;
-            f.near = this.near;
-            f.far = this.far;
-            f.right += this.xOffset;
-            f.left += this.xOffset;
-            f.top += this.yOffset;
-            f.bottom += this.yOffset;
-        }
-    }
-}

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

@@ -1,270 +0,0 @@
-// This file is derived from the Cesium math library under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-// 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
-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
-     *
-     * @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();
-        const { near = 1.0, far = 500000000.0 } = options;
-        this.left = options.left;
-        this._left = undefined;
-        this.right = options.right;
-        this._right = undefined;
-        this.top = options.top;
-        this._top = undefined;
-        this.bottom = options.bottom;
-        this._bottom = undefined;
-        this.near = near;
-        this._near = near;
-        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,
-            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.
-     *
-     * @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(
-    /** A Vector3 defines the eye position. */
-    position, 
-    /** A Vector3 defines the view direction. */
-    direction, 
-    /** A Vector3 defines the up 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.
-     *
-     * @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(
-    /** The width of the drawing buffer. */
-    drawingBufferWidth, 
-    /** The height of the drawing buffer. */
-    drawingBufferHeight, 
-    /** The distance to the near plane in meters. */
-    distance, 
-    /** The object onto which to store the result. */
-    result) {
-        this._update();
-        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
-    _update() {
-        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));
-        // throw new DeveloperError('right, left, top, bottom, near, or far parameters are not set.');
-        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) {
-            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 Matrix4().frustum({
-                left,
-                right,
-                bottom,
-                top,
-                near,
-                far
-            });
-            this._infinitePerspective = new Matrix4().frustum({
-                left,
-                right,
-                bottom,
-                top,
-                near,
-                far: Infinity
-            });
-        }
-    }
-}

package/dist/lib/plane.js

@@ -1,63 +0,0 @@
-// This file is derived from the Cesium math library under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-/* eslint-disable */
-import { Vector3, equals, assert } from '@math.gl/core';
-const scratchPosition = new Vector3();
-const scratchNormal = new Vector3();
-// A plane in Hessian Normal Form
-export default class Plane {
-    constructor(normal = [0, 0, 1], distance = 0) {
-        this.normal = new Vector3();
-        this.distance = -0;
-        this.fromNormalDistance(normal, distance);
-    }
-    /** Creates a plane from a normal and a distance from the origin. */
-    fromNormalDistance(normal, distance) {
-        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();
-        const distance = -this.normal.dot(point);
-        this.distance = distance;
-        return this;
-    }
-    /** Creates a plane from the general equation */
-    fromCoefficients(a, b, c, d) {
-        this.normal.set(a, b, c);
-        assert(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 equals(this.distance, right.distance) && 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 = scratchNormal.copy(this.normal).transformAsVector(matrix4).normalize();
-        const point = this.normal.scale(-this.distance).transform(matrix4);
-        return this.fromPointNormal(point, normal);
-    }
-    projectPointOntoPlane(point, result = [0, 0, 0]) {
-        point = scratchPosition.from(point);
-        // projectedPoint = point - (normal.point + scale) * normal
-        const pointDistance = this.getPointDistance(point);
-        const scaledNormal = scratchNormal.copy(this.normal).scale(pointDistance);
-        return point.subtract(scaledNormal).to(result);
-    }
-}