@math.gl/core 3.6.3 → 4.0.0-alpha.2

package/src/classes/matrix3.ts

@@ -1,13 +1,24 @@
 // Copyright (c) 2017 Uber Technologies, Inc.
 // MIT License
-import Matrix from './base/matrix';
+
+import {NumericArray} from '@math.gl/types';
+import {Matrix} from './base/matrix';
 import {checkVector} from '../lib/validators';
-/* eslint-disable camelcase */
+
 import {vec4_transformMat3} from '../lib/gl-matrix-extras';
-import * as mat3 from 'gl-matrix/mat3';
-import * as vec2 from 'gl-matrix/vec2';
-import * as vec3 from 'gl-matrix/vec3';
-import {NumericArray} from '@math.gl/types';
+
+import {
+  fromQuat as mat3_fromQuat,
+  determinant as mat3_determinant,
+  transpose as mat3_transpose,
+  invert as mat3_invert,
+  multiply as mat3_multiply,
+  rotate as mat3_rotate,
+  scale as mat3_scale,
+  translate as mat3_translate
+} from '../gl-matrix/mat3';
+import {transformMat3 as vec2_transformMat3} from '../gl-matrix/vec2';
+import {transformMat3 as vec3_transformMat3} from '../gl-matrix/vec3';
 
 enum INDICES {
   COL0ROW0 = 0,
@@ -23,7 +34,7 @@ enum INDICES {
 
 const IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]);
 
-export default class Matrix3 extends Matrix {
+export class Matrix3 extends Matrix {
   static get IDENTITY(): Readonly<Matrix3> {
     return getIdentityMatrix();
   }
@@ -85,14 +96,16 @@ export default class Matrix3 extends Matrix {
    * @param object
    * @returns self
    */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   fromObject(object: {[key: string]: any}): this {
     return this.check();
   }
 
-  // Calculates a 3x3 matrix from the given quaternion
-  // q quat  Quaternion to create matrix from
+  /** Calculates a 3x3 matrix from the given quaternion
+   * q quat  Quaternion to create matrix from
+   */
   fromQuaternion(q: Readonly<NumericArray>): this {
-    mat3.fromQuat(this, q);
+    mat3_fromQuat(this, q);
     return this.check();
   }
 
@@ -153,48 +166,48 @@ export default class Matrix3 extends Matrix {
   // Accessors
 
   determinant(): number {
-    return mat3.determinant(this);
+    return mat3_determinant(this);
   }
 
   // Modifiers
   transpose(): this {
-    mat3.transpose(this, this);
+    mat3_transpose(this, this);
     return this.check();
   }
 
   /** Invert a matrix. Note that this can fail if the matrix is not invertible */
   invert(): this {
-    mat3.invert(this, this);
+    mat3_invert(this, this);
     return this.check();
   }
 
   // Operations
   multiplyLeft(a: NumericArray): this {
-    mat3.multiply(this, a, this);
+    mat3_multiply(this, a, this);
     return this.check();
   }
 
   multiplyRight(a: NumericArray): this {
-    mat3.multiply(this, this, a);
+    mat3_multiply(this, this, a);
     return this.check();
   }
 
   rotate(radians: number): NumericArray {
-    mat3.rotate(this, this, radians);
+    mat3_rotate(this, this, radians);
     return this.check();
   }
 
-  scale(factor: NumericArray | number): this {
+  override scale(factor: NumericArray | number): this {
     if (Array.isArray(factor)) {
-      mat3.scale(this, this, factor);
+      mat3_scale(this, this, factor);
     } else {
-      mat3.scale(this, this, [factor as number, factor as number]);
+      mat3_scale(this, this, [factor as number, factor as number]);
     }
     return this.check();
   }
 
   translate(vec: NumericArray): this {
-    mat3.translate(this, this, vec);
+    mat3_translate(this, this, vec);
     return this.check();
   }
 
@@ -203,10 +216,10 @@ export default class Matrix3 extends Matrix {
     let out: NumericArray;
     switch (vector.length) {
       case 2:
-        out = vec2.transformMat3(result || [-0, -0], vector, this);
+        out = vec2_transformMat3(result || [-0, -0], vector, this) as NumericArray;
         break;
       case 3:
-        out = vec3.transformMat3(result || [-0, -0, -0], vector, this);
+        out = vec3_transformMat3(result || [-0, -0, -0], vector, this) as NumericArray;
         break;
       case 4:
         out = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this);
@@ -234,8 +247,8 @@ export default class Matrix3 extends Matrix {
   }
 }
 
-let ZERO_MATRIX3;
-let IDENTITY_MATRIX3;
+let ZERO_MATRIX3: Matrix3 | null;
+let IDENTITY_MATRIX3: Matrix3 | null = null;
 
 function getZeroMatrix(): Readonly<Matrix3> {
   if (!ZERO_MATRIX3) {

package/src/classes/matrix4.ts

@@ -1,15 +1,33 @@
 // Copyright (c) 2017 Uber Technologies, Inc.
 // MIT License
-import Matrix from './base/matrix';
+
 import {NumericArray} from '@math.gl/types';
+import {Matrix} from './base/matrix';
 import {checkVector} from '../lib/validators';
 
 /* eslint-disable camelcase */
 import {vec2_transformMat4AsVector, vec3_transformMat4AsVector} from '../lib/gl-matrix-extras';
-import * as mat4 from 'gl-matrix/mat4';
-import * as vec2 from 'gl-matrix/vec2';
-import * as vec3 from 'gl-matrix/vec3';
-import * as vec4 from 'gl-matrix/vec4';
+// @ts-ignore gl-matrix types...
+import {
+  fromQuat as mat4_fromQuat,
+  frustum as mat4_frustum,
+  lookAt as mat4_lookAt,
+  ortho as mat4_ortho,
+  perspective as mat4_perspective,
+  determinant as mat4_determinant,
+  transpose as mat4_transpose,
+  invert as mat4_invert,
+  multiply as mat4_multiply,
+  rotateX as mat4_rotateX,
+  rotateY as mat4_rotateY,
+  rotateZ as mat4_rotateZ,
+  rotate as mat4_rotate,
+  scale as mat4_scale,
+  translate as mat4_translate
+} from '../gl-matrix/mat4';
+import {transformMat4 as vec2_transformMat4} from '../gl-matrix/vec2';
+import {transformMat4 as vec3_transformMat4} from '../gl-matrix/vec3';
+import {transformMat4 as vec4_transformMat4} from '../gl-matrix/vec3';
 
 enum INDICES {
   COL0ROW0 = 0,
@@ -38,7 +56,7 @@ const DEFAULT_FAR = 500;
 const IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 
 /** 4x4 matrix */
-export default class Matrix4 extends Matrix {
+export class Matrix4 extends Matrix {
   static get IDENTITY(): Readonly<Matrix4> {
     return getIdentityMatrix();
   }
@@ -198,6 +216,7 @@ export default class Matrix4 extends Matrix {
    * @param object
    * @returns self
    */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   fromObject(object: {[key: string]: any}): this {
     return this.check();
   }
@@ -208,7 +227,7 @@ export default class Matrix4 extends Matrix {
    * @returns self
    */
   fromQuaternion(quaternion: Readonly<NumericArray>): this {
-    mat4.fromQuat(this, quaternion);
+    mat4_fromQuat(this, quaternion);
     return this.check();
   }
 
@@ -234,7 +253,7 @@ export default class Matrix4 extends Matrix {
     if (far === Infinity) {
       computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
     } else {
-      mat4.frustum(this, left, right, bottom, top, near, far);
+      mat4_frustum(this, left, right, bottom, top, near, far);
     }
     return this.check();
   }
@@ -253,7 +272,7 @@ export default class Matrix4 extends Matrix {
     up?: Readonly<NumericArray>;
   }): this {
     const {eye, center = [0, 0, 0], up = [0, 1, 0]} = view;
-    mat4.lookAt(this, eye, center, up);
+    mat4_lookAt(this, eye, center, up);
     return this.check();
   }
 
@@ -277,7 +296,7 @@ export default class Matrix4 extends Matrix {
     far?: number;
   }): this {
     const {left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR} = view;
-    mat4.ortho(this, left, right, bottom, top, near, far);
+    mat4_ortho(this, left, right, bottom, top, near, far);
     return this.check();
   }
 
@@ -333,14 +352,14 @@ export default class Matrix4 extends Matrix {
   perspective(view: {fovy: number; aspect?: number; near?: number; far?: number}): this {
     const {fovy = (45 * Math.PI) / 180, aspect = 1, near = 0.1, far = 500} = view;
     checkRadians(fovy);
-    mat4.perspective(this, fovy, aspect, near, far);
+    mat4_perspective(this, fovy, aspect, near, far);
     return this.check();
   }
 
   // Accessors
 
   determinant(): number {
-    return mat4.determinant(this);
+    return mat4_determinant(this);
   }
 
   /**
@@ -432,38 +451,38 @@ export default class Matrix4 extends Matrix {
   // Modifiers
 
   transpose(): this {
-    mat4.transpose(this, this);
+    mat4_transpose(this, this);
     return this.check();
   }
 
   invert(): this {
-    mat4.invert(this, this);
+    mat4_invert(this, this);
     return this.check();
   }
 
   // Operations
 
   multiplyLeft(a: Readonly<NumericArray>): this {
-    mat4.multiply(this, a, this);
+    mat4_multiply(this, a, this);
     return this.check();
   }
 
   multiplyRight(a: Readonly<NumericArray>): this {
-    mat4.multiply(this, this, a);
+    mat4_multiply(this, this, a);
     return this.check();
   }
 
   // Rotates a matrix by the given angle around the X axis
   rotateX(radians: number): this {
-    mat4.rotateX(this, this, radians);
-    // mat4.rotate(this, this, radians, [1, 0, 0]);
+    mat4_rotateX(this, this, radians);
+    // mat4_rotate(this, this, radians, [1, 0, 0]);
     return this.check();
   }
 
   // Rotates a matrix by the given angle around the Y axis.
   rotateY(radians: number): this {
-    mat4.rotateY(this, this, radians);
-    // mat4.rotate(this, this, radians, [0, 1, 0]);
+    mat4_rotateY(this, this, radians);
+    // mat4_rotate(this, this, radians, [0, 1, 0]);
     return this.check();
   }
 
@@ -473,8 +492,8 @@ export default class Matrix4 extends Matrix {
    * @returns self
    */
   rotateZ(radians: number): this {
-    mat4.rotateZ(this, this, radians);
-    // mat4.rotate(this, this, radians, [0, 0, 1]);
+    mat4_rotateZ(this, this, radians);
+    // mat4_rotate(this, this, radians, [0, 0, 1]);
     return this.check();
   }
 
@@ -494,7 +513,7 @@ export default class Matrix4 extends Matrix {
    * @returns self
    */
   rotateAxis(radians: number, axis: Readonly<NumericArray>): this {
-    mat4.rotate(this, this, radians, axis);
+    mat4_rotate(this, this, radians, axis);
     return this.check();
   }
 
@@ -503,8 +522,8 @@ export default class Matrix4 extends Matrix {
    * @param factor
    * @returns self
    */
-  scale(factor: number | Readonly<NumericArray>): this {
-    mat4.scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
+  override scale(factor: number | Readonly<NumericArray>): this {
+    mat4_scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
     return this.check();
   }
 
@@ -514,7 +533,7 @@ export default class Matrix4 extends Matrix {
    * @returns self
    */
   translate(vector: Readonly<NumericArray>): this {
-    mat4.translate(this, this, vector);
+    mat4_translate(this, this, vector);
     return this.check();
   }
 
@@ -528,7 +547,7 @@ export default class Matrix4 extends Matrix {
    */
   transform(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray {
     if (vector.length === 4) {
-      result = vec4.transformMat4(result || [-0, -0, -0, -0], vector, this);
+      result = vec4_transformMat4(result || [-0, -0, -0, -0], vector, this) as NumericArray;
       checkVector(result, 4);
       return result;
     }
@@ -546,10 +565,10 @@ export default class Matrix4 extends Matrix {
     let out: NumericArray;
     switch (length) {
       case 2:
-        out = vec2.transformMat4(result || [-0, -0], vector, this);
+        out = vec2_transformMat4(result || [-0, -0], vector, this) as NumericArray;
         break;
       case 3:
-        out = vec3.transformMat4(result || [-0, -0, -0], vector, this);
+        out = vec3_transformMat4(result || [-0, -0, -0], vector, this) as NumericArray;
         break;
       default:
         throw new Error('Illegal vector');

package/src/classes/pose.ts

@@ -1,8 +1,8 @@
 // Copyright (c) 2017 Uber Technologies, Inc.
 // MIT License
-import Matrix4 from './matrix4';
-import Vector3 from './vector3';
-import Euler from './euler';
+import {Matrix4} from './matrix4';
+import {Vector3} from './vector3';
+import {Euler} from './euler';
 import {NumericArray} from '@math.gl/types';
 
 type PoseOptions = {
@@ -16,7 +16,7 @@ type PoseOptions = {
   yaw?: number;
 };
 
-export default class Pose {
+export class Pose {
   readonly position: Vector3;
   readonly orientation: Euler;
 

package/src/classes/quaternion.ts

@@ -1,15 +1,37 @@
 // 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';
 import {NumericArray} from '@math.gl/types';
+import {MathArray} from './base/math-array';
+import {checkNumber, checkVector} from '../lib/validators';
+import {Vector4} from './vector4';
+// @ts-ignore gl-matrix types...
+import {
+  fromMat3 as quat_fromMat3,
+  setAxisAngle as quat_setAxisAngle,
+  identity as quat_identity,
+  length as quat_length,
+  squaredLength as quat_squaredLength,
+  dot as quat_dot,
+  // getAxisAngle as quat_getAxisAngle,
+  rotationTo as quat_rotationTo,
+  add as quat_add,
+  calculateW as quat_calculateW,
+  conjugate as quat_conjugate,
+  invert as quat_invert,
+  lerp as quat_lerp,
+  multiply as quat_multiply,
+  rotateX as quat_rotateX,
+  rotateY as quat_rotateY,
+  rotateZ as quat_rotateZ,
+  scale as quat_scale,
+  slerp as quat_slerp
+} from '../gl-matrix/quat';
+// @ts-ignore gl-matrix types...
+import {transformQuat as vec4_transformQuat} from '../gl-matrix/vec4';
 
 const IDENTITY_QUATERNION = [0, 0, 0, 1] as const;
 
-export default class Quaternion extends MathArray {
+export class Quaternion extends MathArray {
   constructor(x: number | Readonly<NumericArray> = 0, y = 0, z = 0, w = 1) {
     // PERF NOTE: initialize elements as double precision numbers
     super(-0, -0, -0, -0);
@@ -53,24 +75,24 @@ export default class Quaternion extends MathArray {
    * @returns
    */
   fromMatrix3(m: Readonly<NumericArray>): this {
-    quat.fromMat3(this, m);
+    quat_fromMat3(this, m);
     return this.check();
   }
 
   fromAxisRotation(axis: Readonly<NumericArray>, rad: number): this {
-    quat.setAxisAngle(this, axis, rad);
+    quat_setAxisAngle(this, axis, rad);
     return this.check();
   }
 
   /** Set a quat to the identity quaternion */
   identity(): this {
-    quat.identity(this);
+    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);
+  //   quat_set(this, i, j, k, l);
   //   return this.check();
   // }
 
@@ -114,18 +136,18 @@ export default class Quaternion extends MathArray {
 
   // Calculates the length of a quat
   len(): number {
-    return quat.length(this);
+    return quat_length(this);
   }
 
   // Calculates the squared length of a quat
   lengthSquared(): number {
-    return quat.squaredLength(this);
+    return quat_squaredLength(this);
   }
 
   // Calculates the dot product of two quat's
   // @return {Number}
   dot(a: Readonly<NumericArray>): number {
-    return quat.dot(this, a);
+    return quat_dot(this, a);
   }
 
   // Gets the rotation axis and angle for a given quaternion.
@@ -138,14 +160,14 @@ export default class Quaternion extends MathArray {
   // @return {{[x,y,z], Number}}
   // getAxisAngle() {
   //   const axis = [];
-  //   const angle = quat.getAxisAngle(axis, this);
+  // //   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: NumericArray, vectorB: NumericArray): this {
-    quat.rotationTo(this, vectorA, vectorB);
+    quat_rotationTo(this, vectorA, vectorB);
     return this.check();
   }
 
@@ -160,48 +182,48 @@ export default class Quaternion extends MathArray {
   //   Number;
   // }
   // Adds two quat's
-  add(a: Readonly<NumericArray>): this {
-    quat.add(this, this, a);
+  override add(a: Readonly<NumericArray>): this {
+    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(): this {
-    quat.calculateW(this, this);
+    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.
+  // this function is faster than quat_invert and produces the same result.
   conjugate(): this {
-    quat.conjugate(this, this);
+    quat_conjugate(this, this);
     return this.check();
   }
 
   // Calculates the inverse of a quat
   invert(): this {
-    quat.invert(this, this);
+    quat_invert(this, this);
     return this.check();
   }
 
   // Performs a linear interpolation between two quat's
-  lerp(a: Readonly<NumericArray>, b: Readonly<NumericArray> | number, t?: number): this {
+  override lerp(a: Readonly<NumericArray>, b: Readonly<NumericArray> | number, t?: number): this {
     if (t === undefined) {
       return this.lerp(this, a, b as number);
     }
-    quat.lerp(this, a, b as NumericArray, t);
+    quat_lerp(this, a, b as NumericArray, t);
     return this.check();
   }
 
   // Multiplies two quat's
   multiplyRight(a: Readonly<NumericArray>): this {
-    quat.multiply(this, this, a);
+    quat_multiply(this, this, a);
     return this.check();
   }
 
   multiplyLeft(a: Readonly<NumericArray>): this {
-    quat.multiply(this, a, this);
+    quat_multiply(this, a, this);
     return this.check();
   }
 
@@ -223,25 +245,25 @@ export default class Quaternion extends MathArray {
 
   // Rotates a quaternion by the given angle about the X axis
   rotateX(rad: number): this {
-    quat.rotateX(this, this, rad);
+    quat_rotateX(this, this, rad);
     return this.check();
   }
 
   // Rotates a quaternion by the given angle about the Y axis
   rotateY(rad: number): this {
-    quat.rotateY(this, this, rad);
+    quat_rotateY(this, this, rad);
     return this.check();
   }
 
   // Rotates a quaternion by the given angle about the Z axis
   rotateZ(rad: number): this {
-    quat.rotateZ(this, this, rad);
+    quat_rotateZ(this, this, rad);
     return this.check();
   }
 
   // Scales a quat by a scalar number
-  scale(b: number): this {
-    quat.scale(this, this, b);
+  override scale(b: number): this {
+    quat_scale(this, this, b);
     return this.check();
   }
 
@@ -293,7 +315,7 @@ export default class Quaternion extends MathArray {
         target = arg1 as Readonly<NumericArray>;
         ratio = arg2;
     }
-    quat.slerp(this, start, target, ratio);
+    quat_slerp(this, start, target, ratio);
     return this.check();
   }
 
@@ -301,7 +323,7 @@ export default class Quaternion extends MathArray {
     vector: Readonly<NumericArray>,
     result: NumericArray = new Vector4()
   ): NumericArray {
-    vec4.transformQuat(result, vector, this);
+    vec4_transformQuat(result, vector, this);
     return checkVector(result, 4);
   }
 

package/src/classes/spherical-coordinates.ts

@@ -1,11 +1,12 @@
 // Copyright (c) 2017 Uber Technologies, Inc.
 // MIT License
 // Adaptation of THREE.js Spherical class, under MIT license
-import Vector3 from './vector3';
+import {NumericArray} from '@math.gl/types';
+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';
-import {NumericArray} from '@math.gl/types';
+// @ts-ignore gl-matrix types...
+import * as vec3 from '../gl-matrix/vec3';
 
 type SphericalCoordinatesOptions = {
   phi?: number;
@@ -30,7 +31,7 @@ const EARTH_RADIUS_METERS = 6371000;
  * The equator starts at positive z.
  * @link https://en.wikipedia.org/wiki/Spherical_coordinate_system
  */
-export default class SphericalCoordinates {
+export class SphericalCoordinates {
   phi: number;
   theta: number;
   radius: number;

package/src/classes/vector2.ts

@@ -1,10 +1,14 @@
 // Copyright (c) 2017 Uber Technologies, Inc.
 // MIT License
-import Vector from './base/vector';
+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 {
+  transformMat4 as vec2_transformMat4,
+  transformMat3 as vec2_transformMat3,
+  transformMat2d as vec2_transformMat2d,
+  transformMat2 as vec2_transformMat2
+} from '../gl-matrix/vec2';
 import {vec2_transformMat4AsVector} from '../lib/gl-matrix-extras';
 import {NumericArray} from '@math.gl/types';
 
@@ -12,7 +16,7 @@ import {NumericArray} from '@math.gl/types';
  * Two-element vector class.
  * Subclass of Array<number>
  */
-export default class Vector2 extends Vector {
+export class Vector2 extends Vector {
   // Creates a new, empty vec2
   constructor(x: number | Readonly<NumericArray> = 0, y: number = 0) {
     // PERF NOTE: initialize elements as double precision numbers
@@ -51,7 +55,7 @@ export default class Vector2 extends Vector {
     return this.check();
   }
 
-  toObject(object: {x?: number; y?: number}): {x: number; y: number} {
+  override toObject(object: {x?: number; y?: number}): {x: number; y: number} {
     object.x = this[0];
     object.y = this[1];
     return object as {x: number; y: number};
@@ -96,7 +100,7 @@ export default class Vector2 extends Vector {
    * @returns
    */
   transformAsPoint(matrix4: Readonly<NumericArray>): this {
-    vec2.transformMat4(this, this, matrix4);
+    vec2_transformMat4(this, this, matrix4);
     return this.check();
   }
 
@@ -111,17 +115,17 @@ export default class Vector2 extends Vector {
   }
 
   transformByMatrix3(matrix3: Readonly<NumericArray>): this {
-    vec2.transformMat3(this, this, matrix3);
+    vec2_transformMat3(this, this, matrix3);
     return this.check();
   }
 
   transformByMatrix2x3(matrix2x3: Readonly<NumericArray>): this {
-    vec2.transformMat2d(this, this, matrix2x3);
+    vec2_transformMat2d(this, this, matrix2x3);
     return this.check();
   }
 
   transformByMatrix2(matrix2: Readonly<NumericArray>): this {
-    vec2.transformMat2(this, this, matrix2);
+    vec2_transformMat2(this, this, matrix2);
     return this.check();
   }
 }