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

package/dist/es5/lib/common.d.ts

@@ -1,80 +0,0 @@
-type TypedArray =
-  | Int8Array
-  | Uint8Array
-  | Int16Array
-  | Uint16Array
-  | Int32Array
-  | Uint32Array
-  | Uint8ClampedArray
-  | Float32Array
-  | Float64Array;
-
-type NumberArray = TypedArray | number[];
-
-type ConfigurationOptions = {
-  EPSILON?: number;
-  debug?: boolean;
-  precision?: number;
-  printTypes?: boolean;
-  printDegrees?: boolean;
-  printRowMajor?: boolean;
-  _cartographicRadians?: boolean;
-};
-
-export const config: ConfigurationOptions;
-
-export function configure(options?: ConfigurationOptions): ConfigurationOptions;
-
-export function formatValue(value: number, options?: ConfigurationOptions): string;
-
-/**
- * Check if value is an "array"
- * Returns `true` if value is either an array or a typed array
- *
- * Note: returns `false` for `ArrayBuffer` and `DataView` instances
- */
-export function isArray(value: any): boolean;
-
-export function clone(array: number[]): number[];
-export function clone(array: TypedArray): TypedArray;
-
-export function toRadians(degrees: number): number;
-export function toRadians(degrees: number[]): number[];
-export function toRadians(degrees: TypedArray): TypedArray;
-export function toDegrees(radians: number): number;
-export function toDegrees(radians: number[]): number[];
-export function toDegrees(radians: TypedArray): TypedArray;
-
-// GLSL math function equivalents: Work on both single values and vectors
-
-/* eslint-disable no-shadow */
-
-export function radians(degrees, result?);
-export function degrees(radians, result?);
-
-/** "GLSL equivalent" of `Math.sin` Works on single values and vectors */
-export function sin(radians: number): number;
-export function sin(radians: number[]): number[];
-// "GLSL equivalent" of Math. : Works on single values and vectors
-export function cos(radians);
-/** "GLSL equivalent" of `Math.tan`: Works on single values and vectors */
-export function tan(radians);
-
-/** "GLSL equivalent" of `Math.asin`: Works on single values and vectors */
-export function asin(radians);
-/** "GLSL equivalent" of `Math.acos`: Works on single values and vectors */
-export function acos(radians);
-/** "GLSL equivalent" of `Math.atan`: Works on single values and vectors */
-export function atan(radians);
-
-/** GLSL style value clamping: Works on single values and vectors */
-export function clamp(value, min, max);
-
-// Interpolate between two numbers or two arrays
-export function lerp(a, b, t: number);
-
-export function equals(a, b, epsilon?: number);
-
-export function exactEquals(a, b);
-
-export function withEpsilon(epsilon: number, func: any): any;

package/dist/esm/addons/polygon.d.ts

@@ -1,17 +0,0 @@
-import {NumberArray} from '@math.gl/core/';
-
-type SegmentVisitor = (p1: NumberArray, p2: NumberArray, i1: number, i2: number) => void;
-
-export default class Polygon {
-  constructor(
-    points: NumberArray | NumberArray[],
-    options?: {start?: number; end?: number; size?: number; isClosed?: boolean}
-  );
-
-  // https://en.wikipedia.org/wiki/Shoelace_formula
-  getSignedArea(): number;
-  getArea(): number;
-  getWindingDirection(): number;
-  forEachSegment(visitor: SegmentVisitor): void;
-  modifyWindingDirection(direction: number): boolean;
-}

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

@@ -1,56 +0,0 @@
-
-/** Base class for vectors and matrices */
-export default abstract class MathArray<DerivedType> extends Array<number> {
-  // Defined by derived class
-  abstract get ELEMENTS(): number;
-
-  clone(): DerivedType;
-
-  // TODO - define more sophisticated object type per class?
-  from(array: readonly number[]): DerivedType;
-  from(object: object): DerivedType;
-
-  fromArray(array: readonly number[], offset?: number): DerivedType;
-  // todo
-  to(arrayOrObject): any;
-  toTarget(target): any;
-
-  toArray(array?: number[], offset?: number): number[];
-  toFloat32Array(): Float32Array;
-  toString(): string;
-  formatString(opts: object): string;
-  equals(array: readonly number[]): boolean;
-  exactEquals(array: readonly number[]): boolean;
-
-  // Modifiers
-
-  negate(): DerivedType;
-  lerp(a: readonly number[], b: readonly number[], t: number): DerivedType;
-
-  min(vector: readonly number[]): DerivedType;
-  max(vector: readonly number[]): DerivedType;
-
-  clamp(minVector: readonly number[], maxVector: readonly number[]): DerivedType;
-
-  add(...vectors): DerivedType;
-  subtract(...vectors): DerivedType;
-
-  scale(scale): DerivedType;
-
-  // three.js compatibility
-
-  sub(a): DerivedType;
-  setScalar(a): DerivedType;
-  addScalar(a): DerivedType;
-  subScalar(a): DerivedType;
-  multiplyScalar(scalar): DerivedType;
-  divideScalar(a): DerivedType;
-  clampScalar(min, max): DerivedType;
-  elements: number[];
-
-  // Cesium compatibility
-  multiplyByScalar(scalar): DerivedType;
-
-  // private
-  check(): DerivedType;
-}

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

@@ -1,15 +0,0 @@
-import MathArray from './math-array';
-
-export default abstract class Matrix<MatrixType> extends MathArray<MatrixType> {
-  abstract get RANK(): number;
-
-  toString(): string;
-
-  getElementIndex(row: number, col: number): number;
-  // By default assumes row major indices
-  getElement(row: number, col: number);
-  // By default assumes row major indices
-  setElement(row: number, col: number, value: number);
-  getColumn(columnIndex: number, result?: number[]);
-  setColumn(columnIndex: number, columnVector: number[]);
-}

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

@@ -1,45 +0,0 @@
-import MathArray from './math-array';
-
-/** Base class for vectors */
-export default abstract class Vector<VectorType> extends MathArray<VectorType> {
-  // VIRTUAL METHODS
-  // copy(vector) {
-
-  // ACCESSORS
-
-  x: number;
-  y: number;
-
-  // NOTE: `length` is a reserved word for Arrays, so we can't use `v.length()`
-  len(): number;
-  magnitude(): number;
-  lengthSquared(): number;
-  magnitudeSquared(): number;
-
-  distance(mathArray): number;
-
-  distanceSquared(mathArray): number;
-
-  dot(mathArray): number;
-  // MODIFIERS
-
-  normalize(): VectorType;
-
-  multiply(...vectors): VectorType;
-
-  divide(...vectors): VectorType;
-
-  // THREE.js compatibility
-  lengthSq(): number;
-  distanceTo(vector: VectorType): number;
-  distanceToSquared(vector): number;
-
-  getComponent(i): number;
-  setComponent(i, value): number;
-
-  addVectors(a: VectorType, b: VectorType): VectorType;
-  subVectors(a: VectorType, b: VectorType): VectorType;
-  multiplyVectors(a: VectorType, b: VectorType): VectorType;
-
-  addScaledVector(a: VectorType, b: VectorType): VectorType;
-}

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

@@ -1,92 +0,0 @@
-import MathArray from './base/math-array';
-import Quaternion from './quaternion';
-import Matrix3 from './matrix3';
-
-export default class Euler extends MathArray<Euler> {
-  static ZYX: number;
-  static YXZ: number;
-  static XZY: number;
-  static ZXY: number;
-  static YZX: number;
-  static XYZ: number;
-  static RollPitchYaw: number;
-  static DefaultOrder: number;
-  static RotationOrders: string[];
-
-  static rotationOrder(order: number): string;
-
-  ELEMENTS: number;
-
-  /**
-   * @class
-   * @param {Number | Number[]} x
-   * @param {Number=} [y]
-   * @param {Number=} [z]
-   * @param {Number=} [order]
-   */
-  constructor();
-  constructor(x: number, y: number, z: number, order?: number);
-  constructor(vector3: number[], order?: number);
-
-  fromQuaternion(quaternion: Quaternion): Euler;
-
-  // If copied array does contain fourth element, preserves currently set order
-  copy(array: number[]): Euler;
-
-  // Sets the three angles, and optionally sets the rotation order
-  // If order is not specified, preserves currently set order
-  set(x: number, y: number, z: number, order?: number): Euler;
-
-  validate(): boolean;
-
-  // Does not copy the orientation element
-  toArray(array?: number[], offset?: number): number[];
-
-  // Copies the orientation element
-  toArray4(array?: number[], offset?: number): number[];
-
-  toVector3(result?: number[]): number[];
-
-  // x, y, z angle notation (note: only corresponds to axis in XYZ orientation)
-  x: number;
-  y: number;
-  z: number;
-
-  // alpha, beta, gamma angle notation
-  alpha: number;
-  beta: number;
-  gamma: number;
-
-  // phi, theta, psi angle notation
-  phi: number;
-  theta: number;
-  psi: number;
-
-  // roll, pitch, yaw angle notation
-  roll: number;
-  pitch: number;
-  yaw: number;
-
-  // rotation order, in all three angle notations
-  order: number;
-
-  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */
-
-  // Constructors
-  fromVector3(v: number[], order: number): Euler;
-  // TODO - with and without 4th element
-  fromArray(array: number[], offset?: number): Euler;
-
-  // Common ZYX rotation order
-  fromRollPitchYaw(roll: number, pitch: number, yaw: number): Euler;
-  fromRotationMatrix(m: number[], order?: number): Euler;
-
-  // ACCESSORS
-
-  getRotationMatrix(m: Matrix3): Matrix3;
-  getRotationMatrix(m?: number[]): number[];
-
-  // TODO - move to Quaternion
-  getQuaternion(): Quaternion;
-  toQuaternion(): Quaternion;
-}

package/dist/esm/classes/matrix3.d.ts

@@ -1,91 +0,0 @@
-import Matrix from './base/matrix';
-// import Quaternion from './quaternion';
-
-export default class Matrix3 extends Matrix<Matrix3> {
-  static IDENTITY: Matrix3;
-  static ZERO: Matrix3;
-
-  // inherited
-  get ELEMENTS(): number;
-  get RANK(): number;
-  INDICES: number[];
-
-  constructor();
-  constructor(array: number[]);
-  constructor(
-    m00: number,
-    m10: number,
-    m20: number,
-    m01: number,
-    m11: number,
-    m21: number,
-    m02: number,
-    m12: number,
-    m22: number
-  );
-
-  copy(array): Matrix3;
-
-  // accepts column major order, stores in column major order
-  // eslint-disable-next-line max-params
-  set(
-    m00: number,
-    m10: number,
-    m20: number,
-    m01: number,
-    m11: number,
-    m21: number,
-    m02: number,
-    m12: number,
-    m22: number
-  );
-
-  // accepts row major order, stores as column major
-  // eslint-disable-next-line max-params
-  setRowMajor(
-    m00: number,
-    m01: number,
-    m02: number,
-    m10: number,
-    m11: number,
-    m12: number,
-    m20: number,
-    m21: number,
-    m22: number
-  );
-  setRowMajor(...array: number[]);
-
-  // Accessors
-  determinant(): number;
-
-  // Constructors
-  identity(): Matrix3;
-
-  // Calculates a 3x3 matrix from the given quaternion
-  // q quat  Quaternion to create matrix from
-  fromQuaternion(q: number[]): Matrix3;
-
-  // Modifiers
-  transpose(): Matrix3;
-  invert(): Matrix3;
-
-  // Operations
-  multiplyLeft(a: Matrix3): Matrix3;
-  multiplyRight(a: Matrix3): Matrix3;
-
-  rotate(radians: number): Matrix3;
-
-  scale(scale: number): Matrix3;
-  scale([scaleX, scaleY, scaleZ]: number[]): Matrix3;
-
-  translate(vec): Matrix3;
-
-  // Transforms
-
-  transform(vector: number[], result?: number[]): number[];
-
-  // DEPRECATED IN 3.0
-  transformVector(vector, result);
-  transformVector2(vector, result);
-  transformVector3(vector, result);
-}

package/dist/esm/classes/matrix4.d.ts

@@ -1,161 +0,0 @@
-import Matrix from './base/matrix';
-// import Quaternion from './quaternion';
-
-type Array16 = number[];
-// = [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
-
-export default class Matrix4 extends Matrix<Matrix4> {
-  static IDENTITY: number[];
-  static ZERO: number[];
-
-  INDICES: number[];
-  get ELEMENTS(): number;
-  get RANK(): number;
-
-  constructor();
-  constructor(array: Array16);
-
-  copy(array: Array16);
-
-  // eslint-disable-next-line max-params
-  set(
-    m00: number,
-    m01: number,
-    m02: number,
-    m03: number,
-    m10: number,
-    m11: number,
-    m12: number,
-    m13: number,
-    m20: number,
-    m21: number,
-    m22: number,
-    m23: number,
-    m30: number,
-    m31: number,
-    m32: number,
-    m33: number
-  );
-  setRowMajor(
-    m00: number,
-    m01: number,
-    m02: number,
-    m03: number,
-    m10: number,
-    m11: number,
-    m12: number,
-    m13: number,
-    m20: number,
-    m21: number,
-    m22: number,
-    m23: number,
-    m30: number,
-    m31: number,
-    m32: number,
-    m33: number
-  );
-
-  toRowMajor(result: Array16);
-
-  identity(): Matrix4;
-
-  // Calculates a 4x4 matrix from the given quaternion
-  fromQuaternion(q: number[]): Matrix4;
-
-  // Generates a frustum matrix with the given bounds
-  frustum(args: {
-    left: number;
-    right: number;
-    bottom: number;
-    top: number;
-    near: number;
-    far: number;
-  }): Matrix4;
-
-  // Generates a look-at matrix with the given eye position, focal point, and up axis
-  lookAt(eye: number[], center?: number[], up?: number[]): Matrix4;
-  lookAt(args: {eye: number[]; center?: number[]; up?: number[]}): Matrix4;
-
-  // Generates a orthogonal projection matrix with the given bounds
-  ortho(args: {
-    left: number;
-    right: number;
-    bottom: number;
-    top: number;
-    near: number;
-    far: number;
-  }): Matrix4;
-
-  // Generates an orthogonal projection matrix with the same parameters
-  orthographic(args: {
-    fovy: number;
-    aspect?: number;
-    focalDistance?: number;
-    near?: number;
-    far?: number;
-  }): Matrix4;
-
-  // Generates a perspective projection matrix with the given bounds
-  perspective(args: {
-    fovy?: number;
-    fov?: number;
-    aspect?: number;
-    near?: number;
-    far?: number;
-  }): Matrix4;
-
-  // Accessors
-
-  determinant(): Matrix4;
-
-  // Decomposition
-  // Extracts the non-uniform scale assuming the matrix is an affine transformation.
-  // The scales are the "lengths" of the column vectors in the upper-left 3x3 matrix.
-  getScale(): number[];
-  getScale<T extends number[]>(result: T): T;
-  // Gets the translation portion, assuming the matrix is a affine transformation matrix.
-  getTranslation(): number[];
-  getTranslation<T extends number[]>(result: T): T;
-  // Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix
-  getRotation(): number[];
-  getRotation<T extends number[]>(result: T, scaleResult?: number[]): T;
-  getRotationMatrix3(): number[];
-  getRotationMatrix3<T extends number[]>(result: T, scaleResult?: number[]): T;
-
-  // Modifiers
-  transpose(): Matrix4;
-  invert(): Matrix4;
-
-  // Operations
-  multiplyLeft(a: number[]): Matrix4;
-  multiplyRight(a: number[]): Matrix4;
-
-  scale(factor): Matrix4;
-  translate(vec): Matrix4;
-  rotateX(radians: number): Matrix4;
-  rotateY(radians: number): Matrix4;
-  rotateZ(radians: number): Matrix4;
-  rotateXYZ([rx, ry, rz]: number[]): Matrix4;
-  rotateAxis(radians, axis): Matrix4;
-
-  // Transforms
-
-  // Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points
-  transform(vector: number[], result: number[]): number[];
-
-  // Transforms any 2 or 3 element array as point (w implicitly 1)
-  transformAsPoint(vector: number[], result: number[]): number[];
-  transformAsVector(vector: number[], result: number[]): number[];
-
-  // three.js math API compatibility
-  makeRotationX(radians: number): Matrix4;
-  makeTranslation(x: number, y: number, z: number): Matrix4;
-
-  // DEPRECATED in 3.0
-  /** @deprecated Use Matrix4.transformAsPoint instead. */
-  transformPoint(vector: number[], result?: number[]): number[];
-  /** @deprecated Use Matrix4.transformAsPoint instead. */
-  transformVector(vector: number[], result?: number[]): number[];
-  /** @deprecated Use Matrix4.transformAsPoint instead. */
-  transformDirection(vector: number[], result?: number[]): number[];
-}

package/dist/esm/classes/pose.d.ts

@@ -1,92 +0,0 @@
-// 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 Matrix4 from './matrix4';
-import Vector3 from './vector3';
-import Euler from './euler';
-
-type PoseOptions = {
-  position?: number[];
-  orientation?: number[];
-  x?: number;
-  y?: number;
-  z?: number;
-  roll?: number;
-  pitch?: number;
-  yaw?: number;
-};
-
-export default class Pose {
-  /**
-   * A pose contains both rotation and rotations.
-   * Note that every single pose defines its own coordinate system
-   * (with the position of the pose in the origin, and zero rotations).
-   * These "pose relative" coordinate will be centered on the defining
-   * pose's position and with with the defining pose's orientation
-   * aligned with axis.
-   * @param {Object} options
-   * @param {Number[]} [options.position]
-   * @param {Number[]} [options.orientation]
-   * @param {Number} [options.x]
-   * @param {Number} [options.y]
-   * @param {Number} [options.z]
-   * @param {Number} [options.roll]
-   * @param {Number} [options.pitch]
-   * @param {Number} [options.yaw]
-   */
-  constructor(options?: PoseOptions);
-
-  x: number;
-  y: number;
-  z: number;
-  roll: number;
-  pitch: number;
-  yaw: number;
-
-  getPosition(): Vector3;
-  getOrientation(): Euler;
-
-  equals(pose: Pose): boolean;
-  exactEquals(pose: Pose): boolean;
-
-  /**
-   * Returns a 4x4 matrix that transforms a coordinates (in the same
-   * coordinate system as this pose) into the "pose-relative" coordinate
-   * system defined by this pose.
-   * The pose relative coordinates with have origin in the position of this
-   * pose, and axis will be aligned with the rotation of this pose.
-   */
-  getTransformationMatrix(): Matrix4;
-
-  /**
-   * Given a second pose that represent the same object in a second coordinate
-   * system, this method returns a 4x4 matrix that transforms coordinates in the
-   * second coordinate system into the coordinate system of this pose.
-   */
-  getTransformationMatrixFromPose(pose: Pose): Matrix4;
-
-  /**
-   * Given a second pose that represent the same object in a second coordinate
-   * system, this method returns a 4x4 matrix that transforms coordinates in the
-   * coordinate system of this pose into the coordinate system of the second pose.
-   *
-   * Note: This method returns the inverse of `this.getTransformationMatrixFromPose(pose)`
-   */
-  getTransformationMatrixToPose(pose: Pose): Matrix4;
-}