add `quat.getEuler`

[xieguanglei]

Thanks for the great library!

Sometimes I need to covert quatarnion to eular angles, and I can not find how to do it. It would be greate if there's a quat.getEuler method.

[stefnotch]

Here is an example implementation:

// TODO: Unit tests

/**
 * Returns an euler angle representation of a quaternion
 * @param  {vec3} out Euler angles, pitch-yaw-roll
 * @param  {quat} mat Quaternion
 * @return {vec3} out
 */
export function getEuler(out, quat) {
  let x = quat[0],
    y = quat[1],
    z = quat[2],
    w = quat[3],
    x2 = x * x,
    y2 = y * y,
    z2 = z * z,
    w2 = w * w;
  let unit = x2 + y2 + z2 + w2;
  let test = x * w - y * z;
  if (test > 0.499995 * unit) { //TODO: Use glmatrix.EPSILON
    // singularity at the north pole
    out[0] = Math.PI / 2;
    out[1] = 2 * Math.atan2(y, x);
    out[2] = 0;
  } else if (test < -0.499995 * unit) { //TODO: Use glmatrix.EPSILON
    // singularity at the south pole
    out[0] = -Math.PI / 2;
    out[1] = 2 * Math.atan2(y, x);
    out[2] = 0;
  } else {
    out[0] = Math.asin(2 * (x * z - w * y));
    out[1] = Math.atan2(2 * (x * w + y * z), 1 - 2 * (z2 + w2));
    out[2] = Math.atan2(2 * (x * y + z * w), 1 - 2 * (y2 + z2));
  }
  // TODO: Return them as degrees and not as radians
  return out;
}

[iangilman]

Just a note that this would still be great! In the meantime, I'm using the function provided above and it's working beautifully :)

[dinasorz]

Contributing to the amazing Stefnotch here, to make the Euler returns degree instead of radians:
You can just multiply *180/Math.PI to the output

/**
 * Returns an euler angle (as degrees) representation of a quaternion
 * @param  {vec3} out Euler angles, pitch-yaw-roll
 * @param  {quat} mat Quaternion
 * @return {vec3} out
 */
export function getEuler(out, quat) {
    let x = quat[0],
      y = quat[1],
      z = quat[2],
      w = quat[3],
      x2 = x * x,
      y2 = y * y,
      z2 = z * z,
      w2 = w * w;
    let unit = x2 + y2 + z2 + w2;
    let test = x * w - y * z;
    if (test > 0.499995 * unit) { //TODO: Use glmatrix.EPSILON
      // singularity at the north pole
      out[0] = Math.PI / 2 * 180/Math.PI;
      out[1] = 2 * Math.atan2(y, x) * 180/Math.PI;
      out[2] = 0 * 180/Math.PI;
    } else if (test < -0.499995 * unit) { //TODO: Use glmatrix.EPSILON
      // singularity at the south pole
      out[0] = -Math.PI / 2 * 180/Math.PI;
      out[1] = 2 * Math.atan2(y, x) * 180/Math.PI;
      out[2] = 0 * 180/Math.PI;
    } else {
      out[0] = Math.asin(2 * (x * z - w * y)) * 180/Math.PI;
      out[1] = Math.atan2(2 * (x * w + y * z), 1 - 2 * (z2 + w2)) * 180/Math.PI;
      out[2] = Math.atan2(2 * (x * y + z * w), 1 - 2 * (y2 + z2)) * 180/Math.PI;
    }
    return out;
}