linearly 0.20.2 → 0.20.3

package/lib/quat.js

@@ -0,0 +1,514 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./common", "./vec3", "./vec4"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.setAxes = exports.sqlerp = exports.rotationTo = exports.equals = exports.exactEquals = exports.normalize = exports.sqrLen = exports.squaredLength = exports.len = exports.length = exports.lerp = exports.dot = exports.scale = exports.add = exports.fromEuler = exports.fromMat3 = exports.conjugate = exports.invert = exports.slerp = exports.pow = exports.ln = exports.exp = exports.calculateW = exports.rotateZ = exports.rotateY = exports.rotateX = exports.multiply = exports.getAngle = exports.getAxisAngle = exports.setAxisAngle = exports.identity = void 0;
+    const Common = __importStar(require("./common"));
+    const vec3 = __importStar(require("./vec3"));
+    const vec4 = __importStar(require("./vec4"));
+    /**
+     * Quaternion in the format XYZW
+     * @module quat
+     */
+    /**
+     * The identity quaternion
+     */
+    exports.identity = Object.freeze([0, 0, 0, 1]);
+    /**
+     * Sets a quat from the given angle and rotation axis,
+     * then returns it.
+     *
+     * @param axis the axis around which to rotate
+     * @param rad the angle in radians
+     **/
+    function setAxisAngle(axis, rad) {
+        rad = rad * 0.5;
+        const s = Math.sin(rad);
+        return [s * axis[0], s * axis[1], s * axis[2], Math.cos(rad)];
+    }
+    exports.setAxisAngle = setAxisAngle;
+    /**
+     * Gets the rotation axis and angle for a given
+     *  quaternion. If a quaternion is created with
+     *  setAxisAngle, this method will return the same
+     *  values as providied in the original parameter list
+     *  OR functionally equivalent values.
+     * Example: The quaternion formed by axis [0, 0, 1] and
+     *  angle -90 is the same as the quaternion formed by
+     *  [0, 0, 1] and 270. This method favors the latter.
+     *
+     * @param  q Quaternion to be decomposed
+     */
+    function getAxisAngle(q) {
+        const rad = Math.acos(q[3]) * 2;
+        const s = Math.sin(rad / 2);
+        let axis;
+        if (s > Common.EPSILON) {
+            axis = [q[0] / s, q[1] / s, q[2] / s];
+        }
+        else {
+            // If s is zero, return any axis (no rotation - axis does not matter)
+            axis = [1, 0, 0];
+        }
+        return { axis, rad };
+    }
+    exports.getAxisAngle = getAxisAngle;
+    /**
+     * Gets the angular distance between two unit quaternions
+     *
+     * @param  a     Origin unit quaternion
+     * @param  b     Destination unit quaternion
+     * @return  Angle, in radians, between the two quaternions
+     */
+    function getAngle(a, b) {
+        const dotproduct = (0, exports.dot)(a, b);
+        return Math.acos(2 * dotproduct * dotproduct - 1);
+    }
+    exports.getAngle = getAngle;
+    /**
+     * Multiplies two quat's
+     *
+     * @param a the first operand
+     * @param b the second operand
+     */
+    function multiply(a, b) {
+        const [ax, ay, az, aw] = a;
+        const [bx, by, bz, bw] = b;
+        return [
+            ax * bw + aw * bx + ay * bz - az * by,
+            ay * bw + aw * by + az * bx - ax * bz,
+            az * bw + aw * bz + ax * by - ay * bx,
+            aw * bw - ax * bx - ay * by - az * bz,
+        ];
+    }
+    exports.multiply = multiply;
+    /**
+     * Rotates a quaternion by the given angle about the X axis
+     *
+     * @param a quat to rotate
+     * @param rad angle (in radians) to rotate
+     */
+    function rotateX(a, rad) {
+        rad *= 0.5;
+        const ax = a[0], ay = a[1], az = a[2], aw = a[3];
+        const bx = Math.sin(rad), bw = Math.cos(rad);
+        return [
+            ax * bw + aw * bx,
+            ay * bw + az * bx,
+            az * bw - ay * bx,
+            aw * bw - ax * bx,
+        ];
+    }
+    exports.rotateX = rotateX;
+    /**
+     * Rotates a quaternion by the given angle about the Y axis
+     *
+     * @param a quat to rotate
+     * @param rad angle (in radians) to rotate
+     */
+    function rotateY(a, rad) {
+        rad *= 0.5;
+        const ax = a[0], ay = a[1], az = a[2], aw = a[3];
+        const by = Math.sin(rad), bw = Math.cos(rad);
+        return [
+            ax * bw - az * by,
+            ay * bw + aw * by,
+            az * bw + ax * by,
+            aw * bw - ay * by,
+        ];
+    }
+    exports.rotateY = rotateY;
+    /**
+     * Rotates a quaternion by the given angle about the Z axis
+     *
+     * @param a quat to rotate
+     * @param rad angle (in radians) to rotate
+     */
+    function rotateZ(a, rad) {
+        rad *= 0.5;
+        const ax = a[0], ay = a[1], az = a[2], aw = a[3];
+        const bz = Math.sin(rad), bw = Math.cos(rad);
+        return [
+            ax * bw + ay * bz,
+            ay * bw - ax * bz,
+            az * bw + aw * bz,
+            aw * bw - az * bz,
+        ];
+    }
+    exports.rotateZ = rotateZ;
+    /**
+     * Calculates the W component of a quat from the X, Y, and Z components.
+     * Assumes that quaternion is 1 unit in length.
+     * Any existing W component will be ignored.
+     */
+    function calculateW(a) {
+        const [x, y, z] = a;
+        return [x, y, z, Math.sqrt(Math.abs(1 - x * x - y * y - z * z))];
+    }
+    exports.calculateW = calculateW;
+    /**
+     * Calculate the exponential of a unit quaternion.
+     */
+    function exp(a) {
+        const [x, y, z, w] = a;
+        const r = Math.sqrt(x * x + y * y + z * z);
+        const et = Math.exp(w);
+        const s = r > 0 ? (et * Math.sin(r)) / r : 0;
+        return [x * s, y * s, z * s, et * Math.cos(r)];
+    }
+    exports.exp = exp;
+    /**
+     * Calculate the natural logarithm of a unit quaternion.
+     */
+    function ln(a) {
+        const [x, y, z, w] = a;
+        const r = Math.sqrt(x * x + y * y + z * z);
+        const t = r > 0 ? Math.atan2(r, w) / r : 0;
+        return [x * t, y * t, z * t, 0.5 * Math.log(x * x + y * y + z * z + w * w)];
+    }
+    exports.ln = ln;
+    /**
+     * Calculate the scalar power of a unit quaternion.
+     */
+    function pow(a, b) {
+        return exp((0, exports.scale)(ln(a), b));
+    }
+    exports.pow = pow;
+    /**
+     * Performs a spherical linear interpolation between two quat
+     *
+     * @param a the first operand
+     * @param b the second operand
+     * @param t interpolation amount, in the range [0-1], between the two inputs
+     */
+    function slerp(a, b, t) {
+        // benchmarks:
+        //    http://jsperf.com/quaternion-slerp-implementations
+        const [ax, ay, az, aw] = a;
+        let [bx, by, bz, bw] = b;
+        let omega, cosom, sinom, scale0, scale1;
+        // calc cosine
+        cosom = ax * bx + ay * by + az * bz + aw * bw;
+        // adjust signs (if necessary)
+        if (cosom < 0) {
+            cosom *= -1;
+            bx *= -1;
+            by *= -1;
+            bz *= -1;
+            bw *= -1;
+        }
+        // calculate coefficients
+        if (1 - cosom > Common.EPSILON) {
+            // standard case (slerp)
+            omega = Math.acos(cosom);
+            sinom = Math.sin(omega);
+            scale0 = Math.sin((1 - t) * omega) / sinom;
+            scale1 = Math.sin(t * omega) / sinom;
+        }
+        else {
+            // "from" and "to" quaternions are very close
+            //  ... so we can do a linear interpolation
+            scale0 = 1 - t;
+            scale1 = t;
+        }
+        // calculate final values
+        return [
+            scale0 * ax + scale1 * bx,
+            scale0 * ay + scale1 * by,
+            scale0 * az + scale1 * bz,
+            scale0 * aw + scale1 * bw,
+        ];
+    }
+    exports.slerp = slerp;
+    /**
+     * Calculates the inverse of a quat
+     */
+    function invert(a) {
+        const a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
+        const dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;
+        const invDot = dot ? 1 / dot : 0;
+        // TODO: Would be faster to return [0,0,0,0] immediately if dot == 0
+        return [-a0 * invDot, -a1 * invDot, -a2 * invDot, a3 * invDot];
+    }
+    exports.invert = invert;
+    /**
+     * Calculates the conjugate of a quat
+     * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.
+     */
+    function conjugate(a) {
+        return [-a[0], -a[1], -a[2], a[3]];
+    }
+    exports.conjugate = conjugate;
+    /**
+     * Creates a quaternion from the given 3x3 rotation matrix.
+     *
+     * NOTE: The resultant quaternion is not normalized, so you should be sure
+     * to renormalize the quaternion yourself where necessary.
+     */
+    function fromMat3(m) {
+        // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
+        // article "Quaternion Calculus and Fast Animation".
+        const fTrace = m[0] + m[4] + m[8];
+        let fRoot;
+        const out = [0, 0, 0, 0];
+        if (fTrace > 0) {
+            // |w| > 1/2, may as well choose w > 1/2
+            fRoot = Math.sqrt(fTrace + 1); // 2w
+            out[3] = 0.5 * fRoot;
+            fRoot = 0.5 / fRoot; // 1/(4w)
+            out[0] = (m[5] - m[7]) * fRoot;
+            out[1] = (m[6] - m[2]) * fRoot;
+            out[2] = (m[1] - m[3]) * fRoot;
+        }
+        else {
+            // |w| <= 1/2
+            let i = 0;
+            if (m[4] > m[0])
+                i = 1;
+            if (m[8] > m[i * 3 + i])
+                i = 2;
+            const j = (i + 1) % 3;
+            const k = (i + 2) % 3;
+            fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1);
+            out[i] = 0.5 * fRoot;
+            fRoot = 0.5 / fRoot;
+            out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;
+            out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;
+            out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;
+        }
+        return out;
+    }
+    exports.fromMat3 = fromMat3;
+    /**
+     * Creates a quaternion from the given euler angle x, y, z using the provided intrinsic order for the conversion.
+     *
+     * @param x Angle to rotate around X axis in degrees.
+     * @param y Angle to rotate around Y axis in degrees.
+     * @param z Angle to rotate around Z axis in degrees.
+     * @param order Intrinsic order for conversion, default is zyx.
+     * @function
+     */
+    function fromEuler(x, y, z, order = Common.DEFAULT_ANGLE_ORDER) {
+        const halfToRad = Math.PI / 360;
+        x *= halfToRad;
+        z *= halfToRad;
+        y *= halfToRad;
+        const sx = Math.sin(x);
+        const cx = Math.cos(x);
+        const sy = Math.sin(y);
+        const cy = Math.cos(y);
+        const sz = Math.sin(z);
+        const cz = Math.cos(z);
+        switch (order) {
+            case 'xyz':
+                return [
+                    sx * cy * cz + cx * sy * sz,
+                    cx * sy * cz - sx * cy * sz,
+                    cx * cy * sz + sx * sy * cz,
+                    cx * cy * cz - sx * sy * sz,
+                ];
+            case 'xzy':
+                return [
+                    sx * cy * cz - cx * sy * sz,
+                    cx * sy * cz - sx * cy * sz,
+                    cx * cy * sz + sx * sy * cz,
+                    cx * cy * cz + sx * sy * sz,
+                ];
+            case 'yxz':
+                return [
+                    sx * cy * cz + cx * sy * sz,
+                    cx * sy * cz - sx * cy * sz,
+                    cx * cy * sz - sx * sy * cz,
+                    cx * cy * cz + sx * sy * sz,
+                ];
+            case 'yzx':
+                return [
+                    sx * cy * cz + cx * sy * sz,
+                    cx * sy * cz + sx * cy * sz,
+                    cx * cy * sz - sx * sy * cz,
+                    cx * cy * cz - sx * sy * sz,
+                ];
+            case 'zxy':
+                return [
+                    sx * cy * cz - cx * sy * sz,
+                    cx * sy * cz + sx * cy * sz,
+                    cx * cy * sz + sx * sy * cz,
+                    cx * cy * cz - sx * sy * sz,
+                ];
+            case 'zyx':
+                return [
+                    sx * cy * cz - cx * sy * sz,
+                    cx * sy * cz + sx * cy * sz,
+                    cx * cy * sz - sx * sy * cz,
+                    cx * cy * cz + sx * sy * sz,
+                ];
+        }
+    }
+    exports.fromEuler = fromEuler;
+    /**
+     * Adds two quat's
+     */
+    exports.add = vec4.add;
+    /**
+     * Scales a quat by a scalar number
+     */
+    exports.scale = vec4.scale;
+    /**
+     * Calculates the dot product of two quat's
+     */
+    exports.dot = vec4.dot;
+    /**
+     * Performs a linear interpolation between two quat's
+     *
+     * @param a the first operand
+     * @param b the second operand
+     * @param t interpolation amount, in the range [0-1], between the two inputs
+     */
+    exports.lerp = vec4.lerp;
+    /**
+     * Calculates the length of a quat
+     *
+     * @param a vector to calculate length of
+     * @returns length of a
+     */
+    exports.length = vec4.length;
+    /**
+     * Alias for {@link quat.length}
+     * @function
+     */
+    exports.len = exports.length;
+    /**
+     * Calculates the squared length of a quat
+     *
+     * @param a vector to calculate squared length of
+     * @returns squared length of a
+     * @function
+     */
+    exports.squaredLength = vec4.squaredLength;
+    /**
+     * Alias for {@link quat.squaredLength}
+     * @function
+     */
+    exports.sqrLen = exports.squaredLength;
+    /**
+     * Normalize a quat
+     *
+     * @param a quaternion to normalize
+     */
+    exports.normalize = vec4.normalize;
+    /**
+     * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)
+     */
+    exports.exactEquals = vec4.exactEquals;
+    /**
+     * Returns whether or not the quaternions point approximately to the same direction.
+     *
+     * Both quaternions are assumed to be unit length.
+     */
+    function equals(a, b) {
+        return Math.abs(vec4.dot(a, b)) >= 1 - Common.EPSILON;
+    }
+    exports.equals = equals;
+    /**
+     * Sets a quaternion to represent the shortest rotation from one
+     * vector to another.
+     *
+     * Both vectors are assumed to be unit length.
+     *
+     * @param a the initial vector
+     * @param b the destination vector
+     */
+    exports.rotationTo = (function () {
+        const xUnitVec3 = [1, 0, 0];
+        const yUnitVec3 = [0, 1, 0];
+        return (a, b) => {
+            const dot = vec3.dot(a, b);
+            if (dot > 1 - Common.EPSILON) {
+                return exports.identity;
+            }
+            else if (dot < -1 + Common.EPSILON) {
+                let temp = vec3.cross(xUnitVec3, a);
+                if (vec3.length(temp) < 0.000001) {
+                    temp = vec3.cross(yUnitVec3, a);
+                }
+                temp = vec3.normalize(temp);
+                return setAxisAngle(temp, Math.PI);
+            }
+            else {
+                const tmp = vec3.cross(a, b);
+                const out = [tmp[0], tmp[1], tmp[2], 1 + dot];
+                return (0, exports.normalize)(out);
+            }
+        };
+    })();
+    /**
+     * Performs a spherical linear interpolation with two control points
+     *
+     * @param a the first operand
+     * @param b the second operand
+     * @param c the third operand
+     * @param d the fourth operand
+     * @param t interpolation amount, in the range [0-1], between the two inputs
+     */
+    function sqlerp(a, b, c, d, t) {
+        const temp1 = slerp(a, d, t);
+        const temp2 = slerp(b, c, t);
+        return slerp(temp1, temp2, 2 * t * (1 - t));
+    }
+    exports.sqlerp = sqlerp;
+    /**
+     * Sets the specified quaternion with values corresponding to the given
+     * axes. Each axis is a vec3 and is expected to be unit length and
+     * perpendicular to all other specified axes.
+     *
+     * @param view  the vector representing the viewing direction
+     * @param right the vector representing the local "right" direction
+     * @param up    the vector representing the local "up" direction
+     */
+    function setAxes(view, right, up) {
+        const matr = [
+            right[0],
+            up[0],
+            -view[0],
+            right[1],
+            up[1],
+            -view[1],
+            right[2],
+            up[2],
+            -view[2],
+        ];
+        return (0, exports.normalize)(fromMat3(matr));
+    }
+    exports.setAxes = setAxes;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quat.js","sourceRoot":"","sources":["../src/quat.ts"],"names":[],"mappings":"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"}

package/lib/vec2.d.ts

@@ -0,0 +1,64 @@
+import { Mat2 } from './mat2';
+import { Mat2d } from './mat2d';
+import { Mat3 } from './mat3';
+import { Vec3 } from './vec3';
+export type Vec2 = readonly [number, number];
+export declare const zero: Vec2;
+export declare const one: Vec2;
+export declare function add(a: Vec2, b: Vec2): Vec2;
+export declare function subtract(a: Vec2, b: Vec2): Vec2;
+export declare function multiply(a: Vec2, b: Vec2): Vec2;
+export declare function divide(a: Vec2, b: Vec2): Vec2;
+export declare function ceil(a: Vec2): Vec2;
+export declare function floor(a: Vec2): Vec2;
+export declare function min(a: Vec2, b: Vec2): Vec2;
+export declare function max(a: Vec2, b: Vec2): Vec2;
+/**
+ *  Constrain a value to lie between two further values
+ */
+export declare function clamp(a: Vec2, min: Vec2, max: Vec2): Vec2;
+/**
+ * symmetric round the components of a vec2
+ */
+export declare function round(a: Vec2): Vec2;
+export declare function scale(a: Vec2, s: number): Vec2;
+/**
+ * Adds two vec2's after scaling the second operand by a scalar value
+ */
+export declare function scaleAndAdd(a: Vec2, b: Vec2, scale: number): Vec2;
+export declare function distance(a: Vec2, b: Vec2): number;
+export declare function squaredDistance(a: Vec2, b: Vec2): number;
+export declare function length(v: Vec2): number;
+export declare function squaredLength(v: Vec2): number;
+export declare function negate(v: Vec2): Vec2;
+export declare function inverse(v: Vec2): Vec2;
+export declare function normalize(v: Vec2): Vec2;
+export declare function dot(a: Vec2, b: Vec2): number;
+export declare function cross(a: Vec2, b: Vec2): Vec3;
+/**
+ * Performs a linear interpolation between two Vec2's
+ */
+export declare function lerp(a: Vec2, b: Vec2, t: number): Vec2;
+export declare function transformMat2(a: Vec2, m: Mat2): Vec2;
+export declare function transformMat2d(a: Vec2, m: Mat2d): Vec2;
+/**
+ * Transforms the vec2 with a mat3
+ * 3rd vector component is implicitly '1'
+ */
+export declare function transformMat3(a: Vec2, m: Mat3): Vec2;
+/**
+ * Rotate a 2D vector
+ */
+export declare function rotate(a: Vec2, origin: Vec2, rad: number): Vec2;
+/**
+ * Get the angle between two 2D vectors
+ */
+export declare function angle(a: Vec2, b: Vec2): number;
+/**
+ * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
+ */
+export declare function exactEquals(a: Vec2, b: Vec2): boolean;
+/**
+ * Returns whether or not the vectors have approximately the same elements in the same position.
+ */
+export declare function equals(a: Vec2, b: Vec2): boolean;