@vertexvis/geometry 0.24.5-canary.4 → 1.0.0-testing.0

package/dist/cdn/matrix4.d.ts

@@ -1,285 +0,0 @@
-import * as Quaternion from './quaternion';
-import * as Vector3 from './vector3';
-/**
- * A type alias representing a 4x4 column-major matrix.
- *
- * The common use-case for 4x4 matrices in 3D computer graphics are for
- * [transformation
- * matrices](https://en.wikipedia.org/wiki/Transformation_matrix). This allows a
- * point in 3D space to be projected onto a 2D screen using transformations such
- * as translation, rotation and scale.
- */
-export declare type Matrix4 = [
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number
-];
-/**
- * An object representation of a `Matrix4`, where each value is represented as:
- *
- * ```
- * m11 m12 m13 m14
- * m21 m22 m23 m24
- * m31 m32 m33 m34
- * m41 m42 m43 m44
- * ```
- *
- * `Matrix4` arrays can be converted to an object using {@link toObject}.
- */
-export interface Matrix4AsObject {
-    m11: number;
-    m12: number;
-    m13: number;
-    m14: number;
-    m21: number;
-    m22: number;
-    m23: number;
-    m24: number;
-    m31: number;
-    m32: number;
-    m33: number;
-    m34: number;
-    m41: number;
-    m42: number;
-    m43: number;
-    m44: number;
-}
-/**
- * Creates a 4x4 matrix from a set of row-major components.
- */
-export declare function fromValues(m11: number, m12: number, m13: number, m14: number, m21: number, m22: number, m23: number, m24: number, m31: number, m32: number, m33: number, m34: number, m41: number, m42: number, m43: number, m44: number): Matrix4;
-/**
- * Creates a `Matrix4` from an object representation.
- */
-export declare function fromObject(obj: Matrix4AsObject): Matrix4;
-/**
- * Returns a new [identity matrix](https://en.wikipedia.org/wiki/Identity_matrix).
- */
-export declare function makeIdentity(): Matrix4;
-/**
- * Returns a matrix with all values as 0.
- */
-export declare function makeZero(): Matrix4;
-/**
- * Creates a translation matrix.
- *
- * ```
- * 1, 0, 0, 0,
- * 0, 1, 0, 0,
- * 0, 0, 1, 0,
- * x, y, z, 1
- * ```
- *
- * @param translation A vector representing the translation components.
- * @returns A translation matrix.
- */
-export declare function makeTranslation(translation: Vector3.Vector3): Matrix4;
-/**
- * Creates a rotation matrix.
- *
- * ```
- * 1-2y²-2z²,    2xy-2zw,    2xz+2yw,    0,
- * 2xy+2zw,      1-2x²-2z²,  2yz-2xw,    0,
- * 2xz-2yw,      2yz+2xw,    1-2x²-2y²,  0,
- * 0,            0,          0,          1,
- * ```
- *
- * @param rotation A quaternion representing the rotation.
- * @see https://en.wikipedia.org/wiki/Rotation_matrix#Quaternion
- * @returns A rotation matrix.
- */
-export declare function makeRotation(rotation: Quaternion.Quaternion): Matrix4;
-/**
- * Creates a scale matrix.
- *
- * ```
- * x, 0, 0, 0,
- * 0, y, 0, 0,
- * 0, 0, z, 0,
- * 0, 0, 0, 1
- * ```
- *
- * @param scale A vector representing the different scale components.
- * @returns A scale matrix.
- */
-export declare function makeScale(scale: Vector3.Vector3): Matrix4;
-/**
- * Creates a matrix that has translation, rotation and scale applied to it.
- *
- * @param translation The translation applied to the matrix.
- * @param rotation The rotation applied to the matrix.
- * @param scale The scale applied to the matrix.
- * @returns A transformed matrix.
- */
-export declare function makeTRS(translation: Vector3.Vector3, rotation: Quaternion.Quaternion, scale: Vector3.Vector3): Matrix4;
-/**
- * Returns a matrix that has the basis components (upper left 3x3 matrix) set to
- * the following x, y, and z axis.
- *
- * ```
- * x.x  y.x  z.x  0
- * x.y  y.y  z.y  0
- * x.z  y.z  z.z  0
- * 0    0    0    0
- * ```
- *
- * @param x The x axis to set.
- * @param y The y axis to set.
- * @param z The z axis to set.
- * @returns A matrix with its basis components populated.
- */
-export declare function makeBasis(x: Vector3.Vector3, y: Vector3.Vector3, z: Vector3.Vector3): Matrix4;
-/**
- * Creates a rotation matrix that is rotated around a given axis by the given
- * angle.
- *
- * @param axis The axis of rotation.
- * @param radians The angle of rotation.
- * @returns A rotation matrix.
- */
-export declare function makeRotationAxis(axis: Vector3.Vector3, radians: number): Matrix4;
-/**
- * Creates a matrix used for [perspective
- * projections](https://en.wikipedia.org/wiki/3D_projection#Perspective_projection).
- *
- * The viewing volume is frustum-shaped and defined by the six parameters. Left,
- * right, top, and bottom specify coordinates in the near clipping plane where
- * the frustum edges intersect it, and the near and far parameters define the
- * forward distances of the view volume. The resulting volume can be vertically
- * and horizontally asymmetrical around the center of the near plane.
- *
- * @param left The left coordinate at the near plane.
- * @param right The right coordinate at the near plane.
- * @param top The top coordinate at the near plane.
- * @param bottom The bottom coordinate at the near plane.
- * @param near The near distance.
- * @param far The far distance.
- * @returns A matrix representing a view frustum.
- */
-export declare function makeFrustum(left: number, right: number, top: number, bottom: number, near: number, far: number): Matrix4;
-/**
- * Creates a perspective projection matrix.
- *
- * Related to: gluPerspective. The viewing volume is frustum-shaped amd defined
- * by the four parameters. The fovy and aspect ratio are used to compute the
- * positions of the left, right, top, and bottom sides of the viewing volume in
- * the zNear plane. The fovy is the y field-of-view, the angle made by the top
- * and bottom sides of frustum if they were to intersect. The aspect ratio is
- * the width of the frustum divided by its height. Note that the resulting
- * volume is both vertically and horizontally symmetrical around the center of
- * the near plane.
- *
- * @param near The near Z value.
- * @param far The far Z value.
- * @param fovY The field of view.
- * @param aspect The aspect ratio.
- * @returns A matrix.
- */
-export declare function makePerspective(near: number, far: number, fovY: number, aspect: number): Matrix4;
-/**
- * Creates an orthographic projection matrix.
- *
- * Related to: gluOrtho. The viewing volume is cube-shaped and defined by
- * the six parameters. The left and right values represent the coordinates of
- * the vertical clipping planes, top and bottom values represent the coordinates
- * of the horizontal clipping planes, and near and far values represent the
- * coordinates of the depth clipping planes.
- *
- * @param left The coordinate of the left horizontal clipping plane.
- * @param right The coordinate of the right horizontal clipping plane.
- * @param bottom The coordinate of the bottom vertical clipping plane.
- * @param top The coordinate of the top vertical clipping plane.
- * @param near The coordinate of the near depth clipping plane.
- * @param far The coordinate of the far depth clipping plane.
- * @returns A matrix.
- */
-export declare function makeOrthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
-/**
- * Matrix becomes a combination of an inverse translation and rotation.
- *
- * Related to: gluLookAt. This creates the inverse of makeLookAtMatrix. The
- * matrix will be an opposite translation from the 'eye' position, and it will
- * rotate things in the opposite direction of the eye-to-center orientation.
- * This is definitely confusing, but the main reason to use this transform is to
- * set up a view matrix for a camera that's looking at a certain point. To
- * achieve the effect of moving the camera somewhere and rotating it so that it
- * points at something, the rest of the world is moved in the opposite direction
- * and rotated in the opposite way around the camera. This way, you get the same
- * effect as moving the actual camera, but all the projection math can still be
- * done with the camera positioned at the origin (which makes it way simpler).
- *
- * @param position The position of the object.
- * @param lookAt The point which the object is looking at.
- * @param up The direction which the object considers up.
- * @returns A matrix.
- */
-export declare function makeLookAtView(position: Vector3.Vector3, lookAt: Vector3.Vector3, up: Vector3.Vector3): Matrix4;
-/**
- * Matrix becomes a combination of translation and rotation.
- *
- * Matrix becomes a combination of a translation to the position of 'eye' and a
- * rotation matrix which orients an object to point towards 'center' along its
- * z-axis. Use this function if you want an object to look at a point from
- * another point in space.
- *
- * @param position The position of the object.
- * @param lookAt The point which the object is looking at.
- * @param up The direction which the object considers up.
- * @returns A matrix.
- */
-export declare function makeLookAt(position: Vector3.Vector3, lookAt: Vector3.Vector3, up: Vector3.Vector3): Matrix4;
-/**
- * Returns the inverse of the given matrix. If the determinate of the matrix is
- * zero, then a zero matrix is returned.
- */
-export declare function invert(matrix: Matrix4): Matrix4;
-/**
- * Returns a rotation matrix looking from position towards target and oriented
- * by an up vector.
- *
- * @param m The matrix to transform.
- * @param position The point from which to look at target.
- * @param target The point to look at.
- * @param up The orientation.
- * @returns A rotation matrix.
- */
-export declare function lookAt(m: Matrix4, position: Vector3.Vector3, target: Vector3.Vector3, up: Vector3.Vector3): Matrix4;
-/**
- * Returns a post-multiplied matrix.
- */
-export declare function multiply(a: Matrix4, b: Matrix4): Matrix4;
-/**
- * Returns the [transpose](https://en.wikipedia.org/wiki/Transpose) of the given
- * matrix.
- */
-export declare function transpose(matrix: Matrix4): Matrix4;
-/**
- * Multiplies the columns of a matrix by the given vector.
- */
-export declare function scale(matrix: Matrix4, scale: Vector3.Vector3): Matrix4;
-export declare function position(matrix: Matrix4, other: Matrix4): Matrix4;
-/**
- * Returns true if the matrix is an identity matrix.
- */
-export declare function isIdentity(matrix: Matrix4): boolean;
-/**
- * Returns an object representation of a `Matrix4`.
- */
-export declare function toObject(m: Matrix4): Matrix4AsObject;
-/**
- * A type guard to check if `obj` is of type `Matrix4`.
- */
-export declare function isType(obj: unknown): obj is Matrix4;

package/dist/cdn/plane.d.ts

@@ -1,51 +0,0 @@
-import * as Line3 from './line3';
-import * as Vector3 from './vector3';
-/**
- * A two dimensional surface in 3D space that extends indefinitely. Represented
- * as a direction normal and distance.
- */
-export interface Plane {
-    normal: Vector3.Vector3;
-    constant: number;
-}
-/**
- * Creates a new plane. Defaults to a normal of `[0,0,0]` and constant of `0`.
- *
- * @param values Values to assign to the plane.
- * @returns A new plane.
- */
-export declare function create(values?: Partial<Plane>): Plane;
-/**
- * Creates a plane from a normal and an arbitrary point on a plane.
- *
- * @param normal A normal.
- * @param point A point on the plane.
- * @returns A new plane.
- */
-export declare function fromNormalAndCoplanarPoint(normal: Vector3.Vector3, point: Vector3.Vector3): Plane;
-/**
- * Returns the perpendicular distance from the plane to the given point.
- *
- * @param plane The plane.
- * @param point The point to calculate distance from `plane`.
- * @returns A distance.
- */
-export declare function distanceToPoint(plane: Plane, point: Vector3.Vector3): number;
-/**
- * Returns the point where the line intersects with this plane. If the line does
- * not intersect, then `undefined` is returned. If the line is on the plane,
- * then the starting point of the line is returned.
- *
- * @param plane The plane to intersect.
- * @param line The line to intersect.
- * @returns An intersecting point on the plane and line.
- */
-export declare function intersectLine(plane: Plane, line: Line3.Line3): Vector3.Vector3 | undefined;
-/**
- * Projects the given `point` onto the given `plane`.
- *
- * @param plane The plane to project onto.
- * @param point The point to project.
- * @returns The projected point.
- */
-export declare function projectPoint(plane: Plane, point: Vector3.Vector3): Vector3.Vector3;

package/dist/cdn/point.d.ts

@@ -1,80 +0,0 @@
-import * as Angle from './angle';
-/**
- * A `Point` represents a cartesian coordinate with a horizontal and vertical
- * position or length.
- */
-export interface Point {
-    x: number;
-    y: number;
-}
-/**
- * Returns a new `Point` with the given horizontal and vertical position.
- */
-export declare function create(x?: number, y?: number): Point;
-/**
- * Converts a polar coordinate (length and angle) into a Cartesian coordinate.
- */
-export declare function polar(length: number, radians: Angle.Angle): Point;
-/**
- * Returns the distance between two points.
- */
-export declare function distance(a: Point, b: Point): number;
-/**
- * Returns a new `Point` where `b` is subtracted from `a`.
- */
-export declare function subtract(a: Point, b: Point): Point;
-/**
- * Returns a new `Point` where `b` is added to `a`.
- */
-export declare function add(a: Point, b: Point): Point;
-/**
- * Returns `true` if the `x` and `y` positions of `a` and `b` are equal.
- */
-export declare function isEqual(a: Point, b: Point): boolean;
-/**
- * Performs a linear interpolation between `a` and `b` and returns the result.
- * The value of `t` is clamped between `[0, 1]`.
- *
- * @param a The start value.
- * @param b The end value.
- * @param t A value between 0 and 1.
- * @returns A point between `a` and `b`.
- */
-export declare function lerp(a: Point, b: Point, t: number): Point;
-/**
- * Returns a new `Point` where `x` and `y` are inverted.
- */
-export declare function negate(pt: Point): Point;
-/**
- * Returns a new `Point` where `x` and `y` are multiplied by the given scale
- * factors.
- */
-export declare function scale(pt: Point, scaleX: number, scaleY: number): Point;
-/**
- * Returns a new `Point` where `x` and `y` are multiplied by the given scale
- * factor.
- */
-export declare function scaleProportional(pt: Point, scale: number): Point;
-/**
- * Returns the magnitude of a point.
- */
-export declare function magnitude(pt: Point): number;
-/**
- * Transforms a vector into the corresponding normal (unit) vector.
- */
-export declare function normalizeVector(pt: Point): Point;
-/**
- * Returns a new normal (unit) vector pointing between the two given points.
- */
-export declare function normalDirectionVector(ptA: Point, ptB: Point): Point;
-/**
- * Returns a vector orthogonal to the vector between the two given points.
- */
-export declare function orthogonalVector(ptA: Point, ptB: Point): Point;
-/**
- * Parses a JSON string representation of a Point and returns an object.
- *
- * @param json A JSON string, either in the form `[x,y]` or `{"x": 0, "y": 0}`
- * @returns A parsed Point.
- */
-export declare function fromJson(json: string): Point;

package/dist/cdn/quaternion.d.ts

@@ -1,65 +0,0 @@
-import * as Euler from './euler';
-import * as Matrix4 from './matrix4';
-import * as Vector3 from './vector3';
-/**
- * A type that represents a
- * [quaternion](http://en.wikipedia.org/wiki/Quaternion). Quaternions are used
- * in 3D graphics to represent
- * [rotations](https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation).
- */
-export interface Quaternion {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}
-/**
- * An array representation of a `Quaternion`.
- */
-export declare type QuaternionAsArray = [x: number, y: number, z: number, w: number];
-/**
- * Returns a new quaternion. If `value` is undefined, then `{x: 0, y: 0, z: 0,
- * w: 1}` is returned.
- */
-export declare function create(value?: Partial<Quaternion>): Quaternion;
-/**
- * Parses a JSON string representation of a `Quaternion`.
- *
- * @param json A JSON string either in the form of `[x, y, z, w]` or `{"x": 0, "y": 0, "z": 0, "w": 0}`.
- * @returns A parsed `Quaternion`.
- */
-export declare function fromJson(json: string): Quaternion;
-/**
- * Returns a quaternion with that will have a magnitude of 1.
- */
-export declare function normalize(q: Quaternion): Quaternion;
-/**
- * Returns the magnitude of the provided quaternion.
- */
-export declare function magnitude(q: Quaternion): number;
-/**
- * Returns a quaternion where each component is multiplied by the `scalar`.
- */
-export declare function scale(scalar: number, q: Quaternion): Quaternion;
-/**
- * Creates a `Quaternion` that is rotated the given radians around an axis.
- *
- * @param axis The axis to rotate around.
- * @param radians The rotation, in radians.
- * @returns A rotated quaternion.
- */
-export declare function fromAxisAngle(axis: Vector3.Vector3, radians: number): Quaternion;
-/**
- * Returns a quaternion using the upper 3x3 of a pure rotation matrix
- * (unscaled).
- */
-export declare function fromMatrixRotation(matrix: Matrix4.Matrix4): Quaternion;
-export declare function fromEuler(euler: Euler.Euler): Quaternion;
-/**
- * Multiplies `a` x `b` and returns a new quaternion with the result.
- */
-export declare function multiply(a: Quaternion, b: Quaternion): Quaternion;
-/**
- * Type guard that checks if the given type is a Quaternion.
- */
-export declare function isType(obj: unknown): obj is Quaternion;

package/dist/cdn/ray.d.ts

@@ -1,52 +0,0 @@
-import * as Plane from './plane';
-import * as Vector3 from './vector3';
-/**
- * A `Ray` represents an infinite line starting at `origin` and going in
- * `direction`.
- */
-export interface Ray {
-    /**
-     * The origin point of the ray.
-     */
-    origin: Vector3.Vector3;
-    /**
-     * A normal that describes the direction of the ray from origin.
-     */
-    direction: Vector3.Vector3;
-}
-/**
- * Creates a new ray with the given values, or using default values if none are
- * provided. The direction defaults to `{x: 0, y: 0, z: -1}` if undefined.
- *
- * @param value The values of the ray.
- * @returns A new ray.
- */
-export declare function create(value?: Partial<Ray>): Ray;
-/**
- * Returns a point at the given distance along this ray.
- *
- * @param ray The ray to get the point on.
- * @param distance A distance from origin along the ray's direction.
- * @returns A point on the ray.
- */
-export declare function at(ray: Ray, distance: number): Vector3.Vector3;
-/**
- * Computes the distance of the `ray`s origin to the given `plane`. Returns a
- * distance of 0 if the ray is coplanar and returns `undefined` if the ray does
- * not intersect with the plane.
- *
- * @param ray The ray to get the distance for.
- * @param plane The plane to compute the distance to.
- * @returns The distance to the plane, or `undefined` if it cannot be computed.
- */
-export declare function distanceToPlane(ray: Ray, plane: Plane.Plane): number | undefined;
-/**
- * Computes the intersection point of the given `ray` to the given `plane`. If
- * the ray does not intersect with the plane, then `undefined` is returned.
- *
- * @param ray The ray to intersect.
- * @param plane The plane to intersect with.
- * @returns The intersection point, or `undefined` if the ray does not
- * intersect.
- */
-export declare function intersectPlane(ray: Ray, plane: Plane.Plane): Vector3.Vector3 | undefined;

package/dist/cdn/rectangle.d.ts

@@ -1,125 +0,0 @@
-import * as Dimensions from './dimensions';
-import * as Point from './point';
-/**
- * A `Rectangle` is an object with position and size.
- */
-export interface Rectangle {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/**
- * Returns a new `Rectangle` with the given position and size.
- */
-export declare function create(x: number, y: number, width: number, height: number): Rectangle;
-/**
- * Returns a new `Rectangle` at the origin point and given size.
- */
-export declare function fromDimensions(dimensions: Dimensions.Dimensions): Rectangle;
-/**
- * Returns a new `Rectangle` with the given position and size.
- */
-export declare function fromPointAndDimensions(point: Point.Point, dimensions: Dimensions.Dimensions): Rectangle;
-/**
- * Returns a new `Rectangle` with the given top-left and bottom-right positions.
- * The returned rectangle will always returns a positive width and height.
- */
-export declare function fromPoints(topLeftPt: Point.Point, bottomRightPt: Point.Point): Rectangle;
-/**
- * Returns a rectangle where the longest length of `rect` will be equal to the
- * shortest length of `to`. The shortest length of `rect` will be proportionally
- * scaled to match the aspect ratio of `rect`. The returned rectangle will be
- * centered within `to`.
- *
- * @see {@link cropFit}
- */
-export declare function containFit(to: Rectangle, rect: Rectangle): Rectangle;
-/**
- * Returns a rectangle where the shortest length of `rect` will be equal to the
- * longest length of `to`. The longest length of `rect` will be proportionally
- * scaled to match the aspect ratio of `rect`. The returned rectangle will be
- * centered within `to`.
- *
- * @see {@link containFit}
- */
-export declare function cropFit(to: Rectangle, rect: Rectangle): Rectangle;
-/**
- * Returns a rectangle where each side of `rect` will be reduced proportionally
- * to have an area less than or equal to the provided `to` value. The returned
- * rectangle will be centered within the original bounds of `rect`.
- *
- * @param to - the maximum area this rectangle can have
- * @param rect - the rectangle to scale to fit the specified area
- */
-export declare function scaleFit(to: number, rect: Rectangle): Rectangle;
-/**
- * Returns a rectangle where the position and dimensions are scaled by the given
- * factors. If `scaleY` is omitted, then the position and dimensions are scaled
- * uniformly by `scaleOrScaleX`.
- *
- * @param rect The rectangle to scale.
- * @param scaleOrScaleX The uniform scale factor, or the horizontal scale
- *  factor.
- * @param scaleY The vertical scale factor.
- * @returns A scaled rectangle.
- */
-export declare function scale(rect: Rectangle, scaleOrScaleX: number, scaleY?: number): Rectangle;
-/**
- * Returns true if two rectangles are equal in position and size.
- */
-export declare function isEqual(a: Rectangle, b: Rectangle): boolean;
-/**
- * Returns a rectangle that has its position shifted by a given offset. The
- * size of the rectangle is unchanged.
- */
-export declare function offset(delta: Point.Point, rect: Rectangle): Rectangle;
-/**
- * Returns the area of the rectangle.
- */
-export declare function area(rect: Rectangle): number;
-/**
- * Returns the center point of the rectangle.
- */
-export declare function center(rect: Rectangle): Point.Point;
-/**
- * Returns the top-left position of the rectangle, as a point.
- */
-export declare function topLeft(rect: Rectangle): Point.Point;
-/**
- * Returns the bottom-right position of the rectangle, as a point.
- */
-export declare function bottomRight(rect: Rectangle): Point.Point;
-/**
- * Returns `true` if the given rectangle has a portrait aspect ratio.
- */
-export declare function isPortrait(rect: Rectangle): boolean;
-/**
- * Returns `true` if the given rectangle has a landscape aspect ratio.
- */
-export declare function isLandscape(rect: Rectangle): boolean;
-/**
- * Returns `true` if the given rectangle has a square aspect ratio.
- */
-export declare function isSquare(rect: Rectangle): boolean;
-/**
- * Pads a rectangle by the given amount, maintaining the center position.
- *
- * @param rect The rectangle to apply padding to.
- * @param padding The padding to add.
- */
-export declare function pad(rect: Rectangle, padding: number): Rectangle;
-/**
- * Returns `true` if the given rectangle contains all the given `points`.
- *
- * @param rect The rectangle to check against.
- * @param points The points to check.
- */
-export declare function containsPoints(rect: Rectangle, ...points: Point.Point[]): boolean;
-/**
- * Parses a JSON string representation of a Rectangle and returns an object.
- *
- * @param json A JSON string, either in the form `[x,y,width,height]` or `{"x": 0, "y": 0, "width": 10, "height": 10}`
- * @returns A parsed Point.
- */
-export declare function fromJson(json: string): Rectangle;