@itwin/core-common 3.6.0-dev.51 → 3.6.0-dev.53

package/lib/cjs/geometry/FrustumPlanes.d.ts

@@ -1,82 +1,82 @@
-/** @packageDocumentation
- * @module Geometry
- */
-import { ClipPlane, Point3d, Vector3d } from "@itwin/core-geometry";
-import { Frustum } from "../Frustum";
-import { BoundingSphere } from "./BoundingSphere";
-/** Represents a the planes of a [[Frustum]] for testing containment and intersection.
- * A valid frustum produces six planes. A degenerate frustum produces zero planes.
- * @public
- * @extensions
- */
-export declare class FrustumPlanes {
-    private _planes;
-    private constructor();
-    /** Compute the six planes of the specified frustum.
-     * If the frustum is degenerate - that is, its points do not represent a truncated pyramid - then the returned `FrustumPlanes` will contain zero planes.
-     * @see [[isValid]] to test this condition.
-     */
-    static fromFrustum(frustum: Frustum): FrustumPlanes;
-    /** Create an empty set of frustum planes. [[isValid]] will be `true`. This can be useful when you want to create a `FrustumPlanes` object and initialize it later via [[init]] -
-     * for example, if you intend to use the same object repeatedly with different [[Frustum]]s.
-     */
-    static createEmpty(): FrustumPlanes;
-    /** Returns true if [[planes]] consists of six planes. This may return `false` if a degenerate [[Frustum]] was supplied to [[fromFrustum]], or if this object was created
-     * via [[createEmpty]] - in either case, [[planes]] will be an empty array.
-     */
-    get isValid(): boolean;
-    /** Obtain the list of planes defining the frustum. If [[isValid]] is `true`, it will have a length of six, with the planes ordered as
-     * right, left, top, bottom, back, front. Otherwise, it will be empty.
-     */
-    get planes(): ClipPlane[];
-    /** Recompute the planes from the specified frustum.
-     * @returns true upon success, or false if the input frustum was degenerate, in which case [[isValid]] will be `false`.
-     */
-    init(frustum: Frustum): boolean;
-    /** Compute to what degree a [[Frustum]] is contained with these frustum planes.
-     * @param box The frustum to test for containment.
-     * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.
-     * @returns the degree to which `box` is contained within the clipping planes.
-     */
-    computeFrustumContainment(box: Frustum, sphere?: BoundingSphere): FrustumPlanes.Containment;
-    /** Determines whether a [[Frustum]] intersects with or is fully contained within these frustum planes.
-     * @param box The frustum to test for containment.
-     * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.
-     * @returns true if `box` is not entirely outside of the clipping planes.
-     */
-    intersectsFrustum(box: Frustum, sphere?: BoundingSphere): boolean;
-    /** Determines whether a point is contained within these frustum planes.
-     * @param point The point to test for containment.
-     * @param tolerance The maximum distance from the interior of the frustum planes that will still be considered "contained".
-     * @returns true if `point` is no further than `tolerance` meters outside of the clipping planes.
-     */
-    containsPoint(point: Point3d, tolerance?: number): boolean;
-    /** Compute the degree to which a set of points is contained within these frustum planes.
-     * @param points The points to test for containment.
-     * @param sphere An optional spherical bounding volume fully containing all of the points. If supplied, this can reduce the amount of computation required.
-     * @param tolerance The maximum distance from the interior of the frustum planes a point must be to be considered "contained".
-     * @returns the degree to which all of the points are contained within the clipping planes.
-     */
-    computeContainment(points: Point3d[], sphere?: BoundingSphere, tolerance?: number): FrustumPlanes.Containment;
-    /** Computes whether a ray intersects these clipping planes.
-     * @param origin The origin of the ray.
-     * @param direction The direction of the ray.
-     * @returns true if the ray extending from `origin` in the specified `direction` intersects at least one of the clipping planes.
-     */
-    intersectsRay(origin: Point3d, direction: Vector3d): boolean;
-}
-/** @public @extensions */
-export declare namespace FrustumPlanes {
-    /** Describes the degree to which an object is contained within the planes of a [[Frustum]].
-     * @see [[FrustumPlanes.computeContainment]], for example.
-     */
-    enum Containment {
-        /** The object is entirely outside of the frustum, intersecting none of its planes. */
-        Outside = 0,
-        /** The object intersects at least one of the frustum planes. placing it partially inside of the frustum. */
-        Partial = 1,
-        /** The object is entirely inside of the frustum, intersecting none of its planes. */
-        Inside = 2
-    }
-}
+/** @packageDocumentation
+ * @module Geometry
+ */
+import { ClipPlane, Point3d, Vector3d } from "@itwin/core-geometry";
+import { Frustum } from "../Frustum";
+import { BoundingSphere } from "./BoundingSphere";
+/** Represents a the planes of a [[Frustum]] for testing containment and intersection.
+ * A valid frustum produces six planes. A degenerate frustum produces zero planes.
+ * @public
+ * @extensions
+ */
+export declare class FrustumPlanes {
+    private _planes;
+    private constructor();
+    /** Compute the six planes of the specified frustum.
+     * If the frustum is degenerate - that is, its points do not represent a truncated pyramid - then the returned `FrustumPlanes` will contain zero planes.
+     * @see [[isValid]] to test this condition.
+     */
+    static fromFrustum(frustum: Frustum): FrustumPlanes;
+    /** Create an empty set of frustum planes. [[isValid]] will be `true`. This can be useful when you want to create a `FrustumPlanes` object and initialize it later via [[init]] -
+     * for example, if you intend to use the same object repeatedly with different [[Frustum]]s.
+     */
+    static createEmpty(): FrustumPlanes;
+    /** Returns true if [[planes]] consists of six planes. This may return `false` if a degenerate [[Frustum]] was supplied to [[fromFrustum]], or if this object was created
+     * via [[createEmpty]] - in either case, [[planes]] will be an empty array.
+     */
+    get isValid(): boolean;
+    /** Obtain the list of planes defining the frustum. If [[isValid]] is `true`, it will have a length of six, with the planes ordered as
+     * right, left, top, bottom, back, front. Otherwise, it will be empty.
+     */
+    get planes(): ClipPlane[];
+    /** Recompute the planes from the specified frustum.
+     * @returns true upon success, or false if the input frustum was degenerate, in which case [[isValid]] will be `false`.
+     */
+    init(frustum: Frustum): boolean;
+    /** Compute to what degree a [[Frustum]] is contained with these frustum planes.
+     * @param box The frustum to test for containment.
+     * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.
+     * @returns the degree to which `box` is contained within the clipping planes.
+     */
+    computeFrustumContainment(box: Frustum, sphere?: BoundingSphere): FrustumPlanes.Containment;
+    /** Determines whether a [[Frustum]] intersects with or is fully contained within these frustum planes.
+     * @param box The frustum to test for containment.
+     * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.
+     * @returns true if `box` is not entirely outside of the clipping planes.
+     */
+    intersectsFrustum(box: Frustum, sphere?: BoundingSphere): boolean;
+    /** Determines whether a point is contained within these frustum planes.
+     * @param point The point to test for containment.
+     * @param tolerance The maximum distance from the interior of the frustum planes that will still be considered "contained".
+     * @returns true if `point` is no further than `tolerance` meters outside of the clipping planes.
+     */
+    containsPoint(point: Point3d, tolerance?: number): boolean;
+    /** Compute the degree to which a set of points is contained within these frustum planes.
+     * @param points The points to test for containment.
+     * @param sphere An optional spherical bounding volume fully containing all of the points. If supplied, this can reduce the amount of computation required.
+     * @param tolerance The maximum distance from the interior of the frustum planes a point must be to be considered "contained".
+     * @returns the degree to which all of the points are contained within the clipping planes.
+     */
+    computeContainment(points: Point3d[], sphere?: BoundingSphere, tolerance?: number): FrustumPlanes.Containment;
+    /** Computes whether a ray intersects these clipping planes.
+     * @param origin The origin of the ray.
+     * @param direction The direction of the ray.
+     * @returns true if the ray extending from `origin` in the specified `direction` intersects at least one of the clipping planes.
+     */
+    intersectsRay(origin: Point3d, direction: Vector3d): boolean;
+}
+/** @public @extensions */
+export declare namespace FrustumPlanes {
+    /** Describes the degree to which an object is contained within the planes of a [[Frustum]].
+     * @see [[FrustumPlanes.computeContainment]], for example.
+     */
+    enum Containment {
+        /** The object is entirely outside of the frustum, intersecting none of its planes. */
+        Outside = 0,
+        /** The object intersects at least one of the frustum planes. placing it partially inside of the frustum. */
+        Partial = 1,
+        /** The object is entirely inside of the frustum, intersecting none of its planes. */
+        Inside = 2
+    }
+}
 //# sourceMappingURL=FrustumPlanes.d.ts.map

package/lib/cjs/geometry/FrustumPlanes.js

@@ -1,194 +1,194 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Geometry
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FrustumPlanes = void 0;
-const core_bentley_1 = require("@itwin/core-bentley");
-const core_geometry_1 = require("@itwin/core-geometry");
-const planePointIndices = [
-    [1, 3, 5],
-    [0, 4, 2],
-    [2, 6, 3],
-    [0, 1, 4],
-    [0, 2, 1],
-    [4, 5, 6], // front
-];
-function computeFrustumPlanes(frustum) {
-    const planes = [];
-    const points = frustum.points;
-    const expandPlaneDistance = 1e-6;
-    for (const indices of planePointIndices) {
-        const i0 = indices[0], i1 = indices[1], i2 = indices[2];
-        const normal = core_geometry_1.Vector3d.createCrossProductToPoints(points[i2], points[i1], points[i0]);
-        normal.normalizeInPlace();
-        const plane = core_geometry_1.ClipPlane.createNormalAndDistance(normal, normal.dotProduct(points[i0]) - expandPlaneDistance);
-        if (!plane)
-            return [];
-        planes.push(plane);
-    }
-    (0, core_bentley_1.assert)(planes.length === 6);
-    return planes;
-}
-// Scratch variable used by FrustumPlanes.computeContainment.
-const planesContainingSphere = [false, false, false, false, false, false];
-/** Represents a the planes of a [[Frustum]] for testing containment and intersection.
- * A valid frustum produces six planes. A degenerate frustum produces zero planes.
- * @public
- * @extensions
- */
-class FrustumPlanes {
-    constructor(planes) {
-        this._planes = planes;
-    }
-    /** Compute the six planes of the specified frustum.
-     * If the frustum is degenerate - that is, its points do not represent a truncated pyramid - then the returned `FrustumPlanes` will contain zero planes.
-     * @see [[isValid]] to test this condition.
-     */
-    static fromFrustum(frustum) {
-        const planes = computeFrustumPlanes(frustum);
-        return new FrustumPlanes(planes);
-    }
-    /** Create an empty set of frustum planes. [[isValid]] will be `true`. This can be useful when you want to create a `FrustumPlanes` object and initialize it later via [[init]] -
-     * for example, if you intend to use the same object repeatedly with different [[Frustum]]s.
-     */
-    static createEmpty() {
-        return new FrustumPlanes([]);
-    }
-    /** Returns true if [[planes]] consists of six planes. This may return `false` if a degenerate [[Frustum]] was supplied to [[fromFrustum]], or if this object was created
-     * via [[createEmpty]] - in either case, [[planes]] will be an empty array.
-     */
-    get isValid() {
-        return this._planes.length === 6;
-    }
-    /** Obtain the list of planes defining the frustum. If [[isValid]] is `true`, it will have a length of six, with the planes ordered as
-     * right, left, top, bottom, back, front. Otherwise, it will be empty.
-     */
-    get planes() {
-        return this._planes;
-    }
-    /** Recompute the planes from the specified frustum.
-     * @returns true upon success, or false if the input frustum was degenerate, in which case [[isValid]] will be `false`.
-     */
-    init(frustum) {
-        this._planes = computeFrustumPlanes(frustum);
-        return this.isValid;
-    }
-    /** Compute to what degree a [[Frustum]] is contained with these frustum planes.
-     * @param box The frustum to test for containment.
-     * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.
-     * @returns the degree to which `box` is contained within the clipping planes.
-     */
-    computeFrustumContainment(box, sphere) {
-        return this.computeContainment(box.points, sphere);
-    }
-    /** Determines whether a [[Frustum]] intersects with or is fully contained within these frustum planes.
-     * @param box The frustum to test for containment.
-     * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.
-     * @returns true if `box` is not entirely outside of the clipping planes.
-     */
-    intersectsFrustum(box, sphere) {
-        return FrustumPlanes.Containment.Outside !== this.computeFrustumContainment(box, sphere);
-    }
-    /** Determines whether a point is contained within these frustum planes.
-     * @param point The point to test for containment.
-     * @param tolerance The maximum distance from the interior of the frustum planes that will still be considered "contained".
-     * @returns true if `point` is no further than `tolerance` meters outside of the clipping planes.
-     */
-    containsPoint(point, tolerance = 1.0e-8) {
-        return FrustumPlanes.Containment.Outside !== this.computeContainment([point], undefined, tolerance);
-    }
-    /** Compute the degree to which a set of points is contained within these frustum planes.
-     * @param points The points to test for containment.
-     * @param sphere An optional spherical bounding volume fully containing all of the points. If supplied, this can reduce the amount of computation required.
-     * @param tolerance The maximum distance from the interior of the frustum planes a point must be to be considered "contained".
-     * @returns the degree to which all of the points are contained within the clipping planes.
-     */
-    computeContainment(points, sphere, tolerance = 1.0e-8) {
-        (0, core_bentley_1.assert)(this.isValid);
-        if (undefined === this._planes)
-            return FrustumPlanes.Containment.Outside;
-        // Do the cheap test against bounding sphere first.
-        if (sphere) {
-            for (let i = 0; i < this._planes.length; i++) {
-                const plane = this._planes[i];
-                const centerDistance = plane.altitude(sphere.center);
-                const tolerancePlusRadius = tolerance + sphere.radius;
-                if (centerDistance < -tolerancePlusRadius)
-                    return FrustumPlanes.Containment.Outside;
-                planesContainingSphere[i] = centerDistance > tolerancePlusRadius;
-            }
-        }
-        // Test against points.
-        let allInside = true;
-        for (let i = 0; i < this._planes.length; i++) {
-            if (sphere && planesContainingSphere[i])
-                continue;
-            const plane = this._planes[i];
-            let nOutside = 0;
-            for (const point of points) {
-                if (plane.altitude(point) + tolerance < 0) {
-                    ++nOutside;
-                    allInside = false;
-                }
-            }
-            if (nOutside === points.length)
-                return FrustumPlanes.Containment.Outside;
-        }
-        return allInside ? FrustumPlanes.Containment.Inside : FrustumPlanes.Containment.Partial;
-    }
-    /** Computes whether a ray intersects these clipping planes.
-     * @param origin The origin of the ray.
-     * @param direction The direction of the ray.
-     * @returns true if the ray extending from `origin` in the specified `direction` intersects at least one of the clipping planes.
-     */
-    intersectsRay(origin, direction) {
-        (0, core_bentley_1.assert)(this.isValid);
-        if (undefined === this._planes) {
-            return false;
-        }
-        let tFar = 1e37;
-        let tNear = -tFar;
-        for (const plane of this._planes) {
-            const vD = plane.velocity(direction);
-            const vN = plane.altitude(origin);
-            if (0.0 === vD) {
-                // ray is parallel... no need to continue testing if outside halfspace.
-                if (vN < 0.0) {
-                    return false;
-                }
-            }
-            else {
-                const rayDistance = -vN / vD;
-                if (vD < 0.0) {
-                    tFar = Math.min(rayDistance, tFar);
-                }
-                else {
-                    tNear = Math.max(rayDistance, tNear);
-                }
-            }
-        }
-        return tNear <= tFar;
-    }
-}
-exports.FrustumPlanes = FrustumPlanes;
-/** @public @extensions */
-(function (FrustumPlanes) {
-    /** Describes the degree to which an object is contained within the planes of a [[Frustum]].
-     * @see [[FrustumPlanes.computeContainment]], for example.
-     */
-    let Containment;
-    (function (Containment) {
-        /** The object is entirely outside of the frustum, intersecting none of its planes. */
-        Containment[Containment["Outside"] = 0] = "Outside";
-        /** The object intersects at least one of the frustum planes. placing it partially inside of the frustum. */
-        Containment[Containment["Partial"] = 1] = "Partial";
-        /** The object is entirely inside of the frustum, intersecting none of its planes. */
-        Containment[Containment["Inside"] = 2] = "Inside";
-    })(Containment = FrustumPlanes.Containment || (FrustumPlanes.Containment = {}));
-})(FrustumPlanes = exports.FrustumPlanes || (exports.FrustumPlanes = {}));
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Geometry
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrustumPlanes = void 0;
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_geometry_1 = require("@itwin/core-geometry");
+const planePointIndices = [
+    [1, 3, 5],
+    [0, 4, 2],
+    [2, 6, 3],
+    [0, 1, 4],
+    [0, 2, 1],
+    [4, 5, 6], // front
+];
+function computeFrustumPlanes(frustum) {
+    const planes = [];
+    const points = frustum.points;
+    const expandPlaneDistance = 1e-6;
+    for (const indices of planePointIndices) {
+        const i0 = indices[0], i1 = indices[1], i2 = indices[2];
+        const normal = core_geometry_1.Vector3d.createCrossProductToPoints(points[i2], points[i1], points[i0]);
+        normal.normalizeInPlace();
+        const plane = core_geometry_1.ClipPlane.createNormalAndDistance(normal, normal.dotProduct(points[i0]) - expandPlaneDistance);
+        if (!plane)
+            return [];
+        planes.push(plane);
+    }
+    (0, core_bentley_1.assert)(planes.length === 6);
+    return planes;
+}
+// Scratch variable used by FrustumPlanes.computeContainment.
+const planesContainingSphere = [false, false, false, false, false, false];
+/** Represents a the planes of a [[Frustum]] for testing containment and intersection.
+ * A valid frustum produces six planes. A degenerate frustum produces zero planes.
+ * @public
+ * @extensions
+ */
+class FrustumPlanes {
+    constructor(planes) {
+        this._planes = planes;
+    }
+    /** Compute the six planes of the specified frustum.
+     * If the frustum is degenerate - that is, its points do not represent a truncated pyramid - then the returned `FrustumPlanes` will contain zero planes.
+     * @see [[isValid]] to test this condition.
+     */
+    static fromFrustum(frustum) {
+        const planes = computeFrustumPlanes(frustum);
+        return new FrustumPlanes(planes);
+    }
+    /** Create an empty set of frustum planes. [[isValid]] will be `true`. This can be useful when you want to create a `FrustumPlanes` object and initialize it later via [[init]] -
+     * for example, if you intend to use the same object repeatedly with different [[Frustum]]s.
+     */
+    static createEmpty() {
+        return new FrustumPlanes([]);
+    }
+    /** Returns true if [[planes]] consists of six planes. This may return `false` if a degenerate [[Frustum]] was supplied to [[fromFrustum]], or if this object was created
+     * via [[createEmpty]] - in either case, [[planes]] will be an empty array.
+     */
+    get isValid() {
+        return this._planes.length === 6;
+    }
+    /** Obtain the list of planes defining the frustum. If [[isValid]] is `true`, it will have a length of six, with the planes ordered as
+     * right, left, top, bottom, back, front. Otherwise, it will be empty.
+     */
+    get planes() {
+        return this._planes;
+    }
+    /** Recompute the planes from the specified frustum.
+     * @returns true upon success, or false if the input frustum was degenerate, in which case [[isValid]] will be `false`.
+     */
+    init(frustum) {
+        this._planes = computeFrustumPlanes(frustum);
+        return this.isValid;
+    }
+    /** Compute to what degree a [[Frustum]] is contained with these frustum planes.
+     * @param box The frustum to test for containment.
+     * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.
+     * @returns the degree to which `box` is contained within the clipping planes.
+     */
+    computeFrustumContainment(box, sphere) {
+        return this.computeContainment(box.points, sphere);
+    }
+    /** Determines whether a [[Frustum]] intersects with or is fully contained within these frustum planes.
+     * @param box The frustum to test for containment.
+     * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.
+     * @returns true if `box` is not entirely outside of the clipping planes.
+     */
+    intersectsFrustum(box, sphere) {
+        return FrustumPlanes.Containment.Outside !== this.computeFrustumContainment(box, sphere);
+    }
+    /** Determines whether a point is contained within these frustum planes.
+     * @param point The point to test for containment.
+     * @param tolerance The maximum distance from the interior of the frustum planes that will still be considered "contained".
+     * @returns true if `point` is no further than `tolerance` meters outside of the clipping planes.
+     */
+    containsPoint(point, tolerance = 1.0e-8) {
+        return FrustumPlanes.Containment.Outside !== this.computeContainment([point], undefined, tolerance);
+    }
+    /** Compute the degree to which a set of points is contained within these frustum planes.
+     * @param points The points to test for containment.
+     * @param sphere An optional spherical bounding volume fully containing all of the points. If supplied, this can reduce the amount of computation required.
+     * @param tolerance The maximum distance from the interior of the frustum planes a point must be to be considered "contained".
+     * @returns the degree to which all of the points are contained within the clipping planes.
+     */
+    computeContainment(points, sphere, tolerance = 1.0e-8) {
+        (0, core_bentley_1.assert)(this.isValid);
+        if (undefined === this._planes)
+            return FrustumPlanes.Containment.Outside;
+        // Do the cheap test against bounding sphere first.
+        if (sphere) {
+            for (let i = 0; i < this._planes.length; i++) {
+                const plane = this._planes[i];
+                const centerDistance = plane.altitude(sphere.center);
+                const tolerancePlusRadius = tolerance + sphere.radius;
+                if (centerDistance < -tolerancePlusRadius)
+                    return FrustumPlanes.Containment.Outside;
+                planesContainingSphere[i] = centerDistance > tolerancePlusRadius;
+            }
+        }
+        // Test against points.
+        let allInside = true;
+        for (let i = 0; i < this._planes.length; i++) {
+            if (sphere && planesContainingSphere[i])
+                continue;
+            const plane = this._planes[i];
+            let nOutside = 0;
+            for (const point of points) {
+                if (plane.altitude(point) + tolerance < 0) {
+                    ++nOutside;
+                    allInside = false;
+                }
+            }
+            if (nOutside === points.length)
+                return FrustumPlanes.Containment.Outside;
+        }
+        return allInside ? FrustumPlanes.Containment.Inside : FrustumPlanes.Containment.Partial;
+    }
+    /** Computes whether a ray intersects these clipping planes.
+     * @param origin The origin of the ray.
+     * @param direction The direction of the ray.
+     * @returns true if the ray extending from `origin` in the specified `direction` intersects at least one of the clipping planes.
+     */
+    intersectsRay(origin, direction) {
+        (0, core_bentley_1.assert)(this.isValid);
+        if (undefined === this._planes) {
+            return false;
+        }
+        let tFar = 1e37;
+        let tNear = -tFar;
+        for (const plane of this._planes) {
+            const vD = plane.velocity(direction);
+            const vN = plane.altitude(origin);
+            if (0.0 === vD) {
+                // ray is parallel... no need to continue testing if outside halfspace.
+                if (vN < 0.0) {
+                    return false;
+                }
+            }
+            else {
+                const rayDistance = -vN / vD;
+                if (vD < 0.0) {
+                    tFar = Math.min(rayDistance, tFar);
+                }
+                else {
+                    tNear = Math.max(rayDistance, tNear);
+                }
+            }
+        }
+        return tNear <= tFar;
+    }
+}
+exports.FrustumPlanes = FrustumPlanes;
+/** @public @extensions */
+(function (FrustumPlanes) {
+    /** Describes the degree to which an object is contained within the planes of a [[Frustum]].
+     * @see [[FrustumPlanes.computeContainment]], for example.
+     */
+    let Containment;
+    (function (Containment) {
+        /** The object is entirely outside of the frustum, intersecting none of its planes. */
+        Containment[Containment["Outside"] = 0] = "Outside";
+        /** The object intersects at least one of the frustum planes. placing it partially inside of the frustum. */
+        Containment[Containment["Partial"] = 1] = "Partial";
+        /** The object is entirely inside of the frustum, intersecting none of its planes. */
+        Containment[Containment["Inside"] = 2] = "Inside";
+    })(Containment = FrustumPlanes.Containment || (FrustumPlanes.Containment = {}));
+})(FrustumPlanes = exports.FrustumPlanes || (exports.FrustumPlanes = {}));
 //# sourceMappingURL=FrustumPlanes.js.map

package/lib/cjs/geometry/FrustumPlanes.js.map

@@ -1 +1 @@
-{"version":3,"file":"FrustumPlanes.js","sourceRoot":"","sources":["../../../src/geometry/FrustumPlanes.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Geometry\r\n */\r\n\r\nimport { assert } from \"@itwin/core-bentley\";\r\nimport { ClipPlane, Point3d, Vector3d } from \"@itwin/core-geometry\";\r\nimport { Frustum } from \"../Frustum\";\r\nimport { BoundingSphere } from \"./BoundingSphere\";\r\n\r\nconst planePointIndices = [\r\n  [1, 3, 5],  // right\r\n  [0, 4, 2],  // left\r\n  [2, 6, 3],  // top\r\n  [0, 1, 4],  // bottom\r\n  [0, 2, 1],  // back\r\n  [4, 5, 6],  // front\r\n];\r\n\r\nfunction computeFrustumPlanes(frustum: Frustum): ClipPlane[] {\r\n  const planes = [];\r\n  const points = frustum.points;\r\n  const expandPlaneDistance = 1e-6;\r\n\r\n  for (const indices of planePointIndices) {\r\n    const i0 = indices[0], i1 = indices[1], i2 = indices[2];\r\n    const normal = Vector3d.createCrossProductToPoints(points[i2], points[i1], points[i0]);\r\n    normal.normalizeInPlace();\r\n\r\n    const plane = ClipPlane.createNormalAndDistance(normal, normal.dotProduct(points[i0]) - expandPlaneDistance);\r\n    if (!plane)\r\n      return [];\r\n\r\n    planes.push(plane);\r\n  }\r\n\r\n  assert(planes.length === 6);\r\n  return planes;\r\n}\r\n\r\n// Scratch variable used by FrustumPlanes.computeContainment.\r\nconst planesContainingSphere = [false, false, false, false, false, false];\r\n\r\n/** Represents a the planes of a [[Frustum]] for testing containment and intersection.\r\n * A valid frustum produces six planes. A degenerate frustum produces zero planes.\r\n * @public\r\n * @extensions\r\n */\r\nexport class FrustumPlanes {\r\n  private _planes: ClipPlane[];\r\n\r\n  private constructor(planes: ClipPlane[]) {\r\n    this._planes = planes;\r\n  }\r\n\r\n  /** Compute the six planes of the specified frustum.\r\n   * If the frustum is degenerate - that is, its points do not represent a truncated pyramid - then the returned `FrustumPlanes` will contain zero planes.\r\n   * @see [[isValid]] to test this condition.\r\n   */\r\n  public static fromFrustum(frustum: Frustum): FrustumPlanes {\r\n    const planes = computeFrustumPlanes(frustum);\r\n    return new FrustumPlanes(planes);\r\n  }\r\n\r\n  /** Create an empty set of frustum planes. [[isValid]] will be `true`. This can be useful when you want to create a `FrustumPlanes` object and initialize it later via [[init]] -\r\n   * for example, if you intend to use the same object repeatedly with different [[Frustum]]s.\r\n   */\r\n  public static createEmpty(): FrustumPlanes {\r\n    return new FrustumPlanes([]);\r\n  }\r\n\r\n  /** Returns true if [[planes]] consists of six planes. This may return `false` if a degenerate [[Frustum]] was supplied to [[fromFrustum]], or if this object was created\r\n   * via [[createEmpty]] - in either case, [[planes]] will be an empty array.\r\n   */\r\n  public get isValid(): boolean {\r\n    return this._planes.length === 6;\r\n  }\r\n\r\n  /** Obtain the list of planes defining the frustum. If [[isValid]] is `true`, it will have a length of six, with the planes ordered as\r\n   * right, left, top, bottom, back, front. Otherwise, it will be empty.\r\n   */\r\n  public get planes(): ClipPlane[] {\r\n    return this._planes;\r\n  }\r\n\r\n  /** Recompute the planes from the specified frustum.\r\n   * @returns true upon success, or false if the input frustum was degenerate, in which case [[isValid]] will be `false`.\r\n   */\r\n  public init(frustum: Frustum): boolean {\r\n    this._planes = computeFrustumPlanes(frustum);\r\n    return this.isValid;\r\n  }\r\n\r\n  /** Compute to what degree a [[Frustum]] is contained with these frustum planes.\r\n   * @param box The frustum to test for containment.\r\n   * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.\r\n   * @returns the degree to which `box` is contained within the clipping planes.\r\n   */\r\n  public computeFrustumContainment(box: Frustum, sphere?: BoundingSphere): FrustumPlanes.Containment {\r\n    return this.computeContainment(box.points, sphere);\r\n  }\r\n\r\n  /** Determines whether a [[Frustum]] intersects with or is fully contained within these frustum planes.\r\n   * @param box The frustum to test for containment.\r\n   * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.\r\n   * @returns true if `box` is not entirely outside of the clipping planes.\r\n   */\r\n  public intersectsFrustum(box: Frustum, sphere?: BoundingSphere): boolean {\r\n    return FrustumPlanes.Containment.Outside !== this.computeFrustumContainment(box, sphere);\r\n  }\r\n\r\n  /** Determines whether a point is contained within these frustum planes.\r\n   * @param point The point to test for containment.\r\n   * @param tolerance The maximum distance from the interior of the frustum planes that will still be considered \"contained\".\r\n   * @returns true if `point` is no further than `tolerance` meters outside of the clipping planes.\r\n   */\r\n  public containsPoint(point: Point3d, tolerance: number = 1.0e-8): boolean {\r\n    return FrustumPlanes.Containment.Outside !== this.computeContainment([point], undefined, tolerance);\r\n  }\r\n\r\n  /** Compute the degree to which a set of points is contained within these frustum planes.\r\n   * @param points The points to test for containment.\r\n   * @param sphere An optional spherical bounding volume fully containing all of the points. If supplied, this can reduce the amount of computation required.\r\n   * @param tolerance The maximum distance from the interior of the frustum planes a point must be to be considered \"contained\".\r\n   * @returns the degree to which all of the points are contained within the clipping planes.\r\n   */\r\n  public computeContainment(points: Point3d[], sphere?: BoundingSphere, tolerance: number = 1.0e-8): FrustumPlanes.Containment {\r\n    assert(this.isValid);\r\n    if (undefined === this._planes)\r\n      return FrustumPlanes.Containment.Outside;\r\n\r\n    // Do the cheap test against bounding sphere first.\r\n    if (sphere) {\r\n      for (let i = 0; i < this._planes.length; i++) {\r\n        const plane = this._planes[i];\r\n        const centerDistance = plane.altitude(sphere.center);\r\n        const tolerancePlusRadius = tolerance + sphere.radius;\r\n        if (centerDistance < -tolerancePlusRadius)\r\n          return FrustumPlanes.Containment.Outside;\r\n\r\n        planesContainingSphere[i] = centerDistance > tolerancePlusRadius;\r\n      }\r\n    }\r\n\r\n    // Test against points.\r\n    let allInside = true;\r\n    for (let i = 0; i < this._planes.length; i++) {\r\n      if (sphere && planesContainingSphere[i])\r\n        continue;\r\n\r\n      const plane = this._planes[i];\r\n      let nOutside = 0;\r\n      for (const point of points) {\r\n        if (plane.altitude(point) + tolerance < 0) {\r\n          ++nOutside;\r\n          allInside = false;\r\n        }\r\n      }\r\n\r\n      if (nOutside === points.length)\r\n        return FrustumPlanes.Containment.Outside;\r\n    }\r\n\r\n    return allInside ? FrustumPlanes.Containment.Inside : FrustumPlanes.Containment.Partial;\r\n  }\r\n\r\n  /** Computes whether a ray intersects these clipping planes.\r\n   * @param origin The origin of the ray.\r\n   * @param direction The direction of the ray.\r\n   * @returns true if the ray extending from `origin` in the specified `direction` intersects at least one of the clipping planes.\r\n   */\r\n  public intersectsRay(origin: Point3d, direction: Vector3d): boolean {\r\n    assert(this.isValid);\r\n    if (undefined === this._planes) {\r\n      return false;\r\n    }\r\n\r\n    let tFar = 1e37;\r\n    let tNear = -tFar;\r\n\r\n    for (const plane of this._planes) {\r\n      const vD = plane.velocity(direction);\r\n      const vN = plane.altitude(origin);\r\n      if (0.0 === vD) {\r\n        // ray is parallel... no need to continue testing if outside halfspace.\r\n        if (vN < 0.0) {\r\n          return false;\r\n        }\r\n      } else {\r\n        const rayDistance = -vN / vD;\r\n        if (vD < 0.0) {\r\n          tFar = Math.min(rayDistance, tFar);\r\n        } else {\r\n          tNear = Math.max(rayDistance, tNear);\r\n        }\r\n      }\r\n    }\r\n\r\n    return tNear <= tFar;\r\n  }\r\n}\r\n\r\n/** @public @extensions */\r\nexport namespace FrustumPlanes { // eslint-disable-line no-redeclare\r\n  /** Describes the degree to which an object is contained within the planes of a [[Frustum]].\r\n   * @see [[FrustumPlanes.computeContainment]], for example.\r\n   */\r\n  export enum Containment {\r\n    /** The object is entirely outside of the frustum, intersecting none of its planes. */\r\n    Outside = 0,\r\n    /** The object intersects at least one of the frustum planes. placing it partially inside of the frustum. */\r\n    Partial = 1,\r\n    /** The object is entirely inside of the frustum, intersecting none of its planes. */\r\n    Inside = 2,\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"FrustumPlanes.js","sourceRoot":"","sources":["../../../src/geometry/FrustumPlanes.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,sDAA6C;AAC7C,wDAAoE;AAIpE,MAAM,iBAAiB,GAAG;IACxB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACT,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACT,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACT,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACT,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACT,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAG,QAAQ;CACrB,CAAC;AAEF,SAAS,oBAAoB,CAAC,OAAgB;IAC5C,MAAM,MAAM,GAAG,EAAE,CAAC;IAClB,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAC9B,MAAM,mBAAmB,GAAG,IAAI,CAAC;IAEjC,KAAK,MAAM,OAAO,IAAI,iBAAiB,EAAE;QACvC,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,MAAM,GAAG,wBAAQ,CAAC,0BAA0B,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;QACvF,MAAM,CAAC,gBAAgB,EAAE,CAAC;QAE1B,MAAM,KAAK,GAAG,yBAAS,CAAC,uBAAuB,CAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC;QAC7G,IAAI,CAAC,KAAK;YACR,OAAO,EAAE,CAAC;QAEZ,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;KACpB;IAED,IAAA,qBAAM,EAAC,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC;IAC5B,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,6DAA6D;AAC7D,MAAM,sBAAsB,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAE1E;;;;GAIG;AACH,MAAa,aAAa;IAGxB,YAAoB,MAAmB;QACrC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,WAAW,CAAC,OAAgB;QACxC,MAAM,MAAM,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAC7C,OAAO,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,WAAW;QACvB,OAAO,IAAI,aAAa,CAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;OAEG;IACI,IAAI,CAAC,OAAgB;QAC1B,IAAI,CAAC,OAAO,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAC7C,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACI,yBAAyB,CAAC,GAAY,EAAE,MAAuB;QACpE,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrD,CAAC;IAED;;;;OAIG;IACI,iBAAiB,CAAC,GAAY,EAAE,MAAuB;QAC5D,OAAO,aAAa,CAAC,WAAW,CAAC,OAAO,KAAK,IAAI,CAAC,yBAAyB,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAC3F,CAAC;IAED;;;;OAIG;IACI,aAAa,CAAC,KAAc,EAAE,YAAoB,MAAM;QAC7D,OAAO,aAAa,CAAC,WAAW,CAAC,OAAO,KAAK,IAAI,CAAC,kBAAkB,CAAC,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;IACtG,CAAC;IAED;;;;;OAKG;IACI,kBAAkB,CAAC,MAAiB,EAAE,MAAuB,EAAE,YAAoB,MAAM;QAC9F,IAAA,qBAAM,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,IAAI,SAAS,KAAK,IAAI,CAAC,OAAO;YAC5B,OAAO,aAAa,CAAC,WAAW,CAAC,OAAO,CAAC;QAE3C,mDAAmD;QACnD,IAAI,MAAM,EAAE;YACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC9B,MAAM,cAAc,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACrD,MAAM,mBAAmB,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC;gBACtD,IAAI,cAAc,GAAG,CAAC,mBAAmB;oBACvC,OAAO,aAAa,CAAC,WAAW,CAAC,OAAO,CAAC;gBAE3C,sBAAsB,CAAC,CAAC,CAAC,GAAG,cAAc,GAAG,mBAAmB,CAAC;aAClE;SACF;QAED,uBAAuB;QACvB,IAAI,SAAS,GAAG,IAAI,CAAC;QACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC5C,IAAI,MAAM,IAAI,sBAAsB,CAAC,CAAC,CAAC;gBACrC,SAAS;YAEX,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAC9B,IAAI,QAAQ,GAAG,CAAC,CAAC;YACjB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;gBAC1B,IAAI,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,SAAS,GAAG,CAAC,EAAE;oBACzC,EAAE,QAAQ,CAAC;oBACX,SAAS,GAAG,KAAK,CAAC;iBACnB;aACF;YAED,IAAI,QAAQ,KAAK,MAAM,CAAC,MAAM;gBAC5B,OAAO,aAAa,CAAC,WAAW,CAAC,OAAO,CAAC;SAC5C;QAED,OAAO,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,WAAW,CAAC,OAAO,CAAC;IAC1F,CAAC;IAED;;;;OAIG;IACI,aAAa,CAAC,MAAe,EAAE,SAAmB;QACvD,IAAA,qBAAM,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,IAAI,SAAS,KAAK,IAAI,CAAC,OAAO,EAAE;YAC9B,OAAO,KAAK,CAAC;SACd;QAED,IAAI,IAAI,GAAG,IAAI,CAAC;QAChB,IAAI,KAAK,GAAG,CAAC,IAAI,CAAC;QAElB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,OAAO,EAAE;YAChC,MAAM,EAAE,GAAG,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;YACrC,MAAM,EAAE,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;YAClC,IAAI,GAAG,KAAK,EAAE,EAAE;gBACd,uEAAuE;gBACvE,IAAI,EAAE,GAAG,GAAG,EAAE;oBACZ,OAAO,KAAK,CAAC;iBACd;aACF;iBAAM;gBACL,MAAM,WAAW,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC;gBAC7B,IAAI,EAAE,GAAG,GAAG,EAAE;oBACZ,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;iBACpC;qBAAM;oBACL,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;iBACtC;aACF;SACF;QAED,OAAO,KAAK,IAAI,IAAI,CAAC;IACvB,CAAC;CACF;AAxJD,sCAwJC;AAED,0BAA0B;AAC1B,WAAiB,aAAa;IAC5B;;OAEG;IACH,IAAY,WAOX;IAPD,WAAY,WAAW;QACrB,sFAAsF;QACtF,mDAAW,CAAA;QACX,4GAA4G;QAC5G,mDAAW,CAAA;QACX,qFAAqF;QACrF,iDAAU,CAAA;IACZ,CAAC,EAPW,WAAW,GAAX,yBAAW,KAAX,yBAAW,QAOtB;AACH,CAAC,EAZgB,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAY7B","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Geometry\n */\n\nimport { assert } from \"@itwin/core-bentley\";\nimport { ClipPlane, Point3d, Vector3d } from \"@itwin/core-geometry\";\nimport { Frustum } from \"../Frustum\";\nimport { BoundingSphere } from \"./BoundingSphere\";\n\nconst planePointIndices = [\n  [1, 3, 5],  // right\n  [0, 4, 2],  // left\n  [2, 6, 3],  // top\n  [0, 1, 4],  // bottom\n  [0, 2, 1],  // back\n  [4, 5, 6],  // front\n];\n\nfunction computeFrustumPlanes(frustum: Frustum): ClipPlane[] {\n  const planes = [];\n  const points = frustum.points;\n  const expandPlaneDistance = 1e-6;\n\n  for (const indices of planePointIndices) {\n    const i0 = indices[0], i1 = indices[1], i2 = indices[2];\n    const normal = Vector3d.createCrossProductToPoints(points[i2], points[i1], points[i0]);\n    normal.normalizeInPlace();\n\n    const plane = ClipPlane.createNormalAndDistance(normal, normal.dotProduct(points[i0]) - expandPlaneDistance);\n    if (!plane)\n      return [];\n\n    planes.push(plane);\n  }\n\n  assert(planes.length === 6);\n  return planes;\n}\n\n// Scratch variable used by FrustumPlanes.computeContainment.\nconst planesContainingSphere = [false, false, false, false, false, false];\n\n/** Represents a the planes of a [[Frustum]] for testing containment and intersection.\n * A valid frustum produces six planes. A degenerate frustum produces zero planes.\n * @public\n * @extensions\n */\nexport class FrustumPlanes {\n  private _planes: ClipPlane[];\n\n  private constructor(planes: ClipPlane[]) {\n    this._planes = planes;\n  }\n\n  /** Compute the six planes of the specified frustum.\n   * If the frustum is degenerate - that is, its points do not represent a truncated pyramid - then the returned `FrustumPlanes` will contain zero planes.\n   * @see [[isValid]] to test this condition.\n   */\n  public static fromFrustum(frustum: Frustum): FrustumPlanes {\n    const planes = computeFrustumPlanes(frustum);\n    return new FrustumPlanes(planes);\n  }\n\n  /** Create an empty set of frustum planes. [[isValid]] will be `true`. This can be useful when you want to create a `FrustumPlanes` object and initialize it later via [[init]] -\n   * for example, if you intend to use the same object repeatedly with different [[Frustum]]s.\n   */\n  public static createEmpty(): FrustumPlanes {\n    return new FrustumPlanes([]);\n  }\n\n  /** Returns true if [[planes]] consists of six planes. This may return `false` if a degenerate [[Frustum]] was supplied to [[fromFrustum]], or if this object was created\n   * via [[createEmpty]] - in either case, [[planes]] will be an empty array.\n   */\n  public get isValid(): boolean {\n    return this._planes.length === 6;\n  }\n\n  /** Obtain the list of planes defining the frustum. If [[isValid]] is `true`, it will have a length of six, with the planes ordered as\n   * right, left, top, bottom, back, front. Otherwise, it will be empty.\n   */\n  public get planes(): ClipPlane[] {\n    return this._planes;\n  }\n\n  /** Recompute the planes from the specified frustum.\n   * @returns true upon success, or false if the input frustum was degenerate, in which case [[isValid]] will be `false`.\n   */\n  public init(frustum: Frustum): boolean {\n    this._planes = computeFrustumPlanes(frustum);\n    return this.isValid;\n  }\n\n  /** Compute to what degree a [[Frustum]] is contained with these frustum planes.\n   * @param box The frustum to test for containment.\n   * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.\n   * @returns the degree to which `box` is contained within the clipping planes.\n   */\n  public computeFrustumContainment(box: Frustum, sphere?: BoundingSphere): FrustumPlanes.Containment {\n    return this.computeContainment(box.points, sphere);\n  }\n\n  /** Determines whether a [[Frustum]] intersects with or is fully contained within these frustum planes.\n   * @param box The frustum to test for containment.\n   * @param sphere An optional spherical bounding volume fully containing `box`. If supplied, this can reduce the amount of computation required.\n   * @returns true if `box` is not entirely outside of the clipping planes.\n   */\n  public intersectsFrustum(box: Frustum, sphere?: BoundingSphere): boolean {\n    return FrustumPlanes.Containment.Outside !== this.computeFrustumContainment(box, sphere);\n  }\n\n  /** Determines whether a point is contained within these frustum planes.\n   * @param point The point to test for containment.\n   * @param tolerance The maximum distance from the interior of the frustum planes that will still be considered \"contained\".\n   * @returns true if `point` is no further than `tolerance` meters outside of the clipping planes.\n   */\n  public containsPoint(point: Point3d, tolerance: number = 1.0e-8): boolean {\n    return FrustumPlanes.Containment.Outside !== this.computeContainment([point], undefined, tolerance);\n  }\n\n  /** Compute the degree to which a set of points is contained within these frustum planes.\n   * @param points The points to test for containment.\n   * @param sphere An optional spherical bounding volume fully containing all of the points. If supplied, this can reduce the amount of computation required.\n   * @param tolerance The maximum distance from the interior of the frustum planes a point must be to be considered \"contained\".\n   * @returns the degree to which all of the points are contained within the clipping planes.\n   */\n  public computeContainment(points: Point3d[], sphere?: BoundingSphere, tolerance: number = 1.0e-8): FrustumPlanes.Containment {\n    assert(this.isValid);\n    if (undefined === this._planes)\n      return FrustumPlanes.Containment.Outside;\n\n    // Do the cheap test against bounding sphere first.\n    if (sphere) {\n      for (let i = 0; i < this._planes.length; i++) {\n        const plane = this._planes[i];\n        const centerDistance = plane.altitude(sphere.center);\n        const tolerancePlusRadius = tolerance + sphere.radius;\n        if (centerDistance < -tolerancePlusRadius)\n          return FrustumPlanes.Containment.Outside;\n\n        planesContainingSphere[i] = centerDistance > tolerancePlusRadius;\n      }\n    }\n\n    // Test against points.\n    let allInside = true;\n    for (let i = 0; i < this._planes.length; i++) {\n      if (sphere && planesContainingSphere[i])\n        continue;\n\n      const plane = this._planes[i];\n      let nOutside = 0;\n      for (const point of points) {\n        if (plane.altitude(point) + tolerance < 0) {\n          ++nOutside;\n          allInside = false;\n        }\n      }\n\n      if (nOutside === points.length)\n        return FrustumPlanes.Containment.Outside;\n    }\n\n    return allInside ? FrustumPlanes.Containment.Inside : FrustumPlanes.Containment.Partial;\n  }\n\n  /** Computes whether a ray intersects these clipping planes.\n   * @param origin The origin of the ray.\n   * @param direction The direction of the ray.\n   * @returns true if the ray extending from `origin` in the specified `direction` intersects at least one of the clipping planes.\n   */\n  public intersectsRay(origin: Point3d, direction: Vector3d): boolean {\n    assert(this.isValid);\n    if (undefined === this._planes) {\n      return false;\n    }\n\n    let tFar = 1e37;\n    let tNear = -tFar;\n\n    for (const plane of this._planes) {\n      const vD = plane.velocity(direction);\n      const vN = plane.altitude(origin);\n      if (0.0 === vD) {\n        // ray is parallel... no need to continue testing if outside halfspace.\n        if (vN < 0.0) {\n          return false;\n        }\n      } else {\n        const rayDistance = -vN / vD;\n        if (vD < 0.0) {\n          tFar = Math.min(rayDistance, tFar);\n        } else {\n          tNear = Math.max(rayDistance, tNear);\n        }\n      }\n    }\n\n    return tNear <= tFar;\n  }\n}\n\n/** @public @extensions */\nexport namespace FrustumPlanes { // eslint-disable-line no-redeclare\n  /** Describes the degree to which an object is contained within the planes of a [[Frustum]].\n   * @see [[FrustumPlanes.computeContainment]], for example.\n   */\n  export enum Containment {\n    /** The object is entirely outside of the frustum, intersecting none of its planes. */\n    Outside = 0,\n    /** The object intersects at least one of the frustum planes. placing it partially inside of the frustum. */\n    Partial = 1,\n    /** The object is entirely inside of the frustum, intersecting none of its planes. */\n    Inside = 2,\n  }\n}\n"]}