@math.gl/core 3.5.6 → 3.6.0-alpha.1

package/dist/classes/base/math-array.d.ts

@@ -0,0 +1,36 @@
+export default class MathArray extends Array<any> {
+    constructor(arrayLength?: number);
+    constructor(arrayLength: number);
+    constructor(...items: any[]);
+    get ELEMENTS(): number;
+    clone(): any;
+    from(arrayOrObject: any): any;
+    fromArray(array: any, offset?: number): MathArray;
+    to(arrayOrObject: any): any;
+    toTarget(target: any): any;
+    toArray(array?: any[], offset?: number): any[];
+    toFloat32Array(): Float32Array;
+    formatString(opts: any): string;
+    equals(array: any): boolean;
+    exactEquals(array: any): boolean;
+    negate(): MathArray;
+    lerp(a: any, b: any, t: any): MathArray;
+    min(vector: any): MathArray;
+    max(vector: any): MathArray;
+    clamp(minVector: any, maxVector: any): MathArray;
+    add(...vectors: any[]): MathArray;
+    subtract(...vectors: any[]): MathArray;
+    scale(scale: any): any;
+    sub(a: any): MathArray;
+    setScalar(a: any): MathArray;
+    addScalar(a: any): MathArray;
+    subScalar(a: any): MathArray;
+    multiplyScalar(scalar: any): MathArray;
+    divideScalar(a: any): any;
+    clampScalar(min: any, max: any): MathArray;
+    multiplyByScalar(scalar: any): any;
+    get elements(): MathArray;
+    check(): MathArray;
+    validate(): boolean;
+}
+//# sourceMappingURL=math-array.d.ts.map

package/dist/classes/base/math-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math-array.d.ts","sourceRoot":"","sources":["../../../src/classes/base/math-array.js"],"names":[],"mappings":"AAuBA;IAmOgh3D,kCAAuC;IAAA,iCAAwC;IAAA,6BAAkC;IAjO/n3D,uBAGC;IAED,aAGC;IAED,8BAGC;IAED,kDAKC;IAED,4BAMC;IAED,2BAEC;IAED,+CAKC;IAED,+BAEC;IAMD,gCAMC;IAED,4BAUC;IAED,iCAUC;IAID,oBAKC;IAED,wCAWC;IAED,4BAKC;IAED,4BAKC;IAED,iDAKC;IAED,kCAOC;IAED,uCAOC;IAED,uBASC;IAID,uBAEC;IAED,6BAKC;IAED,6BAKC;IAED,6BAEC;IAED,uCAOC;IAED,0BAEC;IAED,2CAKC;IAID,mCAEC;IAGD,0BAEC;IAID,mBAKC;IAED,oBAMC;CACF"}

package/dist/classes/base/math-array.js

@@ -0,0 +1,214 @@
+// Copyright (c) 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+import { config, formatValue, equals, isArray } from '../../lib/common';
+import assert from '../../lib/assert';
+export default class MathArray extends Array {
+    // Defined by derived class
+    get ELEMENTS() {
+        assert(false);
+        return 0;
+    }
+    clone() {
+        // @ts-ignore error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
+        return new this.constructor().copy(this);
+    }
+    from(arrayOrObject) {
+        // @ts-ignore error TS2339: Property 'copy' does not exist on type 'MathArray'.
+        return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+    }
+    fromArray(array, offset = 0) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = array[i + offset];
+        }
+        return this.check();
+    }
+    to(arrayOrObject) {
+        if (arrayOrObject === this) {
+            return this;
+        }
+        // @ts-ignore error TS2339: Property 'toObject' does not exist on type 'MathArray'.
+        return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
+    }
+    toTarget(target) {
+        return target ? this.to(target) : this;
+    }
+    toArray(array = [], offset = 0) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            array[offset + i] = this[i];
+        }
+        return array;
+    }
+    toFloat32Array() {
+        return new Float32Array(this);
+    }
+    toString() {
+        return this.formatString(config);
+    }
+    formatString(opts) {
+        let string = '';
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            string += (i > 0 ? ', ' : '') + formatValue(this[i], opts);
+        }
+        return `${opts.printTypes ? this.constructor.name : ''}[${string}]`;
+    }
+    equals(array) {
+        if (!array || this.length !== array.length) {
+            return false;
+        }
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            if (!equals(this[i], array[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    exactEquals(array) {
+        if (!array || this.length !== array.length) {
+            return false;
+        }
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            if (this[i] !== array[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Modifiers
+    negate() {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = -this[i];
+        }
+        return this.check();
+    }
+    lerp(a, b, t) {
+        if (t === undefined) {
+            t = b;
+            b = a;
+            a = this; // eslint-disable-line
+        }
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            const ai = a[i];
+            this[i] = ai + t * (b[i] - ai);
+        }
+        return this.check();
+    }
+    min(vector) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.min(vector[i], this[i]);
+        }
+        return this.check();
+    }
+    max(vector) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.max(vector[i], this[i]);
+        }
+        return this.check();
+    }
+    clamp(minVector, maxVector) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);
+        }
+        return this.check();
+    }
+    add(...vectors) {
+        for (const vector of vectors) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] += vector[i];
+            }
+        }
+        return this.check();
+    }
+    subtract(...vectors) {
+        for (const vector of vectors) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] -= vector[i];
+            }
+        }
+        return this.check();
+    }
+    scale(scale) {
+        if (Array.isArray(scale)) {
+            // @ts-ignore error TS2339: Property 'multiply' does not exist on type 'MathArray'.
+            return this.multiply(scale);
+        }
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] *= scale;
+        }
+        return this.check();
+    }
+    // three.js compatibility
+    sub(a) {
+        return this.subtract(a);
+    }
+    setScalar(a) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = a;
+        }
+        return this.check();
+    }
+    addScalar(a) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] += a;
+        }
+        return this.check();
+    }
+    subScalar(a) {
+        return this.addScalar(-a);
+    }
+    multiplyScalar(scalar) {
+        // Multiplies all elements
+        // `Matrix4.scale` only scales its 3x3 "minor"
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] *= scalar;
+        }
+        return this.check();
+    }
+    divideScalar(a) {
+        return this.scale(1 / a);
+    }
+    clampScalar(min, max) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.min(Math.max(this[i], min), max);
+        }
+        return this.check();
+    }
+    // Cesium compatibility
+    multiplyByScalar(scalar) {
+        return this.scale(scalar);
+    }
+    // THREE.js compatibility
+    get elements() {
+        return this;
+    }
+    // Debug checks
+    check() {
+        if (config.debug && !this.validate()) {
+            throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
+        }
+        return this;
+    }
+    validate() {
+        let valid = this.length === this.ELEMENTS;
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            valid = valid && Number.isFinite(this[i]);
+        }
+        return valid;
+    }
+}

package/dist/classes/base/matrix.d.ts

@@ -0,0 +1,12 @@
+export default class Matrix extends MathArray<any> {
+    constructor(arrayLength: number);
+    constructor(...items: number[]);
+    get RANK(): number;
+    getElementIndex(row: any, col: any): any;
+    getElement(row: any, col: any): number;
+    setElement(row: any, col: any, value: any): Matrix;
+    getColumn(columnIndex: any, result?: any[]): any[];
+    setColumn(columnIndex: any, columnVector: any): Matrix;
+}
+import MathArray from "./math-array";
+//# sourceMappingURL=matrix.d.ts.map

package/dist/classes/base/matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../src/classes/base/matrix.js"],"names":[],"mappings":"AAKA;IAyE8u/D,iCAAwC;IAAA,gCAAkC;IAlEtz/D,mBAGC;IAgCD,yCAEC;IAGD,uCAEC;IAGD,mDAGC;IAED,mDAMC;IAED,uDAMC;CACF"}

package/dist/classes/base/matrix.js

@@ -0,0 +1,69 @@
+import MathArray from './math-array';
+import { checkNumber } from '../../lib/validators';
+import { config } from '../../lib/common';
+import assert from '../../lib/assert';
+export default class Matrix extends MathArray {
+    // Defined by derived class
+    get ELEMENTS() {
+        assert(false);
+        return 0;
+    }
+    get RANK() {
+        assert(false);
+        return 0;
+    }
+    // fromObject(object) {
+    //   const array = object.elements;
+    //   return this.fromRowMajor(array);
+    // }
+    // toObject(object) {
+    //   const array = object.elements;
+    //   this.toRowMajor(array);
+    //   return object;
+    // }
+    toString() {
+        let string = '[';
+        if (config.printRowMajor) {
+            string += 'row-major:';
+            for (let row = 0; row < this.RANK; ++row) {
+                for (let col = 0; col < this.RANK; ++col) {
+                    string += ` ${this[col * this.RANK + row]}`;
+                }
+            }
+        }
+        else {
+            string += 'column-major:';
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                string += ` ${this[i]}`;
+            }
+        }
+        string += ']';
+        return string;
+    }
+    getElementIndex(row, col) {
+        return col * this.RANK + row;
+    }
+    // By default assumes row major indices
+    getElement(row, col) {
+        return this[col * this.RANK + row];
+    }
+    // By default assumes row major indices
+    setElement(row, col, value) {
+        this[col * this.RANK + row] = checkNumber(value);
+        return this;
+    }
+    getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {
+        const firstIndex = columnIndex * this.RANK;
+        for (let i = 0; i < this.RANK; ++i) {
+            result[i] = this[firstIndex + i];
+        }
+        return result;
+    }
+    setColumn(columnIndex, columnVector) {
+        const firstIndex = columnIndex * this.RANK;
+        for (let i = 0; i < this.RANK; ++i) {
+            this[firstIndex + i] = columnVector[i];
+        }
+        return this;
+    }
+}

package/dist/classes/base/vector.d.ts

@@ -0,0 +1,32 @@
+export default class Vector extends MathArray<any> {
+    constructor(arrayLength: number);
+    constructor(...items: number[]);
+    copy(vector: any): Vector;
+    set x(arg: any);
+    get x(): any;
+    0: any;
+    set y(arg: any);
+    get y(): any;
+    1: any;
+    len(): number;
+    magnitude(): number;
+    lengthSquared(): number;
+    magnitudeSquared(): number;
+    distance(mathArray: any): number;
+    distanceSquared(mathArray: any): any;
+    dot(mathArray: any): any;
+    normalize(): any;
+    multiply(...vectors: any[]): any;
+    divide(...vectors: any[]): any;
+    lengthSq(): number;
+    distanceTo(vector: any): number;
+    distanceToSquared(vector: any): any;
+    getComponent(i: any): any;
+    setComponent(i: any, value: any): any;
+    addVectors(a: any, b: any): any;
+    subVectors(a: any, b: any): any;
+    multiplyVectors(a: any, b: any): any;
+    addScaledVector(a: any, b: any): any;
+}
+import MathArray from "./math-array";
+//# sourceMappingURL=vector.d.ts.map

package/dist/classes/base/vector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/classes/base/vector.js"],"names":[],"mappings":"AAIA;IA4Jm78D,iCAAwC;IAAA,gCAAkC;IArJ3/8D,0BAGC;IAOD,gBAEC;IALD,aAEC;IAEC,OAA4B;IAM9B,gBAEC;IALD,aAEC;IAEC,OAA4B;IAK9B,cAEC;IAED,oBAEC;IAED,wBAMC;IAED,2BAEC;IAED,iCAEC;IAED,qCAOC;IAED,yBAMC;IAID,iBAQC;IAgBD,iCAOC;IAED,+BAOC;IAGD,mBAEC;IAED,gCAEC;IAED,oCAEC;IAED,0BAGC;IAED,sCAIC;IAED,gCAEC;IAED,gCAEC;IAED,qCAEC;IAED,qCAGC;CACF"}

package/dist/classes/base/vector.js

@@ -0,0 +1,133 @@
+import MathArray from './math-array';
+import { checkNumber } from '../../lib/validators';
+import assert from '../../lib/assert';
+export default class Vector extends MathArray {
+    get ELEMENTS() {
+        assert(false);
+        return 0;
+    }
+    // VIRTUAL METHODS
+    copy(vector) {
+        assert(false);
+        return this;
+    }
+    // ACCESSORS
+    get x() {
+        return this[0];
+    }
+    set x(value) {
+        this[0] = checkNumber(value);
+    }
+    get y() {
+        return this[1];
+    }
+    set y(value) {
+        this[1] = checkNumber(value);
+    }
+    // NOTE: `length` is a reserved word for Arrays, so we can't use `v.length()`
+    // Offer `len` and `magnitude`
+    len() {
+        return Math.sqrt(this.lengthSquared());
+    }
+    magnitude() {
+        return this.len();
+    }
+    lengthSquared() {
+        let length = 0;
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            length += this[i] * this[i];
+        }
+        return length;
+    }
+    magnitudeSquared() {
+        return this.lengthSquared();
+    }
+    distance(mathArray) {
+        return Math.sqrt(this.distanceSquared(mathArray));
+    }
+    distanceSquared(mathArray) {
+        let length = 0;
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            const dist = this[i] - mathArray[i];
+            length += dist * dist;
+        }
+        return checkNumber(length);
+    }
+    dot(mathArray) {
+        let product = 0;
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            product += this[i] * mathArray[i];
+        }
+        return checkNumber(product);
+    }
+    // MODIFIERS
+    normalize() {
+        const length = this.magnitude();
+        if (length !== 0) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] /= length;
+            }
+        }
+        return this.check();
+    }
+    // negate() {
+    //   for (let i = 0; i < this.ELEMENTS; ++i) {
+    //     this[i] = -this[i];
+    //   }
+    //   return this.check();
+    // }
+    // inverse() {
+    //   for (let i = 0; i < this.ELEMENTS; ++i) {
+    //     this[i] = 1 / this[i];
+    //   }
+    //   return this.check();
+    // }
+    multiply(...vectors) {
+        for (const vector of vectors) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] *= vector[i];
+            }
+        }
+        return this.check();
+    }
+    divide(...vectors) {
+        for (const vector of vectors) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] /= vector[i];
+            }
+        }
+        return this.check();
+    }
+    // THREE.js compatibility
+    lengthSq() {
+        return this.lengthSquared();
+    }
+    distanceTo(vector) {
+        return this.distance(vector);
+    }
+    distanceToSquared(vector) {
+        return this.distanceSquared(vector);
+    }
+    getComponent(i) {
+        assert(i >= 0 && i < this.ELEMENTS, 'index is out of range');
+        return checkNumber(this[i]);
+    }
+    setComponent(i, value) {
+        assert(i >= 0 && i < this.ELEMENTS, 'index is out of range');
+        this[i] = value;
+        return this.check();
+    }
+    addVectors(a, b) {
+        return this.copy(a).add(b);
+    }
+    subVectors(a, b) {
+        return this.copy(a).subtract(b);
+    }
+    multiplyVectors(a, b) {
+        return this.copy(a).multiply(b);
+    }
+    addScaledVector(a, b) {
+        // @ts-ignore error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
+        return this.add(new this.constructor(a).multiplyScalar(b));
+    }
+}

package/dist/classes/euler.d.ts

@@ -0,0 +1,73 @@
+export default class Euler extends MathArray<any> {
+    static get ZYX(): number;
+    static get YXZ(): number;
+    static get XZY(): number;
+    static get ZXY(): number;
+    static get YZX(): number;
+    static get XYZ(): number;
+    static get RollPitchYaw(): number;
+    static get DefaultOrder(): number;
+    static get RotationOrders(): string[];
+    static rotationOrder(order: any): string;
+    /**
+     * @class
+     * @param {Number | Number[]} x
+     * @param {Number=} [y]
+     * @param {Number=} [z]
+     * @param {Number=} [order]
+     */
+    constructor(x?: number | number[], y?: number | undefined, z?: number | undefined, order?: number | undefined, ...args: any[]);
+    fromQuaternion(quaternion: any): Euler;
+    copy(array: any): any;
+    0: any;
+    1: any;
+    2: any;
+    3: any;
+    set(x: number, y: number, z: number, order: any): any;
+    validate(): boolean;
+    toArray4(array?: any[], offset?: number): any[];
+    toVector3(result?: number[]): number[];
+    set x(arg: number);
+    /** @type {number} */
+    get x(): number;
+    set y(arg: number);
+    /** @type {number} */
+    get y(): number;
+    set z(arg: number);
+    /** @type {number} */
+    get z(): number;
+    set alpha(arg: any);
+    get alpha(): any;
+    set beta(arg: any);
+    get beta(): any;
+    set gamma(arg: any);
+    get gamma(): any;
+    set phi(arg: any);
+    get phi(): any;
+    set theta(arg: any);
+    get theta(): any;
+    set psi(arg: any);
+    get psi(): any;
+    set roll(arg: number);
+    /** @type {number} */
+    get roll(): number;
+    set pitch(arg: number);
+    /** @type {number} */
+    get pitch(): number;
+    set yaw(arg: number);
+    /** @type {number} */
+    get yaw(): number;
+    set order(arg: any);
+    get order(): any;
+    fromVector3(v: any, order: any): any;
+    fromRollPitchYaw(roll: any, pitch: any, yaw: any): any;
+    fromRotationMatrix(m: any, order?: number): any;
+    getRotationMatrix(m: any): any;
+    getQuaternion(): Quaternion;
+    _fromRotationMatrix(m: any, order?: number): Euler;
+    _getRotationMatrix(result: any): any;
+    toQuaternion(): Quaternion;
+}
+import MathArray from "./base/math-array";
+import Quaternion from "./quaternion";
+//# sourceMappingURL=euler.d.ts.map

package/dist/classes/euler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"euler.d.ts","sourceRoot":"","sources":["../../src/classes/euler.js"],"names":[],"mappings":"AAwCA;IAYE,yBAEC;IAED,yBAEC;IAED,yBAEC;IAED,yBAEC;IAED,yBAEC;IAED,yBAEC;IAED,kCAEC;IAED,kCAEC;IAED,sCAEC;IAED,yCAEC;IAQD;;;;;;OAMG;IACH,gBALW,SAAS,QAAQ,8FAgB3B;IAED,uCAiBC;IAQD,sBAMC;IALC,OAAkB;IAClB,OAAkB;IAClB,OAAkB;IAClB,OAAiD;IAMnD,sDAMC;IAED,oBAOC;IAWD,gDAMC;IAED,uCAKC;IAUD,mBAEC;IAPD,qBAAqB;IACrB,gBAEC;IAWD,mBAEC;IAPD,qBAAqB;IACrB,gBAEC;IAWD,mBAEC;IAPD,qBAAqB;IACrB,gBAEC;IAWD,oBAEC;IAND,iBAEC;IAUD,mBAEC;IAND,gBAEC;IAUD,oBAEC;IAND,iBAEC;IAWD,kBAEC;IAND,eAEC;IAUD,oBAEC;IAND,iBAEC;IAUD,kBAEC;IAND,eAEC;IAYD,sBAEC;IAPD,qBAAqB;IACrB,mBAEC;IAWD,uBAEC;IAPD,qBAAqB;IACrB,oBAEC;IAWD,qBAEC;IAPD,qBAAqB;IACrB,kBAEC;IAWD,oBAEC;IAND,iBAEC;IASD,qCAEC;IAcD,uDAEC;IAED,gDAGC;IAID,+BAEC;IAGD,4BAkBC;IAaD,mDAgGC;IAED,qCAsJC;IAED,2BAeC;CACF"}