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

package/src/classes/vector3.ts

@@ -1,11 +1,20 @@
 // Copyright (c) 2017 Uber Technologies, Inc.
 // MIT License
 import {NumericArray} from '@math.gl/types';
-import Vector from './base/vector';
+import {Vector} from './base/vector';
 import {config, isArray} from '../lib/common';
 import {checkNumber} from '../lib/validators';
 // @ts-ignore gl-matrix types
-import * as vec3 from 'gl-matrix/vec3';
+import {
+  angle as vec3_angle,
+  cross as vec3_cross,
+  rotateX as vec3_rotateX,
+  rotateY as vec3_rotateY,
+  rotateZ as vec3_rotateZ,
+  transformMat4 as vec3_transformMat4,
+  transformMat3 as vec3_transformMat3,
+  transformQuat as vec3_transformQuat
+} from '../gl-matrix/vec3';
 /* eslint-disable camelcase */
 import {vec3_transformMat2, vec3_transformMat4AsVector} from '../lib/gl-matrix-extras';
 
@@ -17,7 +26,7 @@ let ZERO: Vector3;
  * Three-element vector class.
  * Subclass of Array<number>
  */
-export default class Vector3 extends Vector {
+export class Vector3 extends Vector {
   static get ZERO(): Vector3 {
     if (!ZERO) {
       ZERO = new Vector3(0, 0, 0);
@@ -77,7 +86,11 @@ export default class Vector3 extends Vector {
     return this.check();
   }
 
-  toObject(object: {x?: number; y?: number; z?: number}): {x: number; y: number; z: number} {
+  override toObject(object: {x?: number; y?: number; z?: number}): {
+    x: number;
+    y: number;
+    z: number;
+  } {
     object.x = this[0];
     object.y = this[1];
     object.z = this[2];
@@ -99,28 +112,28 @@ export default class Vector3 extends Vector {
   // ACCESSORS
 
   angle(vector: Readonly<NumericArray>): number {
-    return vec3.angle(this, vector);
+    return vec3_angle(this, vector);
   }
 
   // MODIFIERS
 
   cross(vector: Readonly<NumericArray>): this {
-    vec3.cross(this, this, vector);
+    vec3_cross(this, this, vector);
     return this.check();
   }
 
   rotateX({radians, origin = ORIGIN}: {radians: number; origin?: Readonly<NumericArray>}): this {
-    vec3.rotateX(this, this, origin, radians);
+    vec3_rotateX(this, this, origin, radians);
     return this.check();
   }
 
   rotateY({radians, origin = ORIGIN}: {radians: number; origin?: Readonly<NumericArray>}): this {
-    vec3.rotateY(this, this, origin, radians);
+    vec3_rotateY(this, this, origin, radians);
     return this.check();
   }
 
   rotateZ({radians, origin = ORIGIN}: {radians: number; origin?: Readonly<NumericArray>}): this {
-    vec3.rotateZ(this, this, origin, radians);
+    vec3_rotateZ(this, this, origin, radians);
     return this.check();
   }
 
@@ -133,7 +146,7 @@ export default class Vector3 extends Vector {
 
   // transforms as point (4th component is implicitly 1)
   transformAsPoint(matrix4: Readonly<NumericArray>): this {
-    vec3.transformMat4(this, this, matrix4);
+    vec3_transformMat4(this, this, matrix4);
     return this.check();
   }
 
@@ -144,7 +157,7 @@ export default class Vector3 extends Vector {
   }
 
   transformByMatrix3(matrix3: Readonly<NumericArray>): this {
-    vec3.transformMat3(this, this, matrix3);
+    vec3_transformMat3(this, this, matrix3);
     return this.check();
   }
 
@@ -154,7 +167,7 @@ export default class Vector3 extends Vector {
   }
 
   transformByQuaternion(quaternion: Readonly<NumericArray>): this {
-    vec3.transformQuat(this, this, quaternion);
+    vec3_transformQuat(this, this, quaternion);
     return this.check();
   }
 }

package/src/classes/vector4.ts

@@ -2,16 +2,18 @@
 // MIT License
 
 import {NumericArray} from '@math.gl/types';
-// @ts-ignore gl-matrix types...
-import * as vec4 from 'gl-matrix/vec3';
 /* eslint-disable camelcase */
+import {
+  transformMat4 as vec4_transformMat4,
+  transformQuat as vec4_transformQuat
+} from '../gl-matrix/vec3';
 import {vec4_transformMat2, vec4_transformMat3} from '../lib/gl-matrix-extras';
 
-import Vector from './base/vector';
+import {Vector} from './base/vector';
 import {config, isArray} from '../lib/common';
 import {checkNumber} from '../lib/validators';
 
-import type Matrix4 from './matrix4';
+import type {Matrix4} from './matrix4';
 
 let ZERO: Vector4;
 
@@ -19,7 +21,7 @@ let ZERO: Vector4;
  * Four-element vector class.
  * Subclass of Array<number>
  */
-export default class Vector4 extends Vector {
+export class Vector4 extends Vector {
   static get ZERO(): Vector4 {
     if (!ZERO) {
       ZERO = new Vector4(0, 0, 0, 0);
@@ -78,7 +80,7 @@ export default class Vector4 extends Vector {
     return this;
   }
 
-  toObject(object: {x?: number; y?: number; z?: number; w?: number}): {
+  override toObject(object: {x?: number; y?: number; z?: number; w?: number}): {
     x: number;
     y: number;
     z: number;
@@ -116,7 +118,7 @@ export default class Vector4 extends Vector {
   }
 
   transform(matrix4: Readonly<NumericArray>): this {
-    vec4.transformMat4(this, this, matrix4);
+    vec4_transformMat4(this, this, matrix4);
     return this.check();
   }
 
@@ -131,7 +133,7 @@ export default class Vector4 extends Vector {
   }
 
   transformByQuaternion(quaternion: Readonly<NumericArray>): this {
-    vec4.transformQuat(this, this, quaternion);
+    vec4_transformQuat(this, this, quaternion);
     return this.check();
   }
 

package/src/gl-matrix/common.js

@@ -0,0 +1,58 @@
+// @eslint-disable
+// @ts-nocheck
+
+/**
+ * Common utilities
+ * @module glMatrix
+ */
+
+// Configuration Constants
+export const EPSILON = 0.000001;
+export let ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;
+export const RANDOM = Math.random;
+export const ANGLE_ORDER = 'zyx';
+
+/**
+ * Symmetric round
+ * see https://www.npmjs.com/package/round-half-up-symmetric#user-content-detailed-background
+ *
+ * @param {Number} a value to round
+ */
+export function round(a) {
+  if (a >= 0) return Math.round(a);
+
+  return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
+}
+
+/**
+ * Sets the type of array used when creating new vectors and matrices
+ *
+ * @param {Float32ArrayConstructor | ArrayConstructor} type Array type, such as Float32Array or Array
+ */
+export function setMatrixArrayType(type) {
+  ARRAY_TYPE = type;
+}
+
+const degree = Math.PI / 180;
+
+/**
+ * Convert Degree To Radian
+ *
+ * @param {Number} a Angle in Degrees
+ */
+export function toRadian(a) {
+  return a * degree;
+}
+
+/**
+ * Tests whether or not the arguments have approximately the same value, within an absolute
+ * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less
+ * than or equal to 1.0, and a relative tolerance is used for larger values)
+ *
+ * @param {Number} a The first number to test.
+ * @param {Number} b The second number to test.
+ * @returns {Boolean} True if the numbers are approximately equal, false otherwise.
+ */
+export function equals(a, b) {
+  return Math.abs(a - b) <= EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));
+}