@vertexvis/geometry 0.24.5-canary.6 → 1.0.0-testing.1

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;