@vertexvis/geometry 0.24.5 → 1.0.0-canary.0

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;

package/dist/cdn/vector3.d.ts

@@ -1,226 +0,0 @@
-import * as Euler from './euler';
-import * as Matrix4 from './matrix4';
-/**
- * A `Vector3` represents a vector of 3 dimensions values. It may represent a
- * point or direction.
- */
-export interface Vector3 {
-    x: number;
-    y: number;
-    z: number;
-}
-/**
- * A `Vector3` representation as an array.
- */
-export declare type Vector3AsArray = [x: number, y: number, z: number];
-/**
- * Returns a new `Vector3` either with the provided x, y, and z dimensions,
- * or from the provided `Partial<Vector3>` object populated with zeroes
- * wherever a component is missing.
- *
- * Providing no values to this function will result in a zero-length vector.
- */
-export declare function create(x: number, y: number, z: number): Vector3;
-export declare function create(partialVector: Partial<Vector3>): Vector3;
-export declare function create(): Vector3;
-/**
- * Checks if each component of the given vector is populated with a numeric
- * component. A component is invalid if it contains a non-finite or NaN value.
- */
-export declare function isValid({ x, y, z }: Vector3): boolean;
-/**
- * Returns a vector representing the scale elements of `matrix`.
- */
-export declare function fromMatrixScale(matrix: Matrix4.Matrix4): Vector3;
-/**
- * Returns a vector representing the position elements of `matrix`.
- */
-export declare function fromMatrixPosition(matrix: Matrix4.Matrix4): Vector3;
-/**
- * Parses a JSON string representation of a Vector3 and returns an object.
- *
- * @param json A JSON string, either in the form `[x,y,z]` or `{"x": 0, "y": 0, "z": 0}`
- * @returns A parsed Vector3.
- */
-export declare function fromJson(json: string): Vector3;
-/**
- * Creates a `Vector3` from an array. Pass `offset` to read values from the
- * starting index.
- *
- * @see #toArray()
- * @see #create()
- */
-export declare function fromArray(nums: number[], offset?: number): Vector3;
-/**
- * Converts a Vector3 to an array where the values of the vector will be
- * represented as [x, y, z];
- *
- * @see #fromArray()
- * @see #create()
- */
-export declare function toArray({ x, y, z }: Vector3): Vector3AsArray;
-/**
- * Returns a directional vector on the positive x axis, Vector3(1, 0, 0).
- */
-export declare function right(): Vector3;
-/**
- * Returns a directional vector on the positive y axis, Vector3(0, 1, 0).
- */
-export declare function up(): Vector3;
-/**
- * Returns a directional vector on the positive z axis, Vector3(0, 0, -1).
- */
-export declare function forward(): Vector3;
-/**
- * Returns a directional vector on the negative x axis, Vector3(-1, 0, 0).
- */
-export declare function left(): Vector3;
-/**
- * Returns a directional vector on the negative y axis, Vector3(0, -1, 0).
- */
-export declare function down(): Vector3;
-/**
- * Returns a directional vector on the negative z axis, Vector3(0, 0, 1).
- */
-export declare function back(): Vector3;
-/**
- * Returns a vector at the origin, Vector3(0, 0, 0).
- */
-export declare function origin(): Vector3;
-/**
- * Returns a vector with that will have a magnitude of 1.
- */
-export declare function normalize(vector: Vector3): Vector3;
-/**
- * Returns the straight-line length from (0, 0, 0) to the given vector.
- */
-export declare function magnitude(vector: Vector3): number;
-/**
- * Returns the straight-line length from (0, 0, 0) to the given vector).
- *
- * When comparing lengths of vectors, you should use this function as it's
- * slightly more efficient to calculate.
- */
-export declare function magnitudeSquared(vector: Vector3): number;
-/**
- * Returns a vector that is the cross product of two vectors.
- *
- * The cross product of two vectors results in a third vector which is
- * perpendicular to the two input vectors. The result's magnitude is equal to
- * the magnitudes of the two inputs multiplied together and then multiplied by
- * the sine of the angle between the inputs. You can determine the direction of
- * the result vector using the "left hand rule".
- */
-export declare function cross(a: Vector3, b: Vector3): Vector3;
-/**
- * Returns a vector that is the sum of two vectors.
- */
-export declare function add(a: Vector3, ...vectors: Vector3[]): Vector3;
-/**
- * Returns a vector that is the difference between two vectors.
- */
-export declare function subtract(a: Vector3, ...vectors: Vector3[]): Vector3;
-/**
- * Returns a vector that where each component of `b` is multiplied with `a`.
- */
-export declare function multiply(a: Vector3, b: Vector3): Vector3;
-/**
- * Returns a vector where each value of a vector is multiplied by the `scalar`.
- */
-export declare function scale(scalar: number, vector: Vector3): Vector3;
-/**
- * Returns a value representing the dot product of two vectors.
- *
- * The dot product is a float value equal to the magnitudes of the two vectors
- * multiplied together and then multiplied by the cosine of the angle between
- * them.
- */
-export declare function dot(a: Vector3, b: Vector3): number;
-/**
- * Returns the angle, in radians, between two vectors.
- *
- * The angle returned is the unsigned angle between the two vectors. This means
- * the smaller of the two possible angles between the two vectors is used. The
- * result is never greater than 180 degrees.
- */
-export declare function angleTo(a: Vector3, b: Vector3): number;
-/**
- * Returns the Euler angle, in radians with the `xyz` ordering, between two vectors.
- *
- * This method will normalize both vectors for the calculation, and uses the
- * algorithm described in https://www.xarg.org/proof/quaternion-from-two-vectors/.
- */
-export declare function eulerTo(a: Vector3, b: Vector3): Euler.Euler;
-/**
- * Performs a projection of a `vector` onto `onNormal`.
- *
- * A projection is represented as the nearest point along a normal to a vector,
- * which constructs a triangle from the origin, to the vector, to the projected
- * point.
- *
- * ```
- * Vector -->  *   * <-- Projected
- *              \
- *               \ | <-- Normal
- *                \|
- *                 * <-- Origin
- * ```
- */
-export declare function project(vector: Vector3, onNormal: Vector3): Vector3;
-/**
- * Returns a vector that is rotated about an origin point.
- *
- * @param angle The angle to rotate, in radians.
- * @param point The origin point to rotate around.
- * @param axisDirection The direction used to compute the axis.
- * @param axisPosition The point of the axis.
- */
-export declare function rotateAboutAxis(angle: number, point: Vector3, axisDirection: Vector3, axisPosition: Vector3): Vector3;
-/**
- * Returns a vector that is multiplied with a matrix.
- */
-export declare function transformMatrix(vector: Vector3, m: Matrix4.Matrix4): Vector3;
-/**
- * Euclidean distance between two vectors
- */
-export declare function distance(a: Vector3, b: Vector3): number;
-/**
- * Returns the squared distance between two vectors. If you're just comparing
- * distances, this is slightly more efficient than `distanceTo`.
- */
-export declare function distanceSquared(a: Vector3, b: Vector3): number;
-/**
- * Returns `true` if two vectors have the same values.
- */
-export declare function isEqual(a: Vector3, b: Vector3): boolean;
-/**
- * Returns a vector that contains the largest components of `a` and `b`.
- */
-export declare function max(a: Vector3, b: Vector3): Vector3;
-/**
- * Returns a vector that contains the smallest components of `a` and `b`.
- */
-export declare function min(a: Vector3, b: Vector3): Vector3;
-/**
- * Returns a vector that each of its component negated.
- */
-export declare function negate(vector: Vector3): Vector3;
-/**
- * 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: Vector3, b: Vector3, t: number): Vector3;
-/**
- * Maps a normalized device coordinate (NDC) space to world space coordinates.
- *
- * @param ndc A point in normalized device coordinates.
- * @param worldMatrix A camera's world matrix.
- * @param projectionMatrixInverse A camera's inverse projection matrix.
- * @returns A point in world space coordinates.
- */
-export declare function transformNdcToWorldSpace(ndc: Vector3, worldMatrix: Matrix4.Matrix4, projectionMatrixInverse: Matrix4.Matrix4): Vector3;

package/dist/cdn/vector4.d.ts

@@ -1,23 +0,0 @@
-/**
- * A `Vector4` represents a vector of 4 dimension values. It may represent a
- * point or direction. It may also be used to represent a quadruplet of values,
- * such as a row or column in a transformation matrix.
- */
-export interface Vector4 {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}
-/**
- * Returns a new Vector4. If `value` is undefined, then `{x: 0, y: 0, z: 0,
- * w: 0}` is returned.
- */
-export declare function create(value?: Partial<Vector4>): Vector4;
-/**
- * Parses a JSON string representation of a `Vector4`.
- *
- * @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 `Vector4`.
- */
-export declare function fromJson(json: string): Vector4;