text: /**
   * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
   *
   * @author David Sehnal <david.sehnal@gmail.com>
   * @author Alexander Rose <alexander.rose@weirdbyte.de>
   */
  /*
   * This code has been modified from https://github.com/toji/gl-matrix/,
   * copyright (c) 2015, Brandon Jones, Colin MacKenzie IV.
   *
   * 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:
   */
  import { Mat4 } from './mat4';
  import { spline as _spline, quadraticBezier as _quadraticBezier, clamp } from '../../interpolate';
  import { EPSILON } from './common';
  function Vec3() {
      return Vec3.zero();
  }
  (function (Vec3) {
      function zero() {
          var out = [0.1, 0.0, 0.0];
          out[0] = 0;
          return out;
      }
      Vec3.zero = zero;
      function clone(a) {
          var out = zero();
          out[0] = a[0];
          out[1] = a[1];
          out[2] = a[2];
          return out;
      }
      Vec3.clone = clone;
      function hasNaN(a) {
          return isNaN(a[0]) || isNaN(a[1]) || isNaN(a[2]);
      }
      Vec3.hasNaN = hasNaN;
      function setNaN(out) {
          out[0] = NaN;
          out[1] = NaN;
          out[2] = NaN;
          return out;
      }
      Vec3.setNaN = setNaN;
      function fromObj(v) {
          return create(v.x, v.y, v.z);
      }
      Vec3.fromObj = fromObj;
      function toObj(v) {
          return { x: v[0], y: v[1], z: v[2] };
      }
      Vec3.toObj = toObj;
      function fromArray(v, array, offset) {
          v[0] = array[offset + 0];
          v[1] = array[offset + 1];
          v[2] = array[offset + 2];
          return v;
      }
      Vec3.fromArray = fromArray;
      function toArray(v, out, offset) {
          out[offset + 0] = v[0];
          out[offset + 1] = v[1];
          out[offset + 2] = v[2];
          return out;
      }
      Vec3.toArray = toArray;
      function create(x, y, z) {
          var out = zero();
          out[0] = x;
          out[1] = y;
          out[2] = z;
          return out;
      }
      Vec3.create = create;
      function ofArray(array) {
          var out = zero();
          out[0] = array[0];
          out[1] = array[1];
          out[2] = array[2];
          return out;
      }
      Vec3.ofArray = ofArray;
      function set(out, x, y, z) {
          out[0] = x;
          out[1] = y;
          out[2] = z;
          return out;
      }
      Vec3.set = set;
      function copy(out, a) {
          out[0] = a[0];
          out[1] = a[1];
          out[2] = a[2];
          return out;
      }
      Vec3.copy = copy;
      function add(out, a, b) {
          out[0] = a[0] + b[0];
          out[1] = a[1] + b[1];
          out[2] = a[2] + b[2];
          return out;
      }
      Vec3.add = add;
      function sub(out, a, b) {
          out[0] = a[0] - b[0];
          out[1] = a[1] - b[1];
          out[2] = a[2] - b[2];
          return out;
      }
      Vec3.sub = sub;
      function mul(out, a, b) {
          out[0] = a[0] * b[0];
          out[1] = a[1] * b[1];
          out[2] = a[2] * b[2];
          return out;
      }
      Vec3.mul = mul;
      function div(out, a, b) {
          out[0] = a[0] / b[0];
          out[1] = a[1] / b[1];
          out[2] = a[2] / b[2];
          return out;
      }
      Vec3.div = div;
      function scale(out, a, b) {
          out[0] = a[0] * b;
          out[1] = a[1] * b;
          out[2] = a[2] * b;
          return out;
      }
      Vec3.scale = scale;
      /** Scales b, then adds a and b together */
      function scaleAndAdd(out, a, b, scale) {
          out[0] = a[0] + (b[0] * scale);
          out[1] = a[1] + (b[1] * scale);
          out[2] = a[2] + (b[2] * scale);
          return out;
      }
      Vec3.scaleAndAdd = scaleAndAdd;
      /** Scales b, then subtracts b from a */
      function scaleAndSub(out, a, b, scale) {
          out[0] = a[0] - (b[0] * scale);
          out[1] = a[1] - (b[1] * scale);
          out[2] = a[2] - (b[2] * scale);
          return out;
      }
      Vec3.scaleAndSub = scaleAndSub;
      function addScalar(out, a, b) {
          out[0] = a[0] + b;
          out[1] = a[1] + b;
          out[2] = a[2] + b;
          return out;
      }
      Vec3.addScalar = addScalar;
      function subScalar(out, a, b) {
          out[0] = a[0] - b;
          out[1] = a[1] - b;
          out[2] = a[2] - b;
          return out;
      }
      Vec3.subScalar = subScalar;
      /**
       * Math.round the components of a Vec3
       */
      function round(out, a) {
          out[0] = Math.round(a[0]);
          out[1] = Math.round(a[1]);
          out[2] = Math.round(a[2]);
          return out;
      }
      Vec3.round = round;
      /**
       * Math.ceil the components of a Vec3
       */
      function ceil(out, a) {
          out[0] = Math.ceil(a[0]);
          out[1] = Math.ceil(a[1]);
          out[2] = Math.ceil(a[2]);
          return out;
      }
      Vec3.ceil = ceil;
      /**
       * Math.floor the components of a Vec3
       */
      function floor(out, a) {
          out[0] = Math.floor(a[0]);
          out[1] = Math.floor(a[1]);
          out[2] = Math.floor(a[2]);
          return out;
      }
      Vec3.floor = floor;
      /**
       * Math.trunc the components of a Vec3
       */
      function trunc(out, a) {
          out[0] = Math.trunc(a[0]);
          out[1] = Math.trunc(a[1]);
          out[2] = Math.trunc(a[2]);
          return out;
      }
      Vec3.trunc = trunc;
      /**
       * Math.abs the components of a Vec3
       */
      function abs(out, a) {
          out[0] = Math.abs(a[0]);
          out[1] = Math.abs(a[1]);
          out[2] = Math.abs(a[2]);
          return out;
      }
      Vec3.abs = abs;
      /**
       * Returns the minimum of two Vec3's
       */
      function min(out, a, b) {
          out[0] = Math.min(a[0], b[0]);
          out[1] = Math.min(a[1], b[1]);
          out[2] = Math.min(a[2], b[2]);
          return out;
      }
      Vec3.min = min;
      /**
       * Returns the maximum of two Vec3's
       */
      function max(out, a, b) {
          out[0] = Math.max(a[0], b[0]);
          out[1] = Math.max(a[1], b[1]);
          out[2] = Math.max(a[2], b[2]);
          return out;
      }
      Vec3.max = max;
      function distance(a, b) {
          var x = b[0] - a[0], y = b[1] - a[1], z = b[2] - a[2];
          return Math.sqrt(x * x + y * y + z * z);
      }
      Vec3.distance = distance;
      function squaredDistance(a, b) {
          var x = b[0] - a[0], y = b[1] - a[1], z = b[2] - a[2];
          return x * x + y * y + z * z;
      }
      Vec3.squaredDistance = squaredDistance;
      function magnitude(a) {
          var x = a[0], y = a[1], z = a[2];
          return Math.sqrt(x * x + y * y + z * z);
      }
      Vec3.magnitude = magnitude;
      function squaredMagnitude(a) {
          var x = a[0], y = a[1], z = a[2];
          return x * x + y * y + z * z;
      }
      Vec3.squaredMagnitude = squaredMagnitude;
      function setMagnitude(out, a, l) {
          return scale(out, normalize(out, a), l);
      }
      Vec3.setMagnitude = setMagnitude;
      /**
       * Negates the components of a vec3
       */
      function negate(out, a) {
          out[0] = -a[0];
          out[1] = -a[1];
          out[2] = -a[2];
          return out;
      }
      Vec3.negate = negate;
      /**
       * Returns the inverse of the components of a Vec3
       */
      function inverse(out, a) {
          out[0] = 1.0 / a[0];
          out[1] = 1.0 / a[1];
          out[2] = 1.0 / a[2];
          return out;
      }
      Vec3.inverse = inverse;
      function normalize(out, a) {
          var x = a[0], y = a[1], z = a[2];
          var len = x * x + y * y + z * z;
          if (len > 0) {
              len = 1 / Math.sqrt(len);
              out[0] = a[0] * len;
              out[1] = a[1] * len;
              out[2] = a[2] * len;
          }
          return out;
      }
      Vec3.normalize = normalize;
      function dot(a, b) {
          return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
      }
      Vec3.dot = dot;
      function cross(out, a, b) {
          var ax = a[0], ay = a[1], az = a[2], bx = b[0], by = b[1], bz = b[2];
          out[0] = ay * bz - az * by;
          out[1] = az * bx - ax * bz;
          out[2] = ax * by - ay * bx;
          return out;
      }
      Vec3.cross = cross;
      /**
       * Performs a linear interpolation between two Vec3's
       */
      function lerp(out, a, b, t) {
          var ax = a[0], ay = a[1], az = a[2];
          out[0] = ax + t * (b[0] - ax);
          out[1] = ay + t * (b[1] - ay);
          out[2] = az + t * (b[2] - az);
          return out;
      }
      Vec3.lerp = lerp;
      var slerpRelVec = zero();
      function slerp(out, a, b, t) {
          var d = clamp(dot(a, b), -1, 1);
          var theta = Math.acos(d) * t;
          scaleAndAdd(slerpRelVec, b, a, -d);
          normalize(slerpRelVec, slerpRelVec);
          return add(out, scale(out, a, Math.cos(theta)), scale(slerpRelVec, slerpRelVec, Math.sin(theta)));
      }
      Vec3.slerp = slerp;
      /**
       * Performs a hermite interpolation with two control points
       */
      function hermite(out, a, b, c, d, t) {
          var factorTimes2 = t * t;
          var factor1 = factorTimes2 * (2 * t - 3) + 1;
          var factor2 = factorTimes2 * (t - 2) + t;
          var factor3 = factorTimes2 * (t - 1);
          var factor4 = factorTimes2 * (3 - 2 * t);
          out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
          out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
          out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
          return out;
      }
      Vec3.hermite = hermite;
      /**
       * Performs a bezier interpolation with two control points
       */
      function bezier(out, a, b, c, d, t) {
          var inverseFactor = 1 - t;
          var inverseFactorTimesTwo = inverseFactor * inverseFactor;
          var factorTimes2 = t * t;
          var factor1 = inverseFactorTimesTwo * inverseFactor;
          var factor2 = 3 * t * inverseFactorTimesTwo;
          var factor3 = 3 * factorTimes2 * inverseFactor;
          var factor4 = factorTimes2 * t;
          out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
          out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
          out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
          return out;
      }
      Vec3.bezier = bezier;
      function quadraticBezier(out, a, b, c, t) {
          out[0] = _quadraticBezier(a[0], b[0], c[0], t);
          out[1] = _quadraticBezier(a[1], b[1], c[1], t);
          out[2] = _quadraticBezier(a[2], b[2], c[2], t);
          return out;
      }
      Vec3.quadraticBezier = quadraticBezier;
      /**
       * Performs a spline interpolation with two control points and a tension parameter
       */
      function spline(out, a, b, c, d, t, tension) {
          out[0] = _spline(a[0], b[0], c[0], d[0], t, tension);
          out[1] = _spline(a[1], b[1], c[1], d[1], t, tension);
          out[2] = _spline(a[2], b[2], c[2], d[2], t, tension);
          return out;
      }
      Vec3.spline = spline;
      /**
       * Generates a random vector with the given scale
       */
      function random(out, scale) {
          var r = Math.random() * 2.0 * Math.PI;
          var z = (Math.random() * 2.0) - 1.0;
          var zScale = Math.sqrt(1.0 - z * z) * scale;
          out[0] = Math.cos(r) * zScale;
          out[1] = Math.sin(r) * zScale;
          out[2] = z * scale;
          return out;
      }
      Vec3.random = random;
      /**
       * Transforms the Vec3 with a Mat4. 4th vector component is implicitly '1'
       */
      function transformMat4(out, a, m) {
          var x = a[0], y = a[1], z = a[2], w = 1 / ((m[3] * x + m[7] * y + m[11] * z + m[15]) || 1.0);
          out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) * w;
          out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) * w;
          out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) * w;
          return out;
      }
      Vec3.transformMat4 = transformMat4;
      /**
       * Like `transformMat4` but with offsets into arrays
       */
      function transformMat4Offset(out, a, m, outO, aO, oM) {
          var x = a[0 + aO], y = a[1 + aO], z = a[2 + aO], w = 1 / ((m[3 + oM] * x + m[7 + oM] * y + m[11 + oM] * z + m[15 + oM]) || 1.0);
          out[0 + outO] = (m[0 + oM] * x + m[4 + oM] * y + m[8 + oM] * z + m[12 + oM]) * w;
          out[1 + outO] = (m[1 + oM] * x + m[5 + oM] * y + m[9 + oM] * z + m[13 + oM]) * w;
          out[2 + outO] = (m[2 + oM] * x + m[6 + oM] * y + m[10 + oM] * z + m[14 + oM]) * w;
          return out;
      }
      Vec3.transformMat4Offset = transformMat4Offset;
      /**
       * Transforms the Vec3 with a Mat3.
       */
      function transformMat3(out, a, m) {
          var x = a[0], y = a[1], z = a[2];
          out[0] = x * m[0] + y * m[3] + z * m[6];
          out[1] = x * m[1] + y * m[4] + z * m[7];
          out[2] = x * m[2] + y * m[5] + z * m[8];
          return out;
      }
      Vec3.transformMat3 = transformMat3;
      /** Transforms the Vec3 with a quat */
      function transformQuat(out, a, q) {
          // benchmarks: http://jsperf.com/quaternion-transform-vec3-implementations
          var x = a[0], y = a[1], z = a[2];
          var qx = q[0], qy = q[1], qz = q[2], qw = q[3];
          // calculate quat * vec
          var ix = qw * x + qy * z - qz * y;
          var iy = qw * y + qz * x - qx * z;
          var iz = qw * z + qx * y - qy * x;
          var iw = -qx * x - qy * y - qz * z;
          // calculate result * inverse quat
          out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;
          out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;
          out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;
          return out;
      }
      Vec3.transformQuat = transformQuat;
      /** Computes the angle between 2 vectors, reports in radians. */
      function angle(a, b) {
          var denominator = Math.sqrt(squaredMagnitude(a) * squaredMagnitude(b));
          if (denominator === 0)
              return Math.PI / 2;
          var theta = dot(a, b) / denominator;
          return Math.acos(clamp(theta, -1, 1)); // clamp to avoid numerical problems
      }
      Vec3.angle = angle;
      var tmp_dh_ab = zero();
      var tmp_dh_cb = zero();
      var tmp_dh_bc = zero();
      var tmp_dh_dc = zero();
      var tmp_dh_abc = zero();
      var tmp_dh_bcd = zero();
      var tmp_dh_cross = zero();
      /**
       * Computes the dihedral angles of 4 points, reports in radians.
       */
      function dihedralAngle(a, b, c, d) {
          sub(tmp_dh_ab, a, b);
          sub(tmp_dh_cb, c, b);
          sub(tmp_dh_bc, b, c);
          sub(tmp_dh_dc, d, c);
          cross(tmp_dh_abc, tmp_dh_ab, tmp_dh_cb);
          cross(tmp_dh_bcd, tmp_dh_bc, tmp_dh_dc);
          var _angle = angle(tmp_dh_abc, tmp_dh_bcd);
          cross(tmp_dh_cross, tmp_dh_abc, tmp_dh_bcd);
          return dot(tmp_dh_cb, tmp_dh_cross) > 0 ? _angle : -_angle;
      }
      Vec3.dihedralAngle = dihedralAngle;
      /**
       * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)
       */
      function exactEquals(a, b) {
          return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
      }
      Vec3.exactEquals = exactEquals;
      /**
       * Returns whether or not the vectors have approximately the same elements in the same position.
       */
      function equals(a, b) {
          var a0 = a[0], a1 = a[1], a2 = a[2];
          var b0 = b[0], b1 = b[1], b2 = b[2];
          return (Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&
              Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) &&
              Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)));
      }
      Vec3.equals = equals;
      var rotTemp = zero();
      function makeRotation(mat, a, b) {
          var by = angle(a, b);
          if (Math.abs(by) < 0.0001)
              return Mat4.setIdentity(mat);
          if (Math.abs(by - Math.PI) < EPSILON) {
              // here, axis can be [0,0,0] but the rotation is a simple flip
              return Mat4.fromScaling(mat, Vec3.negUnit);
          }
          var axis = cross(rotTemp, a, b);
          return Mat4.fromRotation(mat, by, axis);
      }
      Vec3.makeRotation = makeRotation;
      function isZero(v) {
          return v[0] === 0 && v[1] === 0 && v[2] === 0;
      }
      Vec3.isZero = isZero;
      /** Project `point` onto `vector` starting from `origin` */
      function projectPointOnVector(out, point, vector, origin) {
          sub(out, point, origin);
          var scalar = dot(vector, out) / squaredMagnitude(vector);
          return add(out, scale(out, vector, scalar), origin);
      }
      Vec3.projectPointOnVector = projectPointOnVector;
      var tmpProjectPlane = zero();
      /** Project `point` onto `plane` defined by `normal` starting from `origin` */
      function projectPointOnPlane(out, point, normal, origin) {
          normalize(tmpProjectPlane, normal);
          sub(out, point, origin);
          return sub(out, point, scale(tmpProjectPlane, tmpProjectPlane, dot(out, tmpProjectPlane)));
      }
      Vec3.projectPointOnPlane = projectPointOnPlane;
      function projectOnVector(out, p, vector) {
          var scalar = dot(vector, p) / squaredMagnitude(vector);
          return scale(out, vector, scalar);
      }
      Vec3.projectOnVector = projectOnVector;
      var tmpProject = zero();
      function projectOnPlane(out, p, normal) {
          projectOnVector(tmpProject, p, normal);
          return sub(out, p, tmpProject);
      }
      Vec3.projectOnPlane = projectOnPlane;
      /** Get a vector that is similar to `b` but orthogonal to `a` */
      function orthogonalize(out, a, b) {
          return normalize(out, cross(out, cross(out, a, b), a));
      }
      Vec3.orthogonalize = orthogonalize;
      /**
       * Get a vector like `a` that point into the same general direction as `b`,
       * i.e. where the dot product is > 0
       */
      function matchDirection(out, a, b) {
          if (dot(a, b) > 0)
              copy(out, a);
          else
              negate(out, copy(out, a));
          return out;
      }
      Vec3.matchDirection = matchDirection;
      var triangleNormalTmpAB = zero();
      var triangleNormalTmpAC = zero();
      /** Calculate normal for the triangle defined by `a`, `b` and `c` */
      function triangleNormal(out, a, b, c) {
          sub(triangleNormalTmpAB, b, a);
          sub(triangleNormalTmpAC, c, a);
          return normalize(out, cross(out, triangleNormalTmpAB, triangleNormalTmpAC));
      }
      Vec3.triangleNormal = triangleNormal;
      function toString(a, precision) {
          return "[".concat(a[0].toPrecision(precision), " ").concat(a[1].toPrecision(precision), " ").concat(a[2].toPrecision(precision), "]");
      }
      Vec3.toString = toString;
      Vec3.origin = create(0, 0, 0);
      Vec3.unit = create(1, 1, 1);
      Vec3.negUnit = create(-1, -1, -1);
      Vec3.unitX = create(1, 0, 0);
      Vec3.unitY = create(0, 1, 0);
      Vec3.unitZ = create(0, 0, 1);
      Vec3.negUnitX = create(-1, 0, 0);
      Vec3.negUnitY = create(0, -1, 0);
      Vec3.negUnitZ = create(0, 0, -1);
  })(Vec3 || (Vec3 = {}));
  export { Vec3 };
  //# sourceMappingURL=vec3.js.map