tor-browser

webxr_math_utils.js (2554B)

---

// |matrix| - Float32Array, |input| - point-like dict (must have x, y, z, w)
let transform_point_by_matrix = function(matrix, input) {
 return {
   x : matrix[0] * input.x + matrix[4] * input.y + matrix[8] * input.z + matrix[12] * input.w,
   y : matrix[1] * input.x + matrix[5] * input.y + matrix[9] * input.z + matrix[13] * input.w,
   z : matrix[2] * input.x + matrix[6] * input.y + matrix[10] * input.z + matrix[14] * input.w,
   w : matrix[3] * input.x + matrix[7] * input.y + matrix[11] * input.z + matrix[15] * input.w,
 };
}

// Creates a unit-length quaternion.
// |input| - point-like dict (must have x, y, z, w)
let normalize_quaternion = function(input) {
 const length_squared = input.x * input.x + input.y * input.y + input.z * input.z + input.w * input.w;
 const length = Math.sqrt(length_squared);

 return {x : input.x / length, y : input.y / length, z : input.z / length, w : input.w / length};
}

// Returns negated quaternion.
// |input| - point-like dict (must have x, y, z, w)
let flip_quaternion = function(input) {
 return {x : -input.x, y : -input.y, z : -input.z, w : -input.w};
}

// |input| - point-like dict (must have x, y, z, w)
let conjugate_quaternion = function(input) {
 return {x : -input.x, y : -input.y, z : -input.z, w : input.w};
}

let multiply_quaternions = function(q1, q2) {
 return {
   w : q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z,
   x : q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y,
   y : q1.w * q2.y - q1.x * q2.z + q1.y * q2.w + q1.z * q2.x,
   z : q1.w * q2.z + q1.x * q2.y - q1.y * q2.x + q1.z * q2.w,
 }
}

// |point| - point-like dict (must have x, y, z, w)
let normalize_perspective = function(point) {
 if(point.w == 0 || point.w == 1) return point;

 return {
   x : point.x / point.w,
   y : point.y / point.w,
   z : point.z / point.w,
   w : 1
 };
}

// |quaternion| - point-like dict (must have x, y, z, w),
// |input| - point-like dict (must have x, y, z, w)
let transform_point_by_quaternion = function(quaternion, input) {
 const q_normalized = normalize_quaternion(quaternion);
 const q_conj = conjugate_quaternion(q_normalized);
 const p_in = normalize_perspective(input);

 // construct a quaternion out of the point (take xyz & zero the real part).
 const p = {x : p_in.x, y : p_in.y, z : p_in.z, w : 0};

 // transform the input point
 const p_mul = multiply_quaternions( q_normalized, multiply_quaternions(p, q_conj) );

 // add back the w component of the input
 return { x : p_mul.x, y : p_mul.y, z : p_mul.z, w : p_in.w };
}