@math.gl/culling 3.5.6 → 3.6.0-alpha.2

package/dist/lib/bounding-volumes/oriented-bounding-box.js

@@ -0,0 +1,256 @@
+// 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
+import { Vector3, Matrix3, Quaternion } from '@math.gl/core';
+import BoundingSphere from './bounding-sphere';
+import { INTERSECTION } from '../../constants';
+const scratchVector3 = new Vector3();
+const scratchOffset = new Vector3();
+const scratchVectorU = new Vector3();
+const scratchVectorV = new Vector3();
+const scratchVectorW = new Vector3();
+const scratchCorner = new Vector3();
+const scratchToCenter = new Vector3();
+const MATRIX3 = {
+    COLUMN0ROW0: 0,
+    COLUMN0ROW1: 1,
+    COLUMN0ROW2: 2,
+    COLUMN1ROW0: 3,
+    COLUMN1ROW1: 4,
+    COLUMN1ROW2: 5,
+    COLUMN2ROW0: 6,
+    COLUMN2ROW1: 7,
+    COLUMN2ROW2: 8
+};
+/**
+ * An OrientedBoundingBox of some object is a closed and convex cuboid.
+ * It can provide a tighter bounding volume than `BoundingSphere` or
+ * `AxisAlignedBoundingBox` in many cases.
+ */
+export default class OrientedBoundingBox {
+    constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
+        this.center = new Vector3().from(center);
+        this.halfAxes = new Matrix3(halfAxes);
+    }
+    /** Returns an array with three halfSizes for the bounding box */
+    get halfSize() {
+        const xAxis = this.halfAxes.getColumn(0);
+        const yAxis = this.halfAxes.getColumn(1);
+        const zAxis = this.halfAxes.getColumn(2);
+        return [new Vector3(xAxis).len(), new Vector3(yAxis).len(), new Vector3(zAxis).len()];
+    }
+    /** Returns a quaternion describing the orientation of the bounding box */
+    get quaternion() {
+        const xAxis = this.halfAxes.getColumn(0);
+        const yAxis = this.halfAxes.getColumn(1);
+        const zAxis = this.halfAxes.getColumn(2);
+        const normXAxis = new Vector3(xAxis).normalize();
+        const normYAxis = new Vector3(yAxis).normalize();
+        const normZAxis = new Vector3(zAxis).normalize();
+        return new Quaternion().fromMatrix3(new Matrix3([...normXAxis, ...normYAxis, ...normZAxis]));
+    }
+    /**
+     * Create OrientedBoundingBox from quaternion based OBB,
+     */
+    fromCenterHalfSizeQuaternion(center, halfSize, quaternion) {
+        const quaternionObject = new Quaternion(quaternion);
+        const directionsMatrix = new Matrix3().fromQuaternion(quaternionObject);
+        directionsMatrix[0] = directionsMatrix[0] * halfSize[0];
+        directionsMatrix[1] = directionsMatrix[1] * halfSize[0];
+        directionsMatrix[2] = directionsMatrix[2] * halfSize[0];
+        directionsMatrix[3] = directionsMatrix[3] * halfSize[1];
+        directionsMatrix[4] = directionsMatrix[4] * halfSize[1];
+        directionsMatrix[5] = directionsMatrix[5] * halfSize[1];
+        directionsMatrix[6] = directionsMatrix[6] * halfSize[2];
+        directionsMatrix[7] = directionsMatrix[7] * halfSize[2];
+        directionsMatrix[8] = directionsMatrix[8] * halfSize[2];
+        this.center = new Vector3().from(center);
+        this.halfAxes = directionsMatrix;
+        return this;
+    }
+    /** Duplicates a OrientedBoundingBox instance. */
+    clone() {
+        return new OrientedBoundingBox(this.center, this.halfAxes);
+    }
+    /** Compares the provided OrientedBoundingBox component wise and returns */
+    equals(right) {
+        return (this === right ||
+            (Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes)));
+    }
+    /** Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box. */
+    getBoundingSphere(result = new BoundingSphere()) {
+        const halfAxes = this.halfAxes;
+        const u = halfAxes.getColumn(0, scratchVectorU);
+        const v = halfAxes.getColumn(1, scratchVectorV);
+        const w = halfAxes.getColumn(2, scratchVectorW);
+        // Calculate "corner" vector
+        const cornerVector = scratchVector3.copy(u).add(v).add(w);
+        result.center.copy(this.center);
+        result.radius = cornerVector.magnitude();
+        return result;
+    }
+    /** Determines which side of a plane the oriented bounding box is located. */
+    intersectPlane(plane) {
+        const center = this.center;
+        const normal = plane.normal;
+        const halfAxes = this.halfAxes;
+        const normalX = normal.x;
+        const normalY = normal.y;
+        const normalZ = normal.z;
+        // Plane is used as if it is its normal; the first three components are assumed to be normalized
+        const radEffective = Math.abs(normalX * halfAxes[MATRIX3.COLUMN0ROW0] +
+            normalY * halfAxes[MATRIX3.COLUMN0ROW1] +
+            normalZ * halfAxes[MATRIX3.COLUMN0ROW2]) +
+            Math.abs(normalX * halfAxes[MATRIX3.COLUMN1ROW0] +
+                normalY * halfAxes[MATRIX3.COLUMN1ROW1] +
+                normalZ * halfAxes[MATRIX3.COLUMN1ROW2]) +
+            Math.abs(normalX * halfAxes[MATRIX3.COLUMN2ROW0] +
+                normalY * halfAxes[MATRIX3.COLUMN2ROW1] +
+                normalZ * halfAxes[MATRIX3.COLUMN2ROW2]);
+        const distanceToPlane = normal.dot(center) + plane.distance;
+        if (distanceToPlane <= -radEffective) {
+            // The entire box is on the negative side of the plane normal
+            return INTERSECTION.OUTSIDE;
+        }
+        else if (distanceToPlane >= radEffective) {
+            // The entire box is on the positive side of the plane normal
+            return INTERSECTION.INSIDE;
+        }
+        return INTERSECTION.INTERSECTING;
+    }
+    /** Computes the estimated distance from the closest point on a bounding box to a point. */
+    distanceTo(point) {
+        return Math.sqrt(this.distanceSquaredTo(point));
+    }
+    /**
+     * Computes the estimated distance squared from the closest point
+     * on a bounding box to a point.
+     * See Geometric Tools for Computer Graphics 10.4.2
+     */
+    distanceSquaredTo(point) {
+        // Computes the estimated distance squared from the
+        // closest point on a bounding box to a point.
+        // See Geometric Tools for Computer Graphics 10.4.2
+        const offset = scratchOffset.from(point).subtract(this.center);
+        const halfAxes = this.halfAxes;
+        const u = halfAxes.getColumn(0, scratchVectorU);
+        const v = halfAxes.getColumn(1, scratchVectorV);
+        const w = halfAxes.getColumn(2, scratchVectorW);
+        const uHalf = u.magnitude();
+        const vHalf = v.magnitude();
+        const wHalf = w.magnitude();
+        u.normalize();
+        v.normalize();
+        w.normalize();
+        let distanceSquared = 0.0;
+        let d;
+        d = Math.abs(offset.dot(u)) - uHalf;
+        if (d > 0) {
+            distanceSquared += d * d;
+        }
+        d = Math.abs(offset.dot(v)) - vHalf;
+        if (d > 0) {
+            distanceSquared += d * d;
+        }
+        d = Math.abs(offset.dot(w)) - wHalf;
+        if (d > 0) {
+            distanceSquared += d * d;
+        }
+        return distanceSquared;
+    }
+    /**
+     * The distances calculated by the vector from the center of the bounding box
+     * to position projected onto direction.
+     *
+     * - If you imagine the infinite number of planes with normal direction,
+     *   this computes the smallest distance to the closest and farthest planes
+     *   from `position` that intersect the bounding box.
+     *
+     * @param position The position to calculate the distance from.
+     * @param direction The direction from position.
+     * @param result An Interval (array of length 2) to store the nearest and farthest distances.
+     * @returns Interval (array of length 2) with nearest and farthest distances
+     *   on the bounding box from position in direction.
+     */
+    // eslint-disable-next-line max-statements
+    computePlaneDistances(position, direction, result = [-0, -0]) {
+        let minDist = Number.POSITIVE_INFINITY;
+        let maxDist = Number.NEGATIVE_INFINITY;
+        const center = this.center;
+        const halfAxes = this.halfAxes;
+        const u = halfAxes.getColumn(0, scratchVectorU);
+        const v = halfAxes.getColumn(1, scratchVectorV);
+        const w = halfAxes.getColumn(2, scratchVectorW);
+        // project first corner
+        const corner = scratchCorner.copy(u).add(v).add(w).add(center);
+        const toCenter = scratchToCenter.copy(corner).subtract(position);
+        let mag = direction.dot(toCenter);
+        minDist = Math.min(mag, minDist);
+        maxDist = Math.max(mag, maxDist);
+        // project second corner
+        corner.copy(center).add(u).add(v).subtract(w);
+        toCenter.copy(corner).subtract(position);
+        mag = direction.dot(toCenter);
+        minDist = Math.min(mag, minDist);
+        maxDist = Math.max(mag, maxDist);
+        // project third corner
+        corner.copy(center).add(u).subtract(v).add(w);
+        toCenter.copy(corner).subtract(position);
+        mag = direction.dot(toCenter);
+        minDist = Math.min(mag, minDist);
+        maxDist = Math.max(mag, maxDist);
+        // project fourth corner
+        corner.copy(center).add(u).subtract(v).subtract(w);
+        toCenter.copy(corner).subtract(position);
+        mag = direction.dot(toCenter);
+        minDist = Math.min(mag, minDist);
+        maxDist = Math.max(mag, maxDist);
+        // project fifth corner
+        center.copy(corner).subtract(u).add(v).add(w);
+        toCenter.copy(corner).subtract(position);
+        mag = direction.dot(toCenter);
+        minDist = Math.min(mag, minDist);
+        maxDist = Math.max(mag, maxDist);
+        // project sixth corner
+        center.copy(corner).subtract(u).add(v).subtract(w);
+        toCenter.copy(corner).subtract(position);
+        mag = direction.dot(toCenter);
+        minDist = Math.min(mag, minDist);
+        maxDist = Math.max(mag, maxDist);
+        // project seventh corner
+        center.copy(corner).subtract(u).subtract(v).add(w);
+        toCenter.copy(corner).subtract(position);
+        mag = direction.dot(toCenter);
+        minDist = Math.min(mag, minDist);
+        maxDist = Math.max(mag, maxDist);
+        // project eighth corner
+        center.copy(corner).subtract(u).subtract(v).subtract(w);
+        toCenter.copy(corner).subtract(position);
+        mag = direction.dot(toCenter);
+        minDist = Math.min(mag, minDist);
+        maxDist = Math.max(mag, maxDist);
+        result[0] = minDist;
+        result[1] = maxDist;
+        return result;
+    }
+    /**
+     * Applies a 4x4 affine transformation matrix to a bounding sphere.
+     * @param transform The transformation matrix to apply to the bounding sphere.
+     * @returns itself, i.e. the modified BoundingVolume.
+     */
+    transform(transformation) {
+        this.center.transformAsPoint(transformation);
+        const xAxis = this.halfAxes.getColumn(0, scratchVectorU);
+        xAxis.transformAsPoint(transformation);
+        const yAxis = this.halfAxes.getColumn(1, scratchVectorV);
+        yAxis.transformAsPoint(transformation);
+        const zAxis = this.halfAxes.getColumn(2, scratchVectorW);
+        zAxis.transformAsPoint(transformation);
+        this.halfAxes = new Matrix3([...xAxis, ...yAxis, ...zAxis]);
+        return this;
+    }
+    getTransform() {
+        // const modelMatrix = Matrix4.fromRotationTranslation(this.boundingVolume.halfAxes, this.boundingVolume.center);
+        // return modelMatrix;
+        throw new Error('not implemented');
+    }
+}

package/dist/lib/culling-volume.d.ts

@@ -0,0 +1,46 @@
+import { INTERSECTION } from '../constants';
+import Plane from './plane';
+import type { BoundingVolume } from './bounding-volumes/bounding-volume';
+import type BoundingSphere from './bounding-volumes/bounding-sphere';
+/** A culling volume defined by planes. */
+export default class CullingVolume {
+    /**
+     * 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.
+     */
+    static MASK_OUTSIDE: number;
+    /**
+     * 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.
+     */
+    static MASK_INSIDE: number;
+    /**
+     * 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.
+     */
+    static MASK_INDETERMINATE: number;
+    /** Array of clipping planes. */
+    readonly planes: Plane[];
+    /**
+     * Create a new `CullingVolume` bounded by an array of clipping planed
+     * @param planes Array of clipping planes.
+     * */
+    constructor(planes?: Plane[]);
+    /**
+     * 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: BoundingSphere): CullingVolume;
+    /** Determines whether a bounding volume intersects the culling volume. */
+    computeVisibility(boundingVolume: BoundingVolume): INTERSECTION;
+    /**
+     * 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: BoundingVolume, parentPlaneMask: number): number;
+}
+//# sourceMappingURL=culling-volume.d.ts.map

package/dist/lib/culling-volume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"culling-volume.d.ts","sourceRoot":"","sources":["../../src/lib/culling-volume.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,oCAAoC,CAAC;AACvE,OAAO,KAAK,cAAc,MAAM,oCAAoC,CAAC;AASrE,0CAA0C;AAC1C,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC;;;OAGG;IACH,MAAM,CAAC,YAAY,SAAc;IAEjC;;;OAGG;IACH,MAAM,CAAC,WAAW,SAAc;IAEhC;;;OAGG;IACH,MAAM,CAAC,kBAAkB,SAAc;IAEvC,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;IAEzB;;;SAGK;gBACO,MAAM,GAAE,KAAK,EAAO;IAIhC;;;OAGG;IACH,kBAAkB,CAAC,cAAc,EAAE,cAAc,GAAG,aAAa;IAsCjE,0EAA0E;IAC1E,iBAAiB,CAAC,cAAc,EAAE,cAAc,GAAG,YAAY;IAsB/D;;;;;;;OAOG;IACH,8BAA8B,CAAC,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM;CAmChG"}

package/dist/lib/culling-volume.js

@@ -0,0 +1,121 @@
+// 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.d.ts

@@ -0,0 +1,140 @@
+import { Matrix4 } from '@math.gl/core';
+import PerspectiveOffCenterFrustum from './perspective-off-center-frustum';
+/**
+ * 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 {
+    _offCenterFrustum: PerspectiveOffCenterFrustum;
+    /**
+     * The angle of the field of view (FOV), in radians.  This angle will be used
+     * as the horizontal FOV if the width is greater than the height, otherwise
+     * it will be the vertical FOV.
+     */
+    fov: number;
+    _fov: any;
+    _fovy: any;
+    _sseDenominator: any;
+    /**
+     * The aspect ratio of the frustum's width to it's height.
+     */
+    aspectRatio: number;
+    _aspectRatio: any;
+    /**
+     * The distance of the near plane.
+     * @default 1.0
+     */
+    near: number;
+    _near: any;
+    /**
+     * The distance of the far plane.
+     * @default 500000000.0
+     */
+    far: number;
+    _far: any;
+    /**
+     * Offsets the frustum in the x direction.
+     * @default 0.0
+     */
+    xOffset: number;
+    _xOffset: any;
+    /**
+     * Offsets the frustum in the y direction.
+     * @default 0.0
+     */
+    yOffset: number;
+    _yOffset: any;
+    constructor(options?: Record<string, any>);
+    /**
+     * Returns a duplicate of a PerspectiveFrustum instance.
+     */
+    clone(): PerspectiveFrustum;
+    /**
+     * Compares the provided PerspectiveFrustum componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     */
+    equals(other: PerspectiveFrustum): boolean;
+    /**
+     * Gets the perspective projection matrix computed from the view frustum.
+     */
+    get projectionMatrix(): Matrix4;
+    /**
+     * The perspective projection matrix computed from the view frustum with an infinite far plane.
+     */
+    get infiniteProjectionMatrix(): Matrix4;
+    /**
+     * Gets the angle of the vertical field of view, in radians.
+     */
+    get fovy(): number;
+    /**
+     * @private
+     */
+    get sseDenominator(): number;
+    /**
+     * 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: any, direction: any, up: any): import("./culling-volume").default;
+    /**
+     * 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: any, drawingBufferHeight: any, distance: any, result: any): any;
+}
+//# sourceMappingURL=perspective-frustum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"perspective-frustum.d.ts","sourceRoot":"","sources":["../../src/lib/perspective-frustum.ts"],"names":[],"mappings":"AASA,OAAO,EAAS,OAAO,EAAC,MAAM,eAAe,CAAC;AAC9C,OAAO,2BAA2B,MAAM,kCAAkC,CAAC;AAI3E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAkB;IACrC,iBAAiB,8BAAqC;IACtD;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,MAAC;IACL,KAAK,MAAC;IACN,eAAe,MAAC;IAChB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,MAAC;IACb;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,MAAC;IACN;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,MAAC;IACL;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,MAAC;IACT;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,MAAC;gBAEG,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM;IA0B7C;;OAEG;IACH,KAAK,IAAI,kBAAkB;IAS3B;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO;IAiB1C;;OAEG;IACH,IAAI,gBAAgB,IAAI,OAAO,CAG9B;IAED;;OAEG;IACH,IAAI,wBAAwB,IAAI,OAAO,CAGtC;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAGjB;IAED;;OAEG;IACH,IAAI,cAAc,IAAI,MAAM,CAG3B;IAED;;;;;;;;;;;;OAYG;IACH,oBAAoB,CAAC,QAAQ,KAAA,EAAE,SAAS,KAAA,EAAE,EAAE,KAAA;IAK5C;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,kBAAkB,CAAC,kBAAkB,KAAA,EAAE,mBAAmB,KAAA,EAAE,QAAQ,KAAA,EAAE,MAAM,KAAA;CAS7E"}