@math.gl/core 3.6.1 → 3.6.2

package/dist/classes/quaternion.js

@@ -1,262 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-// MIT License
-import MathArray from './base/math-array';
-import { checkNumber, checkVector } from '../lib/validators';
-import Vector4 from './vector4';
-import * as quat from 'gl-matrix/quat';
-import * as vec4 from 'gl-matrix/vec4';
-const IDENTITY_QUATERNION = [0, 0, 0, 1];
-export default class Quaternion extends MathArray {
-    constructor(x = 0, y = 0, z = 0, w = 1) {
-        // PERF NOTE: initialize elements as double precision numbers
-        super(-0, -0, -0, -0);
-        // eslint-disable-next-line prefer-rest-params
-        if (Array.isArray(x) && arguments.length === 1) {
-            this.copy(x);
-        }
-        else {
-            this.set(x, y, z, w);
-        }
-    }
-    copy(array) {
-        this[0] = array[0];
-        this[1] = array[1];
-        this[2] = array[2];
-        this[3] = array[3];
-        return this.check();
-    }
-    set(x, y, z, w) {
-        this[0] = x;
-        this[1] = y;
-        this[2] = z;
-        this[3] = w;
-        return this.check();
-    }
-    fromObject(object) {
-        this[0] = object.x;
-        this[1] = object.y;
-        this[2] = object.z;
-        this[3] = object.w;
-        return this.check();
-    }
-    /**
-     * 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.
-     * @param m
-     * @returns
-     */
-    fromMatrix3(m) {
-        quat.fromMat3(this, m);
-        return this.check();
-    }
-    fromAxisRotation(axis, rad) {
-        quat.setAxisAngle(this, axis, rad);
-        return this.check();
-    }
-    /** Set a quat to the identity quaternion */
-    identity() {
-        quat.identity(this);
-        return this.check();
-    }
-    // Set the components of a quat to the given values
-    // set(i, j, k, l) {
-    //   quat.set(this, i, j, k, l);
-    //   return this.check();
-    // }
-    // Sets a quat from the given angle and rotation axis, then returns it.
-    setAxisAngle(axis, rad) {
-        return this.fromAxisRotation(axis, rad);
-    }
-    // Getters/setters
-    get ELEMENTS() {
-        return 4;
-    }
-    get x() {
-        return this[0];
-    }
-    set x(value) {
-        this[0] = checkNumber(value);
-    }
-    get y() {
-        return this[1];
-    }
-    set y(value) {
-        this[1] = checkNumber(value);
-    }
-    get z() {
-        return this[2];
-    }
-    set z(value) {
-        this[2] = checkNumber(value);
-    }
-    get w() {
-        return this[3];
-    }
-    set w(value) {
-        this[3] = checkNumber(value);
-    }
-    // Calculates the length of a quat
-    len() {
-        return quat.length(this);
-    }
-    // Calculates the squared length of a quat
-    lengthSquared() {
-        return quat.squaredLength(this);
-    }
-    // Calculates the dot product of two quat's
-    // @return {Number}
-    dot(a) {
-        return quat.dot(this, a);
-    }
-    // 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.
-    // @return {{[x,y,z], Number}}
-    // getAxisAngle() {
-    //   const axis = [];
-    //   const angle = quat.getAxisAngle(axis, this);
-    //   return {axis, angle};
-    // }
-    // MODIFIERS
-    // Sets a quaternion to represent the shortest rotation from one vector
-    // to another. Both vectors are assumed to be unit length.
-    rotationTo(vectorA, vectorB) {
-        quat.rotationTo(this, vectorA, vectorB);
-        return this.check();
-    }
-    // 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.
-    // setAxes() {
-    //   Number
-    // }
-    // Performs a spherical linear interpolation with two control points
-    // sqlerp() {
-    //   Number;
-    // }
-    // Adds two quat's
-    add(a) {
-        quat.add(this, this, a);
-        return this.check();
-    }
-    // Calculates the W component of a quat from the X, Y, and Z components.
-    // Any existing W component will be ignored.
-    calculateW() {
-        quat.calculateW(this, this);
-        return this.check();
-    }
-    // Calculates the conjugate of a quat If the quaternion is normalized,
-    // this function is faster than quat.inverse and produces the same result.
-    conjugate() {
-        quat.conjugate(this, this);
-        return this.check();
-    }
-    // Calculates the inverse of a quat
-    invert() {
-        quat.invert(this, this);
-        return this.check();
-    }
-    // Performs a linear interpolation between two quat's
-    lerp(a, b, t) {
-        if (t === undefined) {
-            return this.lerp(this, a, b);
-        }
-        quat.lerp(this, a, b, t);
-        return this.check();
-    }
-    // Multiplies two quat's
-    multiplyRight(a) {
-        quat.multiply(this, this, a);
-        return this.check();
-    }
-    multiplyLeft(a) {
-        quat.multiply(this, a, this);
-        return this.check();
-    }
-    // Normalize a quat
-    normalize() {
-        // Handle 0 case
-        const length = this.len();
-        const l = length > 0 ? 1 / length : 0;
-        this[0] = this[0] * l;
-        this[1] = this[1] * l;
-        this[2] = this[2] * l;
-        this[3] = this[3] * l;
-        // Set to [0, 0, 0, 1] if length is 0
-        if (length === 0) {
-            this[3] = 1;
-        }
-        return this.check();
-    }
-    // Rotates a quaternion by the given angle about the X axis
-    rotateX(rad) {
-        quat.rotateX(this, this, rad);
-        return this.check();
-    }
-    // Rotates a quaternion by the given angle about the Y axis
-    rotateY(rad) {
-        quat.rotateY(this, this, rad);
-        return this.check();
-    }
-    // Rotates a quaternion by the given angle about the Z axis
-    rotateZ(rad) {
-        quat.rotateZ(this, this, rad);
-        return this.check();
-    }
-    // Scales a quat by a scalar number
-    scale(b) {
-        quat.scale(this, this, b);
-        return this.check();
-    }
-    // Performs a spherical linear interpolation between two quat
-    slerp(arg0, arg1, arg2) {
-        let start;
-        let target;
-        let ratio;
-        // eslint-disable-next-line prefer-rest-params
-        switch (arguments.length) {
-            case 1: // Deprecated signature ({start, target, ratio})
-                // eslint-disable-next-line prefer-rest-params
-                ({
-                    start = IDENTITY_QUATERNION,
-                    target,
-                    ratio
-                } = arg0);
-                break;
-            case 2: // THREE.js compatibility signature (target, ration)
-                start = this; // eslint-disable-line
-                target = arg0;
-                ratio = arg1;
-                break;
-            default:
-                // Default signature: (start, target, ratio)
-                start = arg0;
-                target = arg1;
-                ratio = arg2;
-        }
-        quat.slerp(this, start, target, ratio);
-        return this.check();
-    }
-    transformVector4(vector, result = new Vector4()) {
-        vec4.transformQuat(result, vector, this);
-        return checkVector(result, 4);
-    }
-    // THREE.js Math API compatibility
-    lengthSq() {
-        return this.lengthSquared();
-    }
-    setFromAxisAngle(axis, rad) {
-        return this.setAxisAngle(axis, rad);
-    }
-    premultiply(a) {
-        return this.multiplyLeft(a);
-    }
-    multiply(a) {
-        return this.multiplyRight(a);
-    }
-}

package/dist/classes/spherical-coordinates.js

@@ -1,148 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-// MIT License
-// Adaptation of THREE.js Spherical class, under MIT license
-import Vector3 from './vector3';
-import { formatValue, equals, config } from '../lib/common';
-import { degrees, radians, clamp } from '../lib/common';
-import * as vec3 from 'gl-matrix/vec3';
-// TODO - import epsilon
-const EPSILON = 0.000001;
-const EARTH_RADIUS_METERS = 6371000;
-/**
- * The poles (phi) are at the positive and negative y axis.
- * The equator starts at positive z.
- * @link https://en.wikipedia.org/wiki/Spherical_coordinate_system
- */
-export default class SphericalCoordinates {
-    // bearing: number;
-    // pitch: number;
-    // altitude: number;
-    // lnglatZ coordinates
-    // longitude: number;
-    // latitude: number;
-    // lng: number;
-    // lat: number;
-    // z: number;
-    /**
-     * Creates a new SphericalCoordinates object
-     * @param options
-     * @param [options.phi] =0 - rotation around X (latitude)
-     * @param [options.theta] =0 - rotation around Y (longitude)
-     * @param [options.radius] =1 - Distance from center
-     * @param [options.bearing]
-     * @param [options.pitch]
-     * @param [options.altitude]
-     * @param [options.radiusScale] =1
-     */
-    // eslint-disable-next-line complexity
-    constructor({ phi = 0, theta = 0, radius = 1, bearing, pitch, altitude, radiusScale = EARTH_RADIUS_METERS } = {}) {
-        this.phi = phi;
-        this.theta = theta;
-        // TODO - silently accepts illegal 0
-        this.radius = radius || altitude || 1; // radial distance from center
-        this.radiusScale = radiusScale || 1; // Used by lngLatZ
-        if (bearing !== undefined) {
-            this.bearing = bearing; // up / down towards top and bottom pole
-        }
-        if (pitch !== undefined) {
-            this.pitch = pitch; // around the equator of the sphere
-        }
-        this.check();
-    }
-    toString() {
-        return this.formatString(config);
-    }
-    formatString({ printTypes = false }) {
-        const f = formatValue;
-        return `${printTypes ? 'Spherical' : ''}\
-[rho:${f(this.radius)},theta:${f(this.theta)},phi:${f(this.phi)}]`;
-    }
-    equals(other) {
-        return (equals(this.radius, other.radius) &&
-            equals(this.theta, other.theta) &&
-            equals(this.phi, other.phi));
-    }
-    exactEquals(other) {
-        return this.radius === other.radius && this.theta === other.theta && this.phi === other.phi;
-    }
-    /* eslint-disable brace-style */
-    // Cartographic (bearing 0 north, pitch 0 look from above)
-    get bearing() {
-        return 180 - degrees(this.phi);
-    }
-    set bearing(v) {
-        this.phi = Math.PI - radians(v);
-    }
-    get pitch() {
-        return degrees(this.theta);
-    }
-    set pitch(v) {
-        this.theta = radians(v);
-    }
-    // get pitch() { return 90 - degrees(this.phi); }
-    // set pitch(v) { this.phi = radians(v) + Math.PI / 2; }
-    // get altitude() { return this.radius - 1; } // relative altitude
-    // lnglatZ coordinates
-    get longitude() {
-        return degrees(this.phi);
-    }
-    get latitude() {
-        return degrees(this.theta);
-    }
-    get lng() {
-        return degrees(this.phi);
-    }
-    get lat() {
-        return degrees(this.theta);
-    }
-    get z() {
-        return (this.radius - 1) * this.radiusScale;
-    }
-    /* eslint-enable brace-style */
-    set(radius, phi, theta) {
-        this.radius = radius;
-        this.phi = phi;
-        this.theta = theta;
-        return this.check();
-    }
-    clone() {
-        return new SphericalCoordinates().copy(this);
-    }
-    copy(other) {
-        this.radius = other.radius;
-        this.phi = other.phi;
-        this.theta = other.theta;
-        return this.check();
-    }
-    fromLngLatZ([lng, lat, z]) {
-        this.radius = 1 + z / this.radiusScale;
-        this.phi = radians(lat);
-        this.theta = radians(lng);
-        return this.check();
-    }
-    fromVector3(v) {
-        this.radius = vec3.length(v);
-        if (this.radius > 0) {
-            this.theta = Math.atan2(v[0], v[1]); // equator angle around y-up axis
-            this.phi = Math.acos(clamp(v[2] / this.radius, -1, 1)); // polar angle
-        }
-        return this.check();
-    }
-    toVector3() {
-        return new Vector3(0, 0, this.radius)
-            .rotateX({ radians: this.theta })
-            .rotateZ({ radians: this.phi });
-    }
-    // restrict phi to be betwee EPS and PI-EPS
-    makeSafe() {
-        this.phi = Math.max(EPSILON, Math.min(Math.PI - EPSILON, this.phi));
-        return this;
-    }
-    check() {
-        // this.makeSafe();
-        if (!Number.isFinite(this.phi) || !Number.isFinite(this.theta) || !(this.radius > 0)) {
-            throw new Error('SphericalCoordinates: some fields set to invalid numbers');
-        }
-        return this;
-    }
-}

package/dist/classes/vector2.js

@@ -1,111 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-// MIT License
-import Vector from './base/vector';
-import { config, isArray } from '../lib/common';
-import { checkNumber } from '../lib/validators';
-import * as vec2 from 'gl-matrix/vec2';
-/* eslint-disable camelcase */
-import { vec2_transformMat4AsVector } from '../lib/gl-matrix-extras';
-/**
- * Two-element vector class.
- * Subclass of Array<number>
- */
-export default class Vector2 extends Vector {
-    // Creates a new, empty vec2
-    constructor(x = 0, y = 0) {
-        // PERF NOTE: initialize elements as double precision numbers
-        super(2); // -0, -0);
-        if (isArray(x) && arguments.length === 1) {
-            this.copy(x);
-        }
-        else {
-            if (config.debug) {
-                checkNumber(x);
-                checkNumber(y);
-            }
-            this[0] = x;
-            this[1] = y;
-        }
-    }
-    set(x, y) {
-        this[0] = x;
-        this[1] = y;
-        return this.check();
-    }
-    copy(array) {
-        this[0] = array[0];
-        this[1] = array[1];
-        return this.check();
-    }
-    fromObject(object) {
-        if (config.debug) {
-            checkNumber(object.x);
-            checkNumber(object.y);
-        }
-        this[0] = object.x;
-        this[1] = object.y;
-        return this.check();
-    }
-    toObject(object) {
-        object.x = this[0];
-        object.y = this[1];
-        return object;
-    }
-    // Getters/setters
-    get ELEMENTS() {
-        return 2;
-    }
-    /**
-     * Returns angle from x axis
-     * @returns
-     */
-    horizontalAngle() {
-        return Math.atan2(this.y, this.x);
-    }
-    /**
-     * Returns angle from y axis
-     * @returns
-     */
-    verticalAngle() {
-        return Math.atan2(this.x, this.y);
-    }
-    // Transforms
-    /**
-     * Transforms as point
-     * @param matrix4
-     * @returns
-     */
-    transform(matrix4) {
-        return this.transformAsPoint(matrix4);
-    }
-    /**
-     * transforms as point (4th component is implicitly 1)
-     * @param matrix4
-     * @returns
-     */
-    transformAsPoint(matrix4) {
-        vec2.transformMat4(this, this, matrix4);
-        return this.check();
-    }
-    /**
-     * transforms as vector (4th component is implicitly 0, ignores translation. slightly faster)
-     * @param matrix4
-     * @returns
-     */
-    transformAsVector(matrix4) {
-        vec2_transformMat4AsVector(this, this, matrix4);
-        return this.check();
-    }
-    transformByMatrix3(matrix3) {
-        vec2.transformMat3(this, this, matrix3);
-        return this.check();
-    }
-    transformByMatrix2x3(matrix2x3) {
-        vec2.transformMat2d(this, this, matrix2x3);
-        return this.check();
-    }
-    transformByMatrix2(matrix2) {
-        vec2.transformMat2(this, this, matrix2);
-        return this.check();
-    }
-}

package/dist/classes/vector3.js

@@ -1,133 +0,0 @@
-import Vector from './base/vector';
-import { config, isArray } from '../lib/common';
-import { checkNumber } from '../lib/validators';
-import * as vec3 from 'gl-matrix/vec3';
-/* eslint-disable camelcase */
-import { vec3_transformMat2, vec3_transformMat4AsVector } from '../lib/gl-matrix-extras';
-const ORIGIN = [0, 0, 0];
-let ZERO;
-/**
- * Three-element vector class.
- * Subclass of Array<number>
- */
-export default class Vector3 extends Vector {
-    static get ZERO() {
-        if (!ZERO) {
-            ZERO = new Vector3(0, 0, 0);
-            Object.freeze(ZERO);
-        }
-        return ZERO;
-    }
-    /**
-     * @class
-     * @param x
-     * @param y
-     * @param z
-     */
-    constructor(x = 0, y = 0, z = 0) {
-        // PERF NOTE: initialize elements as double precision numbers
-        super(-0, -0, -0);
-        if (arguments.length === 1 && isArray(x)) {
-            this.copy(x);
-        }
-        else {
-            // this.set(x, y, z);
-            if (config.debug) {
-                checkNumber(x);
-                checkNumber(y);
-                checkNumber(z);
-            }
-            // @ts-expect-error TS2412: Property '0' of type 'number | [number, number, number]' is not assignable to numeric index type 'number'
-            this[0] = x;
-            this[1] = y;
-            this[2] = z;
-        }
-    }
-    set(x, y, z) {
-        this[0] = x;
-        this[1] = y;
-        this[2] = z;
-        return this.check();
-    }
-    copy(array) {
-        this[0] = array[0];
-        this[1] = array[1];
-        this[2] = array[2];
-        return this.check();
-    }
-    fromObject(object) {
-        if (config.debug) {
-            checkNumber(object.x);
-            checkNumber(object.y);
-            checkNumber(object.z);
-        }
-        this[0] = object.x;
-        this[1] = object.y;
-        this[2] = object.z;
-        return this.check();
-    }
-    toObject(object) {
-        object.x = this[0];
-        object.y = this[1];
-        object.z = this[2];
-        return object;
-    }
-    // Getters/setters
-    get ELEMENTS() {
-        return 3;
-    }
-    get z() {
-        return this[2];
-    }
-    set z(value) {
-        this[2] = checkNumber(value);
-    }
-    // ACCESSORS
-    angle(vector) {
-        return vec3.angle(this, vector);
-    }
-    // MODIFIERS
-    cross(vector) {
-        vec3.cross(this, this, vector);
-        return this.check();
-    }
-    rotateX({ radians, origin = ORIGIN }) {
-        vec3.rotateX(this, this, origin, radians);
-        return this.check();
-    }
-    rotateY({ radians, origin = ORIGIN }) {
-        vec3.rotateY(this, this, origin, radians);
-        return this.check();
-    }
-    rotateZ({ radians, origin = ORIGIN }) {
-        vec3.rotateZ(this, this, origin, radians);
-        return this.check();
-    }
-    // Transforms
-    // transforms as point (4th component is implicitly 1)
-    transform(matrix4) {
-        return this.transformAsPoint(matrix4);
-    }
-    // transforms as point (4th component is implicitly 1)
-    transformAsPoint(matrix4) {
-        vec3.transformMat4(this, this, matrix4);
-        return this.check();
-    }
-    // transforms as vector  (4th component is implicitly 0, ignores translation. slightly faster)
-    transformAsVector(matrix4) {
-        vec3_transformMat4AsVector(this, this, matrix4);
-        return this.check();
-    }
-    transformByMatrix3(matrix3) {
-        vec3.transformMat3(this, this, matrix3);
-        return this.check();
-    }
-    transformByMatrix2(matrix2) {
-        vec3_transformMat2(this, this, matrix2);
-        return this.check();
-    }
-    transformByQuaternion(quaternion) {
-        vec3.transformQuat(this, this, quaternion);
-        return this.check();
-    }
-}