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

package/src/lib/algorithms/compute-eigen-decomposition.d.ts

@@ -1,39 +0,0 @@
-import {Matrix3} from '@math.gl/core';
-
-/**
- * Computes the eigenvectors and eigenvalues of a symmetric matrix.
- *
- * - Returns a diagonal matrix and unitary matrix such that:
- * `matrix = unitary matrix * diagonal matrix * transpose(unitary matrix)`
- * - The values along the diagonal of the diagonal matrix are the eigenvalues. The columns
- * of the unitary matrix are the corresponding eigenvectors.
- * - This routine was created based upon Matrix Computations, 3rd ed., by Golub and Van Loan,
- * section 8.4.3 The Classical Jacobi Algorithm
- *
- * @param matrix The 3x3 matrix to decompose into diagonal and unitary matrix. Expected to be symmetric.
- * @param result Optional object with unitary and diagonal properties which are matrices onto which to store the result.
- * @returns An object with unitary and diagonal properties which are the unitary and diagonal matrices, respectively.
- *
- * @example
- * const a = //... symmetric matrix
- * const result = {
- *   unitary : new Matrix3(),
- *   diagonal : new Matrix3()
- * };
- * computeEigenDecomposition(a, result);
- *
- * const unitaryTranspose = Matrix3.transpose(result.unitary, new Matrix3());
- * const b = Matrix3.multiply(result.unitary, result.diagonal, new Matrix3());
- * Matrix3.multiply(b, unitaryTranspose, b); // b is now equal to a
- *
- * const lambda = result.diagonal.getColumn(0, new Vector3()).x;  // first eigenvalue
- * const v = result.unitary.getColumn(0, new Vector3());          // first eigenvector
- * const c = v.multiplyByScalar(lambda);                          // equal to v.transformByMatrix3(a)
- */
-export default function computeEigenDecomposition(
-  matrix: number[],
-  result?: object
-): {
-  unitary: Matrix3;
-  diagonal: Matrix3;
-};

package/src/lib/bounding-volumes/axis-aligned-bounding-box.d.ts

@@ -1,51 +0,0 @@
-import {BoundingVolume} from './bounding-volume';
-import {Vector3} from '@math.gl/core';
-import Plane from '../plane';
-import {INTERSECTION_ENUM} from '../../constants';
-
-/**
-* An axis aligned bounding box - aligned with coordinate axes
-* @see BoundingVolume
-* @see BoundingRectangle
-* @see OrientedBoundingBox
-*/
-export default class AxisAlignedBoundingBox implements BoundingVolume {
-  /** The center point of the bounding box. */
-  readonly center: Vector3;
-  /** The positive half diagonal of the bounding box. */
-  readonly halfDiagonal: Vector3;
-  /** The minimum point defining the bounding box. [0, 0, 0] for empty box */
-  readonly minimum: Vector3;
-  /** The maximum point defining the bounding box. [0, 0, 0] for empty box */
-  readonly maximum: Vector3;
-
-  /**
-   * Creates an instance of an AxisAlignedBoundingBox from the minimum and maximum points along the x, y, and z axes.
-   * @param minimum=[0, 0, 0] The minimum point along the x, y, and z axes.
-   * @param maximum=[0, 0, 0] The maximum point along the x, y, and z axes.
-   * @param center The center of the box; automatically computed if not supplied.
-   */
-  constructor(minimum?: readonly number[], maximum?: readonly number[], center?: readonly number[]);
-
-  /** Duplicates a AxisAlignedBoundingBox instance. */
-  clone(): AxisAlignedBoundingBox;
-  /** Compares the provided AxisAlignedBoundingBox component wise */
-  equals(right: AxisAlignedBoundingBox): boolean;
-
-  // BoundingVolume interface
-
-  /**
-   * Applies a 4x4 affine transformation matrix to a bounding sphere.
-   * @param transform The transformation matrix to apply to the bounding sphere.
-   * @returns itself, i.e. the modified BoundingVolume.
-   */
-  transform(transform: readonly number[]): this;
-
-  /** Computes the estimated distance from the closest point on a bounding box to a point. */
-  distanceTo(point: readonly number[]): number;
-  /** Computes the estimated distance squared from the closest point on a bounding box to a point. */
-  distanceSquaredTo(point: readonly number[]): number;
-
-  /** Determines which side of a plane a box is located. */
-  intersectPlane(plane: Plane): INTERSECTION_ENUM;
-}

package/src/lib/bounding-volumes/bounding-sphere.d.ts

@@ -1,52 +0,0 @@
-import {BoundingVolume} from './bounding-volume';
-import {Vector3} from '@math.gl/core';
-import {INTERSECTION_ENUM} from '../../constants';
-import Plane from '../plane';
-
-/** A BoundingSphere */
-export default class BoundingSphere implements BoundingVolume {
-  center: Vector3;
-  radius: number;
-
-  /** Creates a bounding sphere */
-  constructor(center?: readonly number[], radius?: number);
-
-  /** Sets the bounding sphere from `center` and `radius`. */
-  fromCenterRadius(center: readonly number[], radius: number): this;
-
-  /**
-   * Computes a bounding sphere from the corner points of an axis-aligned bounding box.  The sphere
-   * tightly and fully encompasses the box.
-   */
-  fromCornerPoints(corner: readonly number[], oppositeCorner: readonly number[]): this;
-
-  /** Compares the provided BoundingSphere component wise */
-  equals(right: BoundingSphere): boolean;
-
-  /** Duplicates a BoundingSphere instance. */
-  clone(): this;
-
-  /** Computes a bounding sphere that contains both the left and right bounding spheres. */
-  union(boundingSphere: BoundingSphere): this;
-
-  /** Computes a bounding sphere by enlarging the provided sphere to contain the provided point. */
-  expand(point: readonly number[]): this;
-
-  // BoundingVolume interface
-
-  /**
-   * Applies a 4x4 affine transformation matrix to a bounding sphere.
-   * @param sphere The bounding sphere to apply the transformation to.
-   * @param transform The transformation matrix to apply to the bounding sphere.
-   * @returns self.
-   */
-  transform(transform: readonly number[]): this;
-
-  /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
-  distanceSquaredTo(point: readonly number[]): number;
-  /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
-  distanceTo(point: readonly number[]): number;
-
-  /** Determines which side of a plane a sphere is located. */
-  intersectPlane(plane: Plane): INTERSECTION_ENUM;
-}

package/src/lib/bounding-volumes/oriented-bounding-box.d.ts

@@ -1,83 +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
-
-import {BoundingVolume} from './bounding-volume';
-import {Vector3, Matrix3, Quaternion} from '@math.gl/core';
-import BoundingSphere from './bounding-sphere';
-import Plane from '../plane';
-import {INTERSECTION_ENUM} from '../../constants';
-
-/**
- * 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 implements BoundingVolume {
-  center: Vector3;
-  halfAxes: Matrix3;
-
-  /**
-   * 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.
-   */
-  constructor(center?: readonly number[], halfAxes?: readonly number[]);
-
-  /** Returns an array with three halfSizes for the bounding box */
-  get halfSize(): number[];
-
-  /** Returns a quaternion describing the orientation of the bounding box */
-  get quaternion(): Quaternion;
-
-  /**
-   * Create OrientedBoundingBox from quaternion based OBB,
-   */
-  fromCenterHalfSizeQuaternion(center: number[], halfSize: number[], quaternion: number[]): OrientedBoundingBox;
-
-  /** Duplicates a OrientedBoundingBox instance. */
-  clone(): OrientedBoundingBox;
-
-  /** Compares the provided OrientedBoundingBox component wise and returns */
-  equals(right: OrientedBoundingBox): boolean;
-
-  /** Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box. */
-  getBoundingSphere(result?: BoundingSphere): BoundingSphere;
-
-  /**
-   * 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.
-   */
-  computePlaneDistances(position: readonly number[], direction: readonly number[], result?: number[]): number[];
-
-  // BoundingVolume interface
-
-  /**
-   * Applies a 4x4 affine transformation matrix to a bounding sphere.
-   * @param transform The transformation matrix to apply to the bounding sphere.
-   * @returns itself, i.e. the modified BoundingVolume.
-   */
-  transform(transform: readonly number[]): this;
-
-   /** Computes the estimated distance from the closest point on a bounding box to a point. */
-  distanceTo(point: readonly number[]): number;
-
-  /**
-   * 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: readonly number[]): number;
-
-  /** Determines which side of a plane the oriented bounding box is located. */
-  intersectPlane(plane: Plane): INTERSECTION_ENUM;
-}

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

@@ -1,55 +0,0 @@
-import {INTERSECTION_ENUM} from '../constants';
-import BoundingSphere from './bounding-volumes/bounding-sphere';
-import Plane from './plane';
-
-// 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 readonly 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 readonly 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 readonly 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): INTERSECTION_ENUM;
-
-  /**
-   * 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: object, parentPlaneMask: number): number;
-}

package/src/lib/plane.d.ts

@@ -1,38 +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
-
-import {Vector3} from '@math.gl/core';
-
-/** A plane in Hessian Normal Form */
-export default class Plane {
-  readonly normal: Vector3;
-  readonly distance: number;
-
-  constructor(normal?: readonly number[], distance?: number);
-
-  fromNormalDistance(normal: readonly number[], distance: number);
-
-  /** Creates a plane from a normal and a point on the plane. */
-  fromPointNormal(point: readonly number[], normal: readonly number[]);
-
-  /** Creates a plane from the general equation */
-  fromCoefficients(a: number, b: number, c: number, d: number): Plane;
-
-  /** Duplicates a Plane instance. */
-  clone(): Plane;
-
-  /** Compares the provided Planes by normal and distance */
-  equals(right: Plane): Plane;
-
-  /** Computes the signed shortest distance of a point to a plane.
-   * The sign of the distance determines which side of the plane the point is on.
-   */
-  getPointDistance(point: readonly number[]): number;
-
-  /** Transforms the plane by the given transformation matrix. */
-  transform(matrix4: readonly number[]): Plane;
-
-  /** Projects a point onto the plane. */
-  projectPointOntoPlane(point: readonly number[], result: Vector3): Vector3;
-  projectPointOntoPlane(point: readonly number[], result?: readonly number[]): readonly number[];
-}