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

package/dist/es5/classes/euler.js

@@ -7,553 +7,648 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _mathArray = _interopRequireDefault(require("./base/math-array"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 
-var _common = require("../lib/common");
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
-var _validators = require("../lib/validators");
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-var _quaternion = _interopRequireDefault(require("./quaternion"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 
-const ERR_UNKNOWN_ORDER = 'Unknown Euler angle order';
-const ALMOST_ONE = 0.99999;
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
 
-function validateOrder(value) {
-  return value >= 0 && value < 6;
-}
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
-function checkOrder(value) {
-  if (value < 0 && value >= 6) {
-    throw new Error(ERR_UNKNOWN_ORDER);
-  }
+var _mathArray = _interopRequireDefault(require("./base/math-array"));
 
-  return value;
-}
+var _quaternion2 = _interopRequireDefault(require("./quaternion"));
 
-class Euler extends _mathArray.default {
-  static get ZYX() {
-    return 0;
-  }
+var _common = require("../lib/common");
 
-  static get YXZ() {
-    return 1;
-  }
+var _validators = require("../lib/validators");
 
-  static get XZY() {
-    return 2;
-  }
+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); }; }
 
-  static get ZXY() {
-    return 3;
-  }
+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; } }
 
-  static get YZX() {
-    return 4;
-  }
+var ERR_UNKNOWN_ORDER = 'Unknown Euler angle order';
+var ALMOST_ONE = 0.99999;
+var RotationOrder;
 
-  static get XYZ() {
-    return 5;
-  }
+(function (RotationOrder) {
+  RotationOrder[RotationOrder["ZYX"] = 0] = "ZYX";
+  RotationOrder[RotationOrder["YXZ"] = 1] = "YXZ";
+  RotationOrder[RotationOrder["XZY"] = 2] = "XZY";
+  RotationOrder[RotationOrder["ZXY"] = 3] = "ZXY";
+  RotationOrder[RotationOrder["YZX"] = 4] = "YZX";
+  RotationOrder[RotationOrder["XYZ"] = 5] = "XYZ";
+})(RotationOrder || (RotationOrder = {}));
 
-  static get RollPitchYaw() {
-    return 0;
-  }
+var Euler = function (_MathArray) {
+  (0, _inherits2.default)(Euler, _MathArray);
 
-  static get DefaultOrder() {
-    return Euler.ZYX;
-  }
-
-  static get RotationOrders() {
-    return ['ZYX', 'YXZ', 'XZY', 'ZXY', 'YZX', 'XYZ'];
-  }
+  var _super = _createSuper(Euler);
 
-  static rotationOrder(order) {
-    return Euler.RotationOrders[order];
-  }
-
-  get ELEMENTS() {
-    return 4;
-  }
+  function Euler() {
+    var _this;
 
-  constructor(x = 0, y = 0, z = 0, order = Euler.DefaultOrder) {
-    super(-0, -0, -0, -0);
+    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 order = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : Euler.DefaultOrder;
+    (0, _classCallCheck2.default)(this, Euler);
+    _this = _super.call(this, -0, -0, -0, -0);
 
     if (arguments.length > 0 && Array.isArray(arguments[0])) {
-      this.fromVector3(...arguments);
+      var _this2;
+
+      (_this2 = _this).fromVector3.apply(_this2, arguments);
     } else {
-      this.set(x, y, z, order);
+      _this.set(x, y, z, order);
     }
-  }
 
-  fromQuaternion(quaternion) {
-    const [x, y, z, w] = quaternion;
-    const ysqr = y * y;
-    const t0 = -2.0 * (ysqr + z * z) + 1.0;
-    const t1 = +2.0 * (x * y + w * z);
-    let t2 = -2.0 * (x * z - w * y);
-    const t3 = +2.0 * (y * z + w * x);
-    const t4 = -2.0 * (x * x + ysqr) + 1.0;
-    t2 = t2 > 1.0 ? 1.0 : t2;
-    t2 = t2 < -1.0 ? -1.0 : t2;
-    const roll = Math.atan2(t3, t4);
-    const pitch = Math.asin(t2);
-    const yaw = Math.atan2(t1, t0);
-    return new Euler(roll, pitch, yaw, Euler.RollPitchYaw);
+    return _this;
   }
 
-  copy(array) {
-    this[0] = array[0];
-    this[1] = array[1];
-    this[2] = array[2];
-    this[3] = Number.isFinite(array[3]) || this.order;
-    return this.check();
-  }
-
-  set(x = 0, y = 0, z = 0, order) {
-    this[0] = x;
-    this[1] = y;
-    this[2] = z;
-    this[3] = Number.isFinite(order) ? order : this[3];
-    return this.check();
-  }
-
-  validate() {
-    return validateOrder(this[3]) && Number.isFinite(this[0]) && Number.isFinite(this[1]) && Number.isFinite(this[2]);
-  }
-
-  toArray(array = [], offset = 0) {
-    array[offset] = this[0];
-    array[offset + 1] = this[1];
-    array[offset + 2] = this[2];
-    return array;
-  }
-
-  toArray4(array = [], offset = 0) {
-    array[offset] = this[0];
-    array[offset + 1] = this[1];
-    array[offset + 2] = this[2];
-    array[offset + 3] = this[3];
-    return array;
-  }
-
-  toVector3(result = [-0, -0, -0]) {
-    result[0] = this[0];
-    result[1] = this[1];
-    result[2] = this[2];
-    return result;
-  }
-
-  get x() {
-    return this[0];
-  }
-
-  set x(value) {
-    this[0] = (0, _validators.checkNumber)(value);
-  }
-
-  get y() {
-    return this[1];
-  }
-
-  set y(value) {
-    this[1] = (0, _validators.checkNumber)(value);
-  }
-
-  get z() {
-    return this[2];
-  }
-
-  set z(value) {
-    this[2] = (0, _validators.checkNumber)(value);
-  }
-
-  get alpha() {
-    return this[0];
-  }
-
-  set alpha(value) {
-    this[0] = (0, _validators.checkNumber)(value);
-  }
-
-  get beta() {
-    return this[1];
-  }
-
-  set beta(value) {
-    this[1] = (0, _validators.checkNumber)(value);
-  }
-
-  get gamma() {
-    return this[2];
-  }
-
-  set gamma(value) {
-    this[2] = (0, _validators.checkNumber)(value);
-  }
-
-  get phi() {
-    return this[0];
-  }
-
-  set phi(value) {
-    this[0] = (0, _validators.checkNumber)(value);
-  }
-
-  get theta() {
-    return this[1];
-  }
+  (0, _createClass2.default)(Euler, [{
+    key: "ELEMENTS",
+    get: function get() {
+      return 4;
+    }
+  }, {
+    key: "fromQuaternion",
+    value: function fromQuaternion(quaternion) {
+      var _quaternion = (0, _slicedToArray2.default)(quaternion, 4),
+          x = _quaternion[0],
+          y = _quaternion[1],
+          z = _quaternion[2],
+          w = _quaternion[3];
+
+      var ysqr = y * y;
+      var t0 = -2 * (ysqr + z * z) + 1;
+      var t1 = +2 * (x * y + w * z);
+      var t2 = -2 * (x * z - w * y);
+      var t3 = +2 * (y * z + w * x);
+      var t4 = -2 * (x * x + ysqr) + 1;
+      t2 = t2 > 1 ? 1 : t2;
+      t2 = t2 < -1 ? -1 : t2;
+      var roll = Math.atan2(t3, t4);
+      var pitch = Math.asin(t2);
+      var yaw = Math.atan2(t1, t0);
+      return this.set(roll, pitch, yaw, Euler.RollPitchYaw);
+    }
+  }, {
+    key: "fromObject",
+    value: function fromObject(object) {
+      throw new Error('not implemented');
+    }
+  }, {
+    key: "copy",
+    value: function copy(array) {
+      this[0] = array[0];
+      this[1] = array[1];
+      this[2] = array[2];
+      this[3] = Number.isFinite(array[3]) || this.order;
+      return this.check();
+    }
+  }, {
+    key: "set",
+    value: function set() {
+      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 order = arguments.length > 3 ? arguments[3] : undefined;
+      this[0] = x;
+      this[1] = y;
+      this[2] = z;
+      this[3] = Number.isFinite(order) ? order : this[3];
+      return this.check();
+    }
+  }, {
+    key: "validate",
+    value: function validate() {
+      return validateOrder(this[3]) && Number.isFinite(this[0]) && Number.isFinite(this[1]) && Number.isFinite(this[2]);
+    }
+  }, {
+    key: "toArray",
+    value: function toArray() {
+      var array = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      array[offset] = this[0];
+      array[offset + 1] = this[1];
+      array[offset + 2] = this[2];
+      return array;
+    }
+  }, {
+    key: "toArray4",
+    value: function toArray4() {
+      var array = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      array[offset] = this[0];
+      array[offset + 1] = this[1];
+      array[offset + 2] = this[2];
+      array[offset + 3] = this[3];
+      return array;
+    }
+  }, {
+    key: "toVector3",
+    value: function toVector3() {
+      var result = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [-0, -0, -0];
+      result[0] = this[0];
+      result[1] = this[1];
+      result[2] = this[2];
+      return result;
+    }
+  }, {
+    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: "alpha",
+    get: function get() {
+      return this[0];
+    },
+    set: function set(value) {
+      this[0] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "beta",
+    get: function get() {
+      return this[1];
+    },
+    set: function set(value) {
+      this[1] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "gamma",
+    get: function get() {
+      return this[2];
+    },
+    set: function set(value) {
+      this[2] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "phi",
+    get: function get() {
+      return this[0];
+    },
+    set: function set(value) {
+      this[0] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "theta",
+    get: function get() {
+      return this[1];
+    },
+    set: function set(value) {
+      this[1] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "psi",
+    get: function get() {
+      return this[2];
+    },
+    set: function set(value) {
+      this[2] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "roll",
+    get: function get() {
+      return this[0];
+    },
+    set: function set(value) {
+      this[0] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "pitch",
+    get: function get() {
+      return this[1];
+    },
+    set: function set(value) {
+      this[1] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "yaw",
+    get: function get() {
+      return this[2];
+    },
+    set: function set(value) {
+      this[2] = (0, _validators.checkNumber)(value);
+    }
+  }, {
+    key: "order",
+    get: function get() {
+      return this[3];
+    },
+    set: function set(value) {
+      this[3] = checkOrder(value);
+    }
+  }, {
+    key: "fromVector3",
+    value: function fromVector3(v, order) {
+      return this.set(v[0], v[1], v[2], Number.isFinite(order) ? order : this[3]);
+    }
+  }, {
+    key: "fromArray",
+    value: function fromArray(array) {
+      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      this[0] = array[0 + offset];
+      this[1] = array[1 + offset];
+      this[2] = array[2 + offset];
+
+      if (array[3] !== undefined) {
+        this[3] = array[3];
+      }
+
+      return this.check();
+    }
+  }, {
+    key: "fromRollPitchYaw",
+    value: function fromRollPitchYaw(roll, pitch, yaw) {
+      return this.set(roll, pitch, yaw, RotationOrder.ZYX);
+    }
+  }, {
+    key: "fromRotationMatrix",
+    value: function fromRotationMatrix(m) {
+      var order = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Euler.DefaultOrder;
 
-  set theta(value) {
-    this[1] = (0, _validators.checkNumber)(value);
-  }
+      this._fromRotationMatrix(m, order);
 
-  get psi() {
-    return this[2];
-  }
+      return this.check();
+    }
+  }, {
+    key: "getRotationMatrix",
+    value: function getRotationMatrix(m) {
+      return this._getRotationMatrix(m);
+    }
+  }, {
+    key: "getQuaternion",
+    value: function getQuaternion() {
+      var q = new _quaternion2.default();
 
-  set psi(value) {
-    this[2] = (0, _validators.checkNumber)(value);
-  }
+      switch (this[4]) {
+        case RotationOrder.XYZ:
+          return q.rotateX(this[0]).rotateY(this[1]).rotateZ(this[2]);
 
-  get roll() {
-    return this[0];
-  }
+        case RotationOrder.YXZ:
+          return q.rotateY(this[0]).rotateX(this[1]).rotateZ(this[2]);
 
-  set roll(value) {
-    this[0] = (0, _validators.checkNumber)(value);
-  }
+        case RotationOrder.ZXY:
+          return q.rotateZ(this[0]).rotateX(this[1]).rotateY(this[2]);
 
-  get pitch() {
-    return this[1];
-  }
+        case RotationOrder.ZYX:
+          return q.rotateZ(this[0]).rotateY(this[1]).rotateX(this[2]);
 
-  set pitch(value) {
-    this[1] = (0, _validators.checkNumber)(value);
-  }
+        case RotationOrder.YZX:
+          return q.rotateY(this[0]).rotateZ(this[1]).rotateX(this[2]);
 
-  get yaw() {
-    return this[2];
-  }
+        case RotationOrder.XZY:
+          return q.rotateX(this[0]).rotateZ(this[1]).rotateY(this[2]);
 
-  set yaw(value) {
-    this[2] = (0, _validators.checkNumber)(value);
-  }
+        default:
+          throw new Error(ERR_UNKNOWN_ORDER);
+      }
+    }
+  }, {
+    key: "_fromRotationMatrix",
+    value: function _fromRotationMatrix(m) {
+      var order = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Euler.DefaultOrder;
+      var m11 = m[0],
+          m12 = m[4],
+          m13 = m[8];
+      var m21 = m[1],
+          m22 = m[5],
+          m23 = m[9];
+      var m31 = m[2],
+          m32 = m[6],
+          m33 = m[10];
+      order = order || this[3];
+
+      switch (order) {
+        case Euler.XYZ:
+          this[1] = Math.asin((0, _common.clamp)(m13, -1, 1));
+
+          if (Math.abs(m13) < ALMOST_ONE) {
+            this[0] = Math.atan2(-m23, m33);
+            this[2] = Math.atan2(-m12, m11);
+          } else {
+            this[0] = Math.atan2(m32, m22);
+            this[2] = 0;
+          }
 
-  get order() {
-    return this[3];
-  }
+          break;
 
-  set order(value) {
-    this[3] = checkOrder(value);
-  }
+        case Euler.YXZ:
+          this[0] = Math.asin(-(0, _common.clamp)(m23, -1, 1));
 
-  fromVector3(v, order) {
-    return this.set(v[0], v[1], v[2], Number.isFinite(order) ? order : this[3]);
-  }
+          if (Math.abs(m23) < ALMOST_ONE) {
+            this[1] = Math.atan2(m13, m33);
+            this[2] = Math.atan2(m21, m22);
+          } else {
+            this[1] = Math.atan2(-m31, m11);
+            this[2] = 0;
+          }
 
-  fromArray(array, offset = 0) {
-    this[0] = array[0 + offset];
-    this[1] = array[1 + offset];
-    this[2] = array[2 + offset];
+          break;
 
-    if (array[3] !== undefined) {
-      this[3] = array[3];
-    }
+        case Euler.ZXY:
+          this[0] = Math.asin((0, _common.clamp)(m32, -1, 1));
 
-    return this.check();
-  }
+          if (Math.abs(m32) < ALMOST_ONE) {
+            this[1] = Math.atan2(-m31, m33);
+            this[2] = Math.atan2(-m12, m22);
+          } else {
+            this[1] = 0;
+            this[2] = Math.atan2(m21, m11);
+          }
 
-  fromRollPitchYaw(roll, pitch, yaw) {
-    return this.set(roll, pitch, yaw, Euler.ZYX);
-  }
+          break;
 
-  fromRotationMatrix(m, order = Euler.DefaultOrder) {
-    this._fromRotationMatrix(m, order);
+        case Euler.ZYX:
+          this[1] = Math.asin(-(0, _common.clamp)(m31, -1, 1));
 
-    return this.check();
-  }
+          if (Math.abs(m31) < ALMOST_ONE) {
+            this[0] = Math.atan2(m32, m33);
+            this[2] = Math.atan2(m21, m11);
+          } else {
+            this[0] = 0;
+            this[2] = Math.atan2(-m12, m22);
+          }
 
-  getRotationMatrix(m) {
-    return this._getRotationMatrix(m);
-  }
+          break;
 
-  getQuaternion() {
-    const q = new _quaternion.default();
+        case Euler.YZX:
+          this[2] = Math.asin((0, _common.clamp)(m21, -1, 1));
 
-    switch (this[3]) {
-      case Euler.XYZ:
-        return q.rotateX(this[0]).rotateY(this[1]).rotateZ(this[2]);
+          if (Math.abs(m21) < ALMOST_ONE) {
+            this[0] = Math.atan2(-m23, m22);
+            this[1] = Math.atan2(-m31, m11);
+          } else {
+            this[0] = 0;
+            this[1] = Math.atan2(m13, m33);
+          }
 
-      case Euler.YXZ:
-        return q.rotateY(this[0]).rotateX(this[1]).rotateZ(this[2]);
+          break;
 
-      case Euler.ZXY:
-        return q.rotateZ(this[0]).rotateX(this[1]).rotateY(this[2]);
+        case Euler.XZY:
+          this[2] = Math.asin(-(0, _common.clamp)(m12, -1, 1));
 
-      case Euler.ZYX:
-        return q.rotateZ(this[0]).rotateY(this[1]).rotateX(this[2]);
+          if (Math.abs(m12) < ALMOST_ONE) {
+            this[0] = Math.atan2(m32, m22);
+            this[1] = Math.atan2(m13, m11);
+          } else {
+            this[0] = Math.atan2(-m23, m33);
+            this[1] = 0;
+          }
 
-      case Euler.YZX:
-        return q.rotateY(this[0]).rotateZ(this[1]).rotateX(this[2]);
+          break;
 
-      case Euler.XZY:
-        return q.rotateX(this[0]).rotateZ(this[1]).rotateY(this[2]);
+        default:
+          throw new Error(ERR_UNKNOWN_ORDER);
+      }
 
-      default:
-        throw new Error(ERR_UNKNOWN_ORDER);
+      this[3] = order;
+      return this;
     }
-  }
-
-  _fromRotationMatrix(m, order = Euler.DefaultOrder) {
-    const te = m.elements;
-    const m11 = te[0],
-          m12 = te[4],
-          m13 = te[8];
-    const m21 = te[1],
-          m22 = te[5],
-          m23 = te[9];
-    const m31 = te[2],
-          m32 = te[6],
-          m33 = te[10];
-    order = order || this[3];
-
-    switch (order) {
-      case Euler.XYZ:
-        this[1] = Math.asin((0, _common.clamp)(m13, -1, 1));
-
-        if (Math.abs(m13) < ALMOST_ONE) {
-          this[0] = Math.atan2(-m23, m33);
-          this[2] = Math.atan2(-m12, m11);
-        } else {
-          this[0] = Math.atan2(m32, m22);
-          this[2] = 0;
-        }
-
-        break;
-
-      case Euler.YXZ:
-        this[0] = Math.asin(-(0, _common.clamp)(m23, -1, 1));
-
-        if (Math.abs(m23) < ALMOST_ONE) {
-          this[1] = Math.atan2(m13, m33);
-          this[2] = Math.atan2(m21, m22);
-        } else {
-          this[1] = Math.atan2(-m31, m11);
-          this[2] = 0;
-        }
-
-        break;
-
-      case Euler.ZXY:
-        this[0] = Math.asin((0, _common.clamp)(m32, -1, 1));
-
-        if (Math.abs(m32) < ALMOST_ONE) {
-          this[1] = Math.atan2(-m31, m33);
-          this[2] = Math.atan2(-m12, m22);
-        } else {
-          this[1] = 0;
-          this[2] = Math.atan2(m21, m11);
-        }
-
-        break;
-
-      case Euler.ZYX:
-        this[1] = Math.asin(-(0, _common.clamp)(m31, -1, 1));
-
-        if (Math.abs(m31) < ALMOST_ONE) {
-          this[0] = Math.atan2(m32, m33);
-          this[2] = Math.atan2(m21, m11);
-        } else {
-          this[0] = 0;
-          this[2] = Math.atan2(-m12, m22);
-        }
-
-        break;
-
-      case Euler.YZX:
-        this[2] = Math.asin((0, _common.clamp)(m21, -1, 1));
-
-        if (Math.abs(m21) < ALMOST_ONE) {
-          this[0] = Math.atan2(-m23, m22);
-          this[1] = Math.atan2(-m31, m11);
-        } else {
-          this[0] = 0;
-          this[1] = Math.atan2(m13, m33);
-        }
-
-        break;
-
-      case Euler.XZY:
-        this[2] = Math.asin(-(0, _common.clamp)(m12, -1, 1));
-
-        if (Math.abs(m12) < ALMOST_ONE) {
-          this[0] = Math.atan2(m32, m22);
-          this[1] = Math.atan2(m13, m11);
-        } else {
-          this[0] = Math.atan2(-m23, m33);
-          this[1] = 0;
-        }
-
-        break;
-
-      default:
-        throw new Error(ERR_UNKNOWN_ORDER);
-    }
-
-    this[3] = order;
-    return this;
-  }
-
-  _getRotationMatrix(result) {
-    const te = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
-    const x = this.x,
+  }, {
+    key: "_getRotationMatrix",
+    value: function _getRotationMatrix(result) {
+      var te = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
+      var x = this.x,
           y = this.y,
           z = this.z;
-    const a = Math.cos(x);
-    const c = Math.cos(y);
-    const e = Math.cos(z);
-    const b = Math.sin(x);
-    const d = Math.sin(y);
-    const f = Math.sin(z);
-
-    switch (this[3]) {
-      case Euler.XYZ:
-        {
-          const ae = a * e,
+      var a = Math.cos(x);
+      var c = Math.cos(y);
+      var e = Math.cos(z);
+      var b = Math.sin(x);
+      var d = Math.sin(y);
+      var f = Math.sin(z);
+
+      switch (this[3]) {
+        case Euler.XYZ:
+          {
+            var ae = a * e,
                 af = a * f,
                 be = b * e,
                 bf = b * f;
-          te[0] = c * e;
-          te[4] = -c * f;
-          te[8] = d;
-          te[1] = af + be * d;
-          te[5] = ae - bf * d;
-          te[9] = -b * c;
-          te[2] = bf - ae * d;
-          te[6] = be + af * d;
-          te[10] = a * c;
-          break;
-        }
-
-      case Euler.YXZ:
-        {
-          const ce = c * e,
+            te[0] = c * e;
+            te[4] = -c * f;
+            te[8] = d;
+            te[1] = af + be * d;
+            te[5] = ae - bf * d;
+            te[9] = -b * c;
+            te[2] = bf - ae * d;
+            te[6] = be + af * d;
+            te[10] = a * c;
+            break;
+          }
+
+        case Euler.YXZ:
+          {
+            var ce = c * e,
                 cf = c * f,
                 de = d * e,
                 df = d * f;
-          te[0] = ce + df * b;
-          te[4] = de * b - cf;
-          te[8] = a * d;
-          te[1] = a * f;
-          te[5] = a * e;
-          te[9] = -b;
-          te[2] = cf * b - de;
-          te[6] = df + ce * b;
-          te[10] = a * c;
-          break;
-        }
-
-      case Euler.ZXY:
-        {
-          const ce = c * e,
-                cf = c * f,
-                de = d * e,
-                df = d * f;
-          te[0] = ce - df * b;
-          te[4] = -a * f;
-          te[8] = de + cf * b;
-          te[1] = cf + de * b;
-          te[5] = a * e;
-          te[9] = df - ce * b;
-          te[2] = -a * d;
-          te[6] = b;
-          te[10] = a * c;
-          break;
-        }
-
-      case Euler.ZYX:
-        {
-          const ae = a * e,
-                af = a * f,
-                be = b * e,
-                bf = b * f;
-          te[0] = c * e;
-          te[4] = be * d - af;
-          te[8] = ae * d + bf;
-          te[1] = c * f;
-          te[5] = bf * d + ae;
-          te[9] = af * d - be;
-          te[2] = -d;
-          te[6] = b * c;
-          te[10] = a * c;
-          break;
-        }
-
-      case Euler.YZX:
-        {
-          const ac = a * c,
-                ad = a * d,
-                bc = b * c,
-                bd = b * d;
-          te[0] = c * e;
-          te[4] = bd - ac * f;
-          te[8] = bc * f + ad;
-          te[1] = f;
-          te[5] = a * e;
-          te[9] = -b * e;
-          te[2] = -d * e;
-          te[6] = ad * f + bc;
-          te[10] = ac - bd * f;
-          break;
-        }
-
-      case Euler.XZY:
-        {
-          const ac = a * c,
+            te[0] = ce + df * b;
+            te[4] = de * b - cf;
+            te[8] = a * d;
+            te[1] = a * f;
+            te[5] = a * e;
+            te[9] = -b;
+            te[2] = cf * b - de;
+            te[6] = df + ce * b;
+            te[10] = a * c;
+            break;
+          }
+
+        case Euler.ZXY:
+          {
+            var _ce = c * e,
+                _cf = c * f,
+                _de = d * e,
+                _df = d * f;
+
+            te[0] = _ce - _df * b;
+            te[4] = -a * f;
+            te[8] = _de + _cf * b;
+            te[1] = _cf + _de * b;
+            te[5] = a * e;
+            te[9] = _df - _ce * b;
+            te[2] = -a * d;
+            te[6] = b;
+            te[10] = a * c;
+            break;
+          }
+
+        case Euler.ZYX:
+          {
+            var _ae = a * e,
+                _af = a * f,
+                _be = b * e,
+                _bf = b * f;
+
+            te[0] = c * e;
+            te[4] = _be * d - _af;
+            te[8] = _ae * d + _bf;
+            te[1] = c * f;
+            te[5] = _bf * d + _ae;
+            te[9] = _af * d - _be;
+            te[2] = -d;
+            te[6] = b * c;
+            te[10] = a * c;
+            break;
+          }
+
+        case Euler.YZX:
+          {
+            var ac = a * c,
                 ad = a * d,
                 bc = b * c,
                 bd = b * d;
-          te[0] = c * e;
-          te[4] = -f;
-          te[8] = d * e;
-          te[1] = ac * f + bd;
-          te[5] = a * e;
-          te[9] = ad * f - bc;
-          te[2] = bc * f - ad;
-          te[6] = b * e;
-          te[10] = bd * f + ac;
-          break;
-        }
-
-      default:
-        throw new Error(ERR_UNKNOWN_ORDER);
+            te[0] = c * e;
+            te[4] = bd - ac * f;
+            te[8] = bc * f + ad;
+            te[1] = f;
+            te[5] = a * e;
+            te[9] = -b * e;
+            te[2] = -d * e;
+            te[6] = ad * f + bc;
+            te[10] = ac - bd * f;
+            break;
+          }
+
+        case Euler.XZY:
+          {
+            var _ac = a * c,
+                _ad = a * d,
+                _bc = b * c,
+                _bd = b * d;
+
+            te[0] = c * e;
+            te[4] = -f;
+            te[8] = d * e;
+            te[1] = _ac * f + _bd;
+            te[5] = a * e;
+            te[9] = _ad * f - _bc;
+            te[2] = _bc * f - _ad;
+            te[6] = b * e;
+            te[10] = _bd * f + _ac;
+            break;
+          }
+
+        default:
+          throw new Error(ERR_UNKNOWN_ORDER);
+      }
+
+      te[3] = 0;
+      te[7] = 0;
+      te[11] = 0;
+      te[12] = 0;
+      te[13] = 0;
+      te[14] = 0;
+      te[15] = 1;
+      return te;
+    }
+  }, {
+    key: "toQuaternion",
+    value: function toQuaternion() {
+      var cy = Math.cos(this.yaw * 0.5);
+      var sy = Math.sin(this.yaw * 0.5);
+      var cr = Math.cos(this.roll * 0.5);
+      var sr = Math.sin(this.roll * 0.5);
+      var cp = Math.cos(this.pitch * 0.5);
+      var sp = Math.sin(this.pitch * 0.5);
+      var w = cy * cr * cp + sy * sr * sp;
+      var x = cy * sr * cp - sy * cr * sp;
+      var y = cy * cr * sp + sy * sr * cp;
+      var z = sy * cr * cp - cy * sr * sp;
+      return new _quaternion2.default(x, y, z, w);
+    }
+  }], [{
+    key: "ZYX",
+    get: function get() {
+      return RotationOrder.ZYX;
     }
+  }, {
+    key: "YXZ",
+    get: function get() {
+      return RotationOrder.YXZ;
+    }
+  }, {
+    key: "XZY",
+    get: function get() {
+      return RotationOrder.XZY;
+    }
+  }, {
+    key: "ZXY",
+    get: function get() {
+      return RotationOrder.ZXY;
+    }
+  }, {
+    key: "YZX",
+    get: function get() {
+      return RotationOrder.YZX;
+    }
+  }, {
+    key: "XYZ",
+    get: function get() {
+      return RotationOrder.XYZ;
+    }
+  }, {
+    key: "RollPitchYaw",
+    get: function get() {
+      return RotationOrder.ZYX;
+    }
+  }, {
+    key: "DefaultOrder",
+    get: function get() {
+      return RotationOrder.ZYX;
+    }
+  }, {
+    key: "RotationOrders",
+    get: function get() {
+      return RotationOrder;
+    }
+  }, {
+    key: "rotationOrder",
+    value: function rotationOrder(order) {
+      return RotationOrder[order];
+    }
+  }]);
+  return Euler;
+}(_mathArray.default);
 
-    te[3] = 0;
-    te[7] = 0;
-    te[11] = 0;
-    te[12] = 0;
-    te[13] = 0;
-    te[14] = 0;
-    te[15] = 1;
-    return te;
-  }
+exports.default = Euler;
 
-  toQuaternion() {
-    const cy = Math.cos(this.yaw * 0.5);
-    const sy = Math.sin(this.yaw * 0.5);
-    const cr = Math.cos(this.roll * 0.5);
-    const sr = Math.sin(this.roll * 0.5);
-    const cp = Math.cos(this.pitch * 0.5);
-    const sp = Math.sin(this.pitch * 0.5);
-    const w = cy * cr * cp + sy * sr * sp;
-    const x = cy * sr * cp - sy * cr * sp;
-    const y = cy * cr * sp + sy * sr * cp;
-    const z = sy * cr * cp - cy * sr * sp;
-    return new _quaternion.default(x, y, z, w);
+function validateOrder(value) {
+  return value >= 0 && value < 6;
+}
+
+function checkOrder(value) {
+  if (value < 0 && value >= 6) {
+    throw new Error(ERR_UNKNOWN_ORDER);
   }
 
+  return value;
 }
-
-exports.default = Euler;
 //# sourceMappingURL=euler.js.map