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

package/dist/es5/classes/quaternion.js

@@ -2,250 +2,322 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
+var _typeof = require("@babel/runtime/helpers/typeof");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 
-var _mathArray = _interopRequireDefault(require("./base/math-array"));
-
-var _validators = require("../lib/validators");
-
-var _assert = _interopRequireDefault(require("../lib/assert"));
-
-var quat = _interopRequireWildcard(require("gl-matrix/quat"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
-var vec4 = _interopRequireWildcard(require("gl-matrix/vec4"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
 
-const IDENTITY_QUATERNION = [0, 0, 0, 1];
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
-class Quaternion extends _mathArray.default {
-  constructor(x = 0, y = 0, z = 0, w = 1) {
-    super(-0, -0, -0, -0);
-
-    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();
-  }
-
-  fromMatrix3(m) {
-    quat.fromMat3(this, m);
-    return this.check();
-  }
-
-  identity() {
-    quat.identity(this);
-    return this.check();
-  }
+var _mathArray = _interopRequireDefault(require("./base/math-array"));
 
-  fromAxisRotation(axis, rad) {
-    quat.setAxisAngle(this, axis, rad);
-    return this.check();
-  }
+var _validators = require("../lib/validators");
 
-  setAxisAngle(axis, rad) {
-    return this.fromAxisRotation(axis, rad);
-  }
+var _vector = _interopRequireDefault(require("./vector4"));
 
-  get ELEMENTS() {
-    return 4;
-  }
+var quat = _interopRequireWildcard(require("gl-matrix/quat"));
 
-  get x() {
-    return this[0];
-  }
+var vec4 = _interopRequireWildcard(require("gl-matrix/vec4"));
 
-  set x(value) {
-    this[0] = (0, _validators.checkNumber)(value);
-  }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-  get y() {
-    return this[1];
-  }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-  set y(value) {
-    this[1] = (0, _validators.checkNumber)(value);
-  }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
 
-  get z() {
-    return this[2];
-  }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-  set z(value) {
-    this[2] = (0, _validators.checkNumber)(value);
-  }
+var IDENTITY_QUATERNION = [0, 0, 0, 1];
 
-  get w() {
-    return this[3];
-  }
+var Quaternion = function (_MathArray) {
+  (0, _inherits2.default)(Quaternion, _MathArray);
 
-  set w(value) {
-    this[3] = (0, _validators.checkNumber)(value);
-  }
+  var _super = _createSuper(Quaternion);
 
-  len() {
-    return quat.length(this);
-  }
+  function Quaternion() {
+    var _this;
 
-  lengthSquared() {
-    return quat.squaredLength(this);
-  }
+    var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var z = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    var w = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+    (0, _classCallCheck2.default)(this, Quaternion);
+    _this = _super.call(this, -0, -0, -0, -0);
 
-  dot(a, b) {
-    if (b !== undefined) {
-      throw new Error('Quaternion.dot only takes one argument');
+    if (Array.isArray(x) && arguments.length === 1) {
+      _this.copy(x);
+    } else {
+      _this.set(x, y, z, w);
     }
 
-    return quat.dot(this, a);
+    return _this;
   }
 
-  rotationTo(vectorA, vectorB) {
-    quat.rotationTo(this, vectorA, vectorB);
-    return this.check();
-  }
-
-  add(a, b) {
-    if (b !== undefined) {
-      throw new Error('Quaternion.add only takes one argument');
+  (0, _createClass2.default)(Quaternion, [{
+    key: "copy",
+    value: function copy(array) {
+      this[0] = array[0];
+      this[1] = array[1];
+      this[2] = array[2];
+      this[3] = array[3];
+      return this.check();
     }
-
-    quat.add(this, this, a);
-    return this.check();
-  }
-
-  calculateW() {
-    quat.calculateW(this, this);
-    return this.check();
-  }
-
-  conjugate() {
-    quat.conjugate(this, this);
-    return this.check();
-  }
-
-  invert() {
-    quat.invert(this, this);
-    return this.check();
-  }
-
-  lerp(a, b, t) {
-    quat.lerp(this, a, b, t);
-    return this.check();
-  }
-
-  multiplyRight(a, b) {
-    (0, _assert.default)(!b);
-    quat.multiply(this, this, a);
-    return this.check();
-  }
-
-  multiplyLeft(a, b) {
-    (0, _assert.default)(!b);
-    quat.multiply(this, a, this);
-    return this.check();
-  }
-
-  normalize() {
-    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;
-
-    if (length === 0) {
-      this[3] = 1;
+  }, {
+    key: "set",
+    value: function set(x, y, z, w) {
+      this[0] = x;
+      this[1] = y;
+      this[2] = z;
+      this[3] = w;
+      return this.check();
     }
-
-    return this.check();
-  }
-
-  rotateX(rad) {
-    quat.rotateX(this, this, rad);
-    return this.check();
-  }
-
-  rotateY(rad) {
-    quat.rotateY(this, this, rad);
-    return this.check();
-  }
-
-  rotateZ(rad) {
-    quat.rotateZ(this, this, rad);
-    return this.check();
-  }
-
-  scale(b) {
-    quat.scale(this, this, b);
-    return this.check();
-  }
-
-  slerp(start, target, ratio) {
-    switch (arguments.length) {
-      case 1:
-        ({
-          start = IDENTITY_QUATERNION,
-          target,
-          ratio
-        } = arguments[0]);
-        break;
-
-      case 2:
-        [target, ratio] = arguments;
-        start = this;
-        break;
-
-      default:
+  }, {
+    key: "fromObject",
+    value: function fromObject(object) {
+      this[0] = object.x;
+      this[1] = object.y;
+      this[2] = object.z;
+      this[3] = object.w;
+      return this.check();
     }
-
-    quat.slerp(this, start, target, ratio);
-    return this.check();
-  }
-
-  transformVector4(vector, result = vector) {
-    vec4.transformQuat(result, vector, this);
-    return (0, _validators.checkVector)(result, 4);
-  }
-
-  lengthSq() {
-    return this.lengthSquared();
-  }
-
-  setFromAxisAngle(axis, rad) {
-    return this.setAxisAngle(axis, rad);
-  }
-
-  premultiply(a, b) {
-    return this.multiplyLeft(a, b);
-  }
-
-  multiply(a, b) {
-    return this.multiplyRight(a, b);
-  }
-
-}
+  }, {
+    key: "fromMatrix3",
+    value: function fromMatrix3(m) {
+      quat.fromMat3(this, m);
+      return this.check();
+    }
+  }, {
+    key: "fromAxisRotation",
+    value: function fromAxisRotation(axis, rad) {
+      quat.setAxisAngle(this, axis, rad);
+      return this.check();
+    }
+  }, {
+    key: "identity",
+    value: function identity() {
+      quat.identity(this);
+      return this.check();
+    }
+  }, {
+    key: "setAxisAngle",
+    value: function setAxisAngle(axis, rad) {
+      return this.fromAxisRotation(axis, rad);
+    }
+  }, {
+    key: "ELEMENTS",
+    get: function get() {
+      return 4;
+    }
+  }, {
+    key: "x",
+    get: function get() {
+      return this[0];
+    },
+    set: function set(value) {
+      this[0] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "y",
+    get: function get() {
+      return this[1];
+    },
+    set: function set(value) {
+      this[1] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "z",
+    get: function get() {
+      return this[2];
+    },
+    set: function set(value) {
+      this[2] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "w",
+    get: function get() {
+      return this[3];
+    },
+    set: function set(value) {
+      this[3] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "len",
+    value: function len() {
+      return quat.length(this);
+    }
+  }, {
+    key: "lengthSquared",
+    value: function lengthSquared() {
+      return quat.squaredLength(this);
+    }
+  }, {
+    key: "dot",
+    value: function dot(a) {
+      return quat.dot(this, a);
+    }
+  }, {
+    key: "rotationTo",
+    value: function rotationTo(vectorA, vectorB) {
+      quat.rotationTo(this, vectorA, vectorB);
+      return this.check();
+    }
+  }, {
+    key: "add",
+    value: function add(a) {
+      quat.add(this, this, a);
+      return this.check();
+    }
+  }, {
+    key: "calculateW",
+    value: function calculateW() {
+      quat.calculateW(this, this);
+      return this.check();
+    }
+  }, {
+    key: "conjugate",
+    value: function conjugate() {
+      quat.conjugate(this, this);
+      return this.check();
+    }
+  }, {
+    key: "invert",
+    value: function invert() {
+      quat.invert(this, this);
+      return this.check();
+    }
+  }, {
+    key: "lerp",
+    value: function lerp(a, b, t) {
+      if (t === undefined) {
+        return this.lerp(this, a, b);
+      }
+
+      quat.lerp(this, a, b, t);
+      return this.check();
+    }
+  }, {
+    key: "multiplyRight",
+    value: function multiplyRight(a) {
+      quat.multiply(this, this, a);
+      return this.check();
+    }
+  }, {
+    key: "multiplyLeft",
+    value: function multiplyLeft(a) {
+      quat.multiply(this, a, this);
+      return this.check();
+    }
+  }, {
+    key: "normalize",
+    value: function normalize() {
+      var length = this.len();
+      var 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;
+
+      if (length === 0) {
+        this[3] = 1;
+      }
+
+      return this.check();
+    }
+  }, {
+    key: "rotateX",
+    value: function rotateX(rad) {
+      quat.rotateX(this, this, rad);
+      return this.check();
+    }
+  }, {
+    key: "rotateY",
+    value: function rotateY(rad) {
+      quat.rotateY(this, this, rad);
+      return this.check();
+    }
+  }, {
+    key: "rotateZ",
+    value: function rotateZ(rad) {
+      quat.rotateZ(this, this, rad);
+      return this.check();
+    }
+  }, {
+    key: "scale",
+    value: function scale(b) {
+      quat.scale(this, this, b);
+      return this.check();
+    }
+  }, {
+    key: "slerp",
+    value: function slerp(arg0, arg1, arg2) {
+      var start;
+      var target;
+      var ratio;
+
+      switch (arguments.length) {
+        case 1:
+          var _ref = arg0;
+          var _ref$start = _ref.start;
+          start = _ref$start === void 0 ? IDENTITY_QUATERNION : _ref$start;
+          target = _ref.target;
+          ratio = _ref.ratio;
+          break;
+
+        case 2:
+          start = this;
+          target = arg0;
+          ratio = arg1;
+          break;
+
+        default:
+          start = arg0;
+          target = arg1;
+          ratio = arg2;
+      }
+
+      quat.slerp(this, start, target, ratio);
+      return this.check();
+    }
+  }, {
+    key: "transformVector4",
+    value: function transformVector4(vector) {
+      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _vector.default();
+      vec4.transformQuat(result, vector, this);
+      return (0, _validators.checkVector)(result, 4);
+    }
+  }, {
+    key: "lengthSq",
+    value: function lengthSq() {
+      return this.lengthSquared();
+    }
+  }, {
+    key: "setFromAxisAngle",
+    value: function setFromAxisAngle(axis, rad) {
+      return this.setAxisAngle(axis, rad);
+    }
+  }, {
+    key: "premultiply",
+    value: function premultiply(a) {
+      return this.multiplyLeft(a);
+    }
+  }, {
+    key: "multiply",
+    value: function multiply(a) {
+      return this.multiplyRight(a);
+    }
+  }]);
+  return Quaternion;
+}(_mathArray.default);
 
 exports.default = Quaternion;
 //# sourceMappingURL=quaternion.js.map

package/dist/es5/classes/quaternion.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/classes/quaternion.js"],"names":["IDENTITY_QUATERNION","Quaternion","MathArray","constructor","x","y","z","w","Array","isArray","arguments","length","copy","set","array","check","fromMatrix3","m","quat","fromMat3","identity","fromAxisRotation","axis","rad","setAxisAngle","ELEMENTS","value","len","lengthSquared","squaredLength","dot","a","b","undefined","Error","rotationTo","vectorA","vectorB","add","calculateW","conjugate","invert","lerp","t","multiplyRight","multiply","multiplyLeft","normalize","l","rotateX","rotateY","rotateZ","scale","slerp","start","target","ratio","transformVector4","vector","result","vec4","transformQuat","lengthSq","setFromAxisAngle","premultiply"],"mappings":"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","sourcesContent":["// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport MathArray from './base/math-array';\nimport {checkNumber, checkVector} from '../lib/validators';\nimport assert from '../lib/assert';\n\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as quat from 'gl-matrix/quat';\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as vec4 from 'gl-matrix/vec4';\n\nconst IDENTITY_QUATERNION = [0, 0, 0, 1];\n\nexport default class Quaternion extends MathArray {\n  constructor(x = 0, y = 0, z = 0, w = 1) {\n    // PERF NOTE: initialize elements as double precision numbers\n    super(-0, -0, -0, -0);\n    // eslint-disable-next-line prefer-rest-params\n    if (Array.isArray(x) && arguments.length === 1) {\n      this.copy(x);\n    } else {\n      this.set(x, y, z, w);\n    }\n  }\n\n  copy(array) {\n    this[0] = array[0];\n    this[1] = array[1];\n    this[2] = array[2];\n    this[3] = array[3];\n    return this.check();\n  }\n\n  set(x, y, z, w) {\n    this[0] = x;\n    this[1] = y;\n    this[2] = z;\n    this[3] = w;\n    return this.check();\n  }\n\n  // Creates a quaternion from the given 3x3 rotation matrix.\n  // NOTE: The resultant quaternion is not normalized, so you should\n  // be sure to renormalize the quaternion yourself where necessary.\n  fromMatrix3(m) {\n    quat.fromMat3(this, m);\n    return this.check();\n  }\n\n  // Set a quat to the identity quaternion\n  identity() {\n    quat.identity(this);\n    return this.check();\n  }\n\n  fromAxisRotation(axis, rad) {\n    quat.setAxisAngle(this, axis, rad);\n    return this.check();\n  }\n\n  // Set the components of a quat to the given values\n  // set(i, j, k, l) {\n  //   quat.set(this, i, j, k, l);\n  //   return this.check();\n  // }\n\n  // Sets a quat from the given angle and rotation axis, then returns it.\n  setAxisAngle(axis, rad) {\n    return this.fromAxisRotation(axis, rad);\n  }\n\n  // Getters/setters\n  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */\n  get ELEMENTS() {\n    return 4;\n  }\n\n  get x() {\n    return this[0];\n  }\n\n  set x(value) {\n    this[0] = checkNumber(value);\n  }\n\n  get y() {\n    return this[1];\n  }\n\n  set y(value) {\n    this[1] = checkNumber(value);\n  }\n\n  get z() {\n    return this[2];\n  }\n\n  set z(value) {\n    this[2] = checkNumber(value);\n  }\n\n  get w() {\n    return this[3];\n  }\n\n  set w(value) {\n    this[3] = checkNumber(value);\n  }\n\n  /* eslint-enable no-multi-spaces, brace-style, no-return-assign */\n\n  // Calculates the length of a quat\n  len() {\n    return quat.length(this);\n  }\n\n  // Calculates the squared length of a quat\n  lengthSquared() {\n    return quat.squaredLength(this);\n  }\n\n  // Calculates the dot product of two quat's\n  // @return {Number}\n  dot(a, b) {\n    if (b !== undefined) {\n      throw new Error('Quaternion.dot only takes one argument');\n    }\n    return quat.dot(this, a);\n  }\n\n  // Gets the rotation axis and angle for a given quaternion.\n  // If a quaternion is created with setAxisAngle, this method will\n  // return the same values as providied in the original parameter\n  // list OR functionally equivalent values.\n  // Example: The quaternion formed by axis [0, 0, 1] and angle -90\n  // is the same as the quaternion formed by [0, 0, 1] and 270.\n  // This method favors the latter.\n  // @return {{[x,y,z], Number}}\n  // getAxisAngle() {\n  //   const axis = [];\n  //   const angle = quat.getAxisAngle(axis, this);\n  //   return {axis, angle};\n  // }\n\n  // MODIFIERS\n\n  // Sets a quaternion to represent the shortest rotation from one vector\n  // to another. Both vectors are assumed to be unit length.\n  rotationTo(vectorA, vectorB) {\n    quat.rotationTo(this, vectorA, vectorB);\n    return this.check();\n  }\n\n  // Sets the specified quaternion with values corresponding to the given axes.\n  // Each axis is a vec3 and is expected to be unit length and perpendicular\n  // to all other specified axes.\n  // setAxes() {\n  //   Number\n  // }\n\n  // Performs a spherical linear interpolation with two control points\n  // sqlerp() {\n  //   Number;\n  // }\n\n  // Adds two quat's\n  add(a, b) {\n    if (b !== undefined) {\n      throw new Error('Quaternion.add only takes one argument');\n    }\n    quat.add(this, this, a);\n    return this.check();\n  }\n\n  // Calculates the W component of a quat from the X, Y, and Z components.\n  // Any existing W component will be ignored.\n  calculateW() {\n    quat.calculateW(this, this);\n    return this.check();\n  }\n\n  // Calculates the conjugate of a quat If the quaternion is normalized,\n  // this function is faster than quat.inverse and produces the same result.\n  conjugate() {\n    quat.conjugate(this, this);\n    return this.check();\n  }\n\n  // Calculates the inverse of a quat\n  invert() {\n    quat.invert(this, this);\n    return this.check();\n  }\n\n  // Performs a linear interpolation between two quat's\n  lerp(a, b, t) {\n    quat.lerp(this, a, b, t);\n    return this.check();\n  }\n\n  // Multiplies two quat's\n  multiplyRight(a, b) {\n    assert(!b); // Quaternion.multiply only takes one argument\n    quat.multiply(this, this, a);\n    return this.check();\n  }\n\n  multiplyLeft(a, b) {\n    assert(!b); // Quaternion.multiply only takes one argument\n    quat.multiply(this, a, this);\n    return this.check();\n  }\n\n  // Normalize a quat\n  normalize() {\n    // Handle 0 case\n    const length = this.len();\n    const l = length > 0 ? 1 / length : 0;\n    this[0] = this[0] * l;\n    this[1] = this[1] * l;\n    this[2] = this[2] * l;\n    this[3] = this[3] * l;\n    // Set to [0, 0, 0, 1] if length is 0\n    if (length === 0) {\n      this[3] = 1;\n    }\n    return this.check();\n  }\n\n  // Rotates a quaternion by the given angle about the X axis\n  rotateX(rad) {\n    quat.rotateX(this, this, rad);\n    return this.check();\n  }\n\n  // Rotates a quaternion by the given angle about the Y axis\n  rotateY(rad) {\n    quat.rotateY(this, this, rad);\n    return this.check();\n  }\n\n  // Rotates a quaternion by the given angle about the Z axis\n  rotateZ(rad) {\n    quat.rotateZ(this, this, rad);\n    return this.check();\n  }\n\n  // Scales a quat by a scalar number\n  scale(b) {\n    quat.scale(this, this, b);\n    return this.check();\n  }\n\n  // Performs a spherical linear interpolation between two quat\n  slerp(start, target, ratio) {\n    // eslint-disable-next-line prefer-rest-params\n    switch (arguments.length) {\n      case 1: // Deprecated signature ({start, target, ratio})\n        // eslint-disable-next-line prefer-rest-params\n        ({start = IDENTITY_QUATERNION, target, ratio} = arguments[0]);\n        break;\n      case 2: // THREE.js compatibility signature (target, ration)\n        // eslint-disable-next-line prefer-rest-params\n        [target, ratio] = arguments;\n        start = this; // eslint-disable-line\n        break;\n      default: // Default signature: (start, target, ratio)\n    }\n    quat.slerp(this, start, target, ratio);\n    return this.check();\n  }\n\n  transformVector4(vector, result = vector) {\n    vec4.transformQuat(result, vector, this);\n    return checkVector(result, 4);\n  }\n\n  // THREE.js Math API compatibility\n  lengthSq() {\n    return this.lengthSquared();\n  }\n\n  setFromAxisAngle(axis, rad) {\n    return this.setAxisAngle(axis, rad);\n  }\n\n  premultiply(a, b) {\n    return this.multiplyLeft(a, b);\n  }\n\n  multiply(a, b) {\n    return this.multiplyRight(a, b);\n  }\n}\n"],"file":"quaternion.js"}
+{"version":3,"sources":["../../../src/classes/quaternion.ts"],"names":["IDENTITY_QUATERNION","Quaternion","x","y","z","w","Array","isArray","arguments","length","copy","set","array","check","object","m","quat","fromMat3","axis","rad","setAxisAngle","identity","fromAxisRotation","value","squaredLength","a","dot","vectorA","vectorB","rotationTo","add","calculateW","conjugate","invert","b","t","undefined","lerp","multiply","len","l","rotateX","rotateY","rotateZ","scale","arg0","arg1","arg2","start","target","ratio","slerp","vector","result","Vector4","vec4","transformQuat","lengthSquared","multiplyLeft","multiplyRight","MathArray"],"mappings":"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","sourcesContent":["// Copyright (c) 2017 Uber Technologies, Inc.\n// MIT License\nimport MathArray from './base/math-array';\nimport {checkNumber, checkVector} from '../lib/validators';\nimport Vector4 from './vector4';\nimport * as quat from 'gl-matrix/quat';\nimport * as vec4 from 'gl-matrix/vec4';\nimport {NumericArray} from '@math.gl/types';\n\nconst IDENTITY_QUATERNION = [0, 0, 0, 1] as const;\n\nexport default class Quaternion extends MathArray {\n  constructor(x: number | Readonly<NumericArray> = 0, y = 0, z = 0, w = 1) {\n    // PERF NOTE: initialize elements as double precision numbers\n    super(-0, -0, -0, -0);\n    // eslint-disable-next-line prefer-rest-params\n    if (Array.isArray(x) && arguments.length === 1) {\n      this.copy(x);\n    } else {\n      this.set(x as number, y, z, w);\n    }\n  }\n\n  copy(array: Readonly<NumericArray>): this {\n    this[0] = array[0];\n    this[1] = array[1];\n    this[2] = array[2];\n    this[3] = array[3];\n    return this.check();\n  }\n\n  set(x: number, y: number, z: number, w: number): this {\n    this[0] = x;\n    this[1] = y;\n    this[2] = z;\n    this[3] = w;\n    return this.check();\n  }\n\n  fromObject(object: {x: number; y: number; z: number; w: number}): this {\n    this[0] = object.x;\n    this[1] = object.y;\n    this[2] = object.z;\n    this[3] = object.w;\n    return this.check();\n  }\n\n  /**\n   * Creates a quaternion from the given 3x3 rotation matrix.\n   * NOTE: The resultant quaternion is not normalized, so you should\n   * be sure to renormalize the quaternion yourself where necessary.\n   * @param m\n   * @returns\n   */\n  fromMatrix3(m: Readonly<NumericArray>): this {\n    quat.fromMat3(this, m);\n    return this.check();\n  }\n\n  fromAxisRotation(axis: Readonly<NumericArray>, rad: number): this {\n    quat.setAxisAngle(this, axis, rad);\n    return this.check();\n  }\n\n  /** Set a quat to the identity quaternion */\n  identity(): this {\n    quat.identity(this);\n    return this.check();\n  }\n\n  // Set the components of a quat to the given values\n  // set(i, j, k, l) {\n  //   quat.set(this, i, j, k, l);\n  //   return this.check();\n  // }\n\n  // Sets a quat from the given angle and rotation axis, then returns it.\n  setAxisAngle(axis: Readonly<NumericArray>, rad: number): this {\n    return this.fromAxisRotation(axis, rad);\n  }\n\n  // Getters/setters\n  get ELEMENTS(): number {\n    return 4;\n  }\n\n  get x(): number {\n    return this[0];\n  }\n  set x(value: number) {\n    this[0] = checkNumber(value);\n  }\n\n  get y(): number {\n    return this[1];\n  }\n  set y(value: number) {\n    this[1] = checkNumber(value);\n  }\n\n  get z(): number {\n    return this[2];\n  }\n  set z(value: number) {\n    this[2] = checkNumber(value);\n  }\n\n  get w(): number {\n    return this[3];\n  }\n  set w(value: number) {\n    this[3] = checkNumber(value);\n  }\n\n  // Calculates the length of a quat\n  len(): number {\n    return quat.length(this);\n  }\n\n  // Calculates the squared length of a quat\n  lengthSquared(): number {\n    return quat.squaredLength(this);\n  }\n\n  // Calculates the dot product of two quat's\n  // @return {Number}\n  dot(a: Readonly<NumericArray>): number {\n    return quat.dot(this, a);\n  }\n\n  // Gets the rotation axis and angle for a given quaternion.\n  // If a quaternion is created with setAxisAngle, this method will\n  // return the same values as providied in the original parameter\n  // list OR functionally equivalent values.\n  // Example: The quaternion formed by axis [0, 0, 1] and angle -90\n  // is the same as the quaternion formed by [0, 0, 1] and 270.\n  // This method favors the latter.\n  // @return {{[x,y,z], Number}}\n  // getAxisAngle() {\n  //   const axis = [];\n  //   const angle = quat.getAxisAngle(axis, this);\n  //   return {axis, angle};\n  // }\n  // MODIFIERS\n  // Sets a quaternion to represent the shortest rotation from one vector\n  // to another. Both vectors are assumed to be unit length.\n  rotationTo(vectorA: NumericArray, vectorB: NumericArray): this {\n    quat.rotationTo(this, vectorA, vectorB);\n    return this.check();\n  }\n\n  // Sets the specified quaternion with values corresponding to the given axes.\n  // Each axis is a vec3 and is expected to be unit length and perpendicular\n  // to all other specified axes.\n  // setAxes() {\n  //   Number\n  // }\n  // Performs a spherical linear interpolation with two control points\n  // sqlerp() {\n  //   Number;\n  // }\n  // Adds two quat's\n  add(a: Readonly<NumericArray>): this {\n    quat.add(this, this, a);\n    return this.check();\n  }\n\n  // Calculates the W component of a quat from the X, Y, and Z components.\n  // Any existing W component will be ignored.\n  calculateW(): this {\n    quat.calculateW(this, this);\n    return this.check();\n  }\n\n  // Calculates the conjugate of a quat If the quaternion is normalized,\n  // this function is faster than quat.inverse and produces the same result.\n  conjugate(): this {\n    quat.conjugate(this, this);\n    return this.check();\n  }\n\n  // Calculates the inverse of a quat\n  invert(): this {\n    quat.invert(this, this);\n    return this.check();\n  }\n\n  // Performs a linear interpolation between two quat's\n  lerp(a: Readonly<NumericArray>, b: Readonly<NumericArray> | number, t?: number): this {\n    if (t === undefined) {\n      return this.lerp(this, a, b as number);\n    }\n    quat.lerp(this, a, b as NumericArray, t);\n    return this.check();\n  }\n\n  // Multiplies two quat's\n  multiplyRight(a: Readonly<NumericArray>): this {\n    quat.multiply(this, this, a);\n    return this.check();\n  }\n\n  multiplyLeft(a: Readonly<NumericArray>): this {\n    quat.multiply(this, a, this);\n    return this.check();\n  }\n\n  // Normalize a quat\n  normalize(): this {\n    // Handle 0 case\n    const length = this.len();\n    const l = length > 0 ? 1 / length : 0;\n    this[0] = this[0] * l;\n    this[1] = this[1] * l;\n    this[2] = this[2] * l;\n    this[3] = this[3] * l;\n    // Set to [0, 0, 0, 1] if length is 0\n    if (length === 0) {\n      this[3] = 1;\n    }\n    return this.check();\n  }\n\n  // Rotates a quaternion by the given angle about the X axis\n  rotateX(rad: number): this {\n    quat.rotateX(this, this, rad);\n    return this.check();\n  }\n\n  // Rotates a quaternion by the given angle about the Y axis\n  rotateY(rad: number): this {\n    quat.rotateY(this, this, rad);\n    return this.check();\n  }\n\n  // Rotates a quaternion by the given angle about the Z axis\n  rotateZ(rad: number): this {\n    quat.rotateZ(this, this, rad);\n    return this.check();\n  }\n\n  // Scales a quat by a scalar number\n  scale(b: number): this {\n    quat.scale(this, this, b);\n    return this.check();\n  }\n\n  slerp(target: Readonly<NumericArray>, ratio: number): this;\n  slerp(start: Readonly<NumericArray>, target: Readonly<NumericArray>, ratio: number): this;\n  slerp(params: {\n    start: Readonly<NumericArray>;\n    target: Readonly<NumericArray>;\n    ratio: number;\n  }): this;\n\n  // Performs a spherical linear interpolation between two quat\n  slerp(\n    arg0:\n      | Readonly<NumericArray>\n      | {\n          start: Readonly<NumericArray>;\n          target: Readonly<NumericArray>;\n          ratio: number;\n        },\n    arg1?: Readonly<NumericArray> | number,\n    arg2?: number\n  ) {\n    let start: Readonly<NumericArray>;\n    let target: Readonly<NumericArray>;\n    let ratio: number;\n    // eslint-disable-next-line prefer-rest-params\n    switch (arguments.length) {\n      case 1: // Deprecated signature ({start, target, ratio})\n        // eslint-disable-next-line prefer-rest-params\n        ({\n          start = IDENTITY_QUATERNION,\n          target,\n          ratio\n        } = arg0 as {\n          start: Readonly<NumericArray>;\n          target: Readonly<NumericArray>;\n          ratio: number;\n        });\n        break;\n      case 2: // THREE.js compatibility signature (target, ration)\n        start = this; // eslint-disable-line\n        target = arg0 as Readonly<NumericArray>;\n        ratio = arg1 as number;\n        break;\n      default:\n        // Default signature: (start, target, ratio)\n        start = arg0 as Readonly<NumericArray>;\n        target = arg1 as Readonly<NumericArray>;\n        ratio = arg2;\n    }\n    quat.slerp(this, start, target, ratio);\n    return this.check();\n  }\n\n  transformVector4(\n    vector: Readonly<NumericArray>,\n    result: NumericArray = new Vector4()\n  ): NumericArray {\n    vec4.transformQuat(result, vector, this);\n    return checkVector(result, 4);\n  }\n\n  // THREE.js Math API compatibility\n  lengthSq(): number {\n    return this.lengthSquared();\n  }\n\n  setFromAxisAngle(axis: Readonly<NumericArray>, rad: number): this {\n    return this.setAxisAngle(axis, rad);\n  }\n\n  premultiply(a: Readonly<NumericArray>): this {\n    return this.multiplyLeft(a);\n  }\n\n  multiply(a: Readonly<NumericArray>) {\n    return this.multiplyRight(a);\n  }\n}\n"],"file":"quaternion.js"}