/*! @license
* glMatrix: https://github.com/toji/gl-matrix/
* Copyright 2015-2021, Brandon Jones, Colin MacKenzie IV
* SPDX-License-Identifier: MIT
*/
goog.provide('shaka.ui.Matrix4x4');
/**
* 4x4 Matrix
* Format: column-major, when typed out it looks like row-major
* The matrices are being post multiplied.
*/
shaka.ui.Matrix4x4 = class {
/**
* Creates a new identity 4x4 Matrix
*
* @return {!Float32Array} a new 4x4 matrix
*/
static create() {
const out = new Float32Array(16);
out[0] = 1;
out[5] = 1;
out[10] = 1;
out[15] = 1;
return out;
}
/**
* Generates a look-at matrix with the given eye position, focal point, and
* up axis.
*
* @param {!Float32Array} out 4x4 matrix frustum matrix will be written into
* @param {!Array.<number>} eye Position of the viewer
* @param {!Array.<number>} center Point the viewer is looking at
* @param {!Array.<number>} up Vector pointing up
*/
static lookAt(out, eye, center, up) {
let x0;
let x1;
let x2;
let y0;
let y1;
let y2;
let z0;
let z1;
let z2;
let len;
const eyex = eye[0];
const eyey = eye[1];
const eyez = eye[2];
const upx = up[0];
const upy = up[1];
const upz = up[2];
const centerx = center[0];
const centery = center[1];
const centerz = center[2];
if (Math.abs(eyex - centerx) < shaka.ui.Matrix4x4.EPSILON_ &&
Math.abs(eyey - centery) < shaka.ui.Matrix4x4.EPSILON_ &&
Math.abs(eyez - centerz) < shaka.ui.Matrix4x4.EPSILON_) {
return shaka.ui.Matrix4x4.identity_(out);
}
z0 = eyex - centerx;
z1 = eyey - centery;
z2 = eyez - centerz;
len = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
z0 *= len;
z1 *= len;
z2 *= len;
x0 = upy * z2 - upz * z1;
x1 = upz * z0 - upx * z2;
x2 = upx * z1 - upy * z0;
len = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
if (!len) {
x0 = 0;
x1 = 0;
x2 = 0;
} else {
len = 1 / len;
x0 *= len;
x1 *= len;
x2 *= len;
}
y0 = z1 * x2 - z2 * x1;
y1 = z2 * x0 - z0 * x2;
y2 = z0 * x1 - z1 * x0;
len = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
if (!len) {
y0 = 0;
y1 = 0;
y2 = 0;
} else {
len = 1 / len;
y0 *= len;
y1 *= len;
y2 *= len;
}
out[0] = x0;
out[1] = y0;
out[2] = z0;
out[3] = 0;
out[4] = x1;
out[5] = y1;
out[6] = z1;
out[7] = 0;
out[8] = x2;
out[9] = y2;
out[10] = z2;
out[11] = 0;
out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
out[15] = 1;
return out;
}
/**
* Scales the 4x4 matrix by the dimensions in the given vector not using
* vectorization
*
* @param {!Float32Array} out the receiving matrix
* @param {!Float32Array} a the matrix to scale
* @param {!Array.<number>} v the vector to scale the matrix by
*/
static scale(out, a, v) {
const x = v[0];
const y = v[1];
const z = v[2];
out[0] = a[0] * x;
out[1] = a[1] * x;
out[2] = a[2] * x;
out[3] = a[3] * x;
out[4] = a[4] * y;
out[5] = a[5] * y;
out[6] = a[6] * y;
out[7] = a[7] * y;
out[8] = a[8] * z;
out[9] = a[9] * z;
out[10] = a[10] * z;
out[11] = a[11] * z;
out[12] = a[12];
out[13] = a[13];
out[14] = a[14];
out[15] = a[15];
}
/**
* Generates a perspective projection matrix with the given bounds.
* The near/far clip planes correspond to a normalized device coordinate Z
* range of [-1, 1], which matches WebGL's clip volume.
* Passing null/undefined/no value for far will generate infinite projection
* matrix.
*
* @param {!Float32Array} out 4x4 matrix frustum matrix will be written into
* @param {number} fovy Vertical field of view in radians
* @param {number} aspect Aspect ratio. typically viewport width/height
* @param {number} near Near bound of the frustum
* @param {number} far Far bound of the frustum, can be null or Infinity
*/
static perspective(out, fovy, aspect, near, far) {
const f = 1.0 / Math.tan(fovy / 2);
out[0] = f / aspect;
out[1] = 0;
out[2] = 0;
out[3] = 0;
out[4] = 0;
out[5] = f;
out[6] = 0;
out[7] = 0;
out[8] = 0;
out[9] = 0;
out[11] = -1;
out[12] = 0;
out[13] = 0;
out[15] = 0;
if (far != null && far !== Infinity) {
const nf = 1 / (near - far);
out[10] = (far + near) * nf;
out[14] = 2 * far * near * nf;
} else {
out[10] = -1;
out[14] = -2 * near;
}
return out;
}
/**
* Multiplies two 4x4 matrix
*
* @param {!Float32Array} out the receiving matrix
* @param {!Float32Array} a the first operand
* @param {!Float32Array} b the second operand
*/
static multiply(out, a, b) {
const a00 = a[0];
const a01 = a[1];
const a02 = a[2];
const a03 = a[3];
const a10 = a[4];
const a11 = a[5];
const a12 = a[6];
const a13 = a[7];
const a20 = a[8];
const a21 = a[9];
const a22 = a[10];
const a23 = a[11];
const a30 = a[12];
const a31 = a[13];
const a32 = a[14];
const a33 = a[15];
// Cache only the current line of the second matrix
let b0 = b[0];
let b1 = b[1];
let b2 = b[2];
let b3 = b[3];
out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
b0 = b[4];
b1 = b[5];
b2 = b[6];
b3 = b[7];
out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
b0 = b[8];
b1 = b[9];
b2 = b[10];
b3 = b[11];
out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
b0 = b[12];
b1 = b[13];
b2 = b[14];
b3 = b[15];
out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
}
/**
* Generates a frustum matrix with the given bounds
*
* @param {!Float32Array} out 4x4 matrix frustum matrix will be written into
* @param {number} left Left bound of the frustum
* @param {number} right Right bound of the frustum
* @param {number} bottom Bottom bound of the frustum
* @param {number} top Top bound of the frustum
* @param {number} near Near bound of the frustum
* @param {number} far Far bound of the frustum
*/
static frustum(out, left, right, bottom, top, near, far) {
const rl = 1 / (right - left);
const tb = 1 / (top - bottom);
const nf = 1 / (near - far);
out[0] = near * 2 * rl;
out[1] = 0;
out[2] = 0;
out[3] = 0;
out[4] = 0;
out[5] = near * 2 * tb;
out[6] = 0;
out[7] = 0;
out[8] = (right + left) * rl;
out[9] = (top + bottom) * tb;
out[10] = (far + near) * nf;
out[11] = -1;
out[12] = 0;
out[13] = 0;
out[14] = far * near * 2 * nf;
out[15] = 0;
return out;
}
/**
* Rotates a matrix by the given angle around the X axis
*
* @param {!Float32Array} out the receiving matrix
* @param {!Float32Array} a the matrix to rotate
* @param {number} rad the angle to rotate the matrix by
*/
static rotateX(out, a, rad) {
const s = Math.sin(rad);
const c = Math.cos(rad);
const a10 = a[4];
const a11 = a[5];
const a12 = a[6];
const a13 = a[7];
const a20 = a[8];
const a21 = a[9];
const a22 = a[10];
const a23 = a[11];
if (a !== out) {
// If the source and destination differ, copy the unchanged rows
out[0] = a[0];
out[1] = a[1];
out[2] = a[2];
out[3] = a[3];
out[12] = a[12];
out[13] = a[13];
out[14] = a[14];
out[15] = a[15];
}
// Perform axis-specific matrix multiplication
out[4] = a10 * c + a20 * s;
out[5] = a11 * c + a21 * s;
out[6] = a12 * c + a22 * s;
out[7] = a13 * c + a23 * s;
out[8] = a20 * c - a10 * s;
out[9] = a21 * c - a11 * s;
out[10] = a22 * c - a12 * s;
out[11] = a23 * c - a13 * s;
}
/**
* Rotates a matrix by the given angle around the Y axis
*
* @param {!Float32Array} out the receiving matrix
* @param {!Float32Array} a the matrix to rotate
* @param {number} rad the angle to rotate the matrix by
*/
static rotateY(out, a, rad) {
const s = Math.sin(rad);
const c = Math.cos(rad);
const a00 = a[0];
const a01 = a[1];
const a02 = a[2];
const a03 = a[3];
const a20 = a[8];
const a21 = a[9];
const a22 = a[10];
const a23 = a[11];
if (a !== out) {
// If the source and destination differ, copy the unchanged rows
out[4] = a[4];
out[5] = a[5];
out[6] = a[6];
out[7] = a[7];
out[12] = a[12];
out[13] = a[13];
out[14] = a[14];
out[15] = a[15];
}
// Perform axis-specific matrix multiplication
out[0] = a00 * c - a20 * s;
out[1] = a01 * c - a21 * s;
out[2] = a02 * c - a22 * s;
out[3] = a03 * c - a23 * s;
out[8] = a00 * s + a20 * c;
out[9] = a01 * s + a21 * c;
out[10] = a02 * s + a22 * c;
out[11] = a03 * s + a23 * c;
}
/**
* Rotates a matrix by the given angle around the Z axis
*
* @param {!Float32Array} out the receiving matrix
* @param {!Float32Array} a the matrix to rotate
* @param {number} rad the angle to rotate the matrix by
*/
static rotateZ(out, a, rad) {
const s = Math.sin(rad);
const c = Math.cos(rad);
const a00 = a[0];
const a01 = a[1];
const a02 = a[2];
const a03 = a[3];
const a10 = a[4];
const a11 = a[5];
const a12 = a[6];
const a13 = a[7];
if (a !== out) {
// If the source and destination differ, copy the unchanged last row
out[8] = a[8];
out[9] = a[9];
out[10] = a[10];
out[11] = a[11];
out[12] = a[12];
out[13] = a[13];
out[14] = a[14];
out[15] = a[15];
}
// Perform axis-specific matrix multiplication
out[0] = a00 * c + a10 * s;
out[1] = a01 * c + a11 * s;
out[2] = a02 * c + a12 * s;
out[3] = a03 * c + a13 * s;
out[4] = a10 * c - a00 * s;
out[5] = a11 * c - a01 * s;
out[6] = a12 * c - a02 * s;
out[7] = a13 * c - a03 * s;
}
/**
* Returns a quaternion representing the rotational component
* of a transformation matrix. If a matrix is built with
* fromRotationTranslation, the returned quaternion will be the
* same as the quaternion originally supplied.
* @param {!Float32Array} out Quaternion to receive the rotation component
* @param {!Float32Array} mat Matrix to be decomposed (input)
*/
static getRotation(out, mat) {
const scaling = new Float32Array(3);
shaka.ui.Matrix4x4.getScaling_(scaling, mat);
const is1 = 1 / scaling[0];
const is2 = 1 / scaling[1];
const is3 = 1 / scaling[2];
const sm11 = mat[0] * is1;
const sm12 = mat[1] * is2;
const sm13 = mat[2] * is3;
const sm21 = mat[4] * is1;
const sm22 = mat[5] * is2;
const sm23 = mat[6] * is3;
const sm31 = mat[8] * is1;
const sm32 = mat[9] * is2;
const sm33 = mat[10] * is3;
const trace = sm11 + sm22 + sm33;
let S = 0;
if (trace > 0) {
S = Math.sqrt(trace + 1.0) * 2;
out[3] = 0.25 * S;
out[0] = (sm23 - sm32) / S;
out[1] = (sm31 - sm13) / S;
out[2] = (sm12 - sm21) / S;
} else if (sm11 > sm22 && sm11 > sm33) {
S = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;
out[3] = (sm23 - sm32) / S;
out[0] = 0.25 * S;
out[1] = (sm12 + sm21) / S;
out[2] = (sm31 + sm13) / S;
} else if (sm22 > sm33) {
S = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;
out[3] = (sm31 - sm13) / S;
out[0] = (sm12 + sm21) / S;
out[1] = 0.25 * S;
out[2] = (sm23 + sm32) / S;
} else {
S = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;
out[3] = (sm12 - sm21) / S;
out[0] = (sm31 + sm13) / S;
out[1] = (sm23 + sm32) / S;
out[2] = 0.25 * S;
}
return out;
}
/**
* Calculates a 4x4 matrix from the given quaternion
*
* @param {!Float32Array} out 4x4 matrix receiving operation result
* @param {!Float32Array} q Quaternion to create matrix from
*/
static fromQuat(out, q) {
const x = q[0];
const y = q[1];
const z = q[2];
const w = q[3];
const x2 = x + x;
const y2 = y + y;
const z2 = z + z;
const xx = x * x2;
const yx = y * x2;
const yy = y * y2;
const zx = z * x2;
const zy = z * y2;
const zz = z * z2;
const wx = w * x2;
const wy = w * y2;
const wz = w * z2;
out[0] = 1 - yy - zz;
out[1] = yx + wz;
out[2] = zx - wy;
out[3] = 0;
out[4] = yx - wz;
out[5] = 1 - xx - zz;
out[6] = zy + wx;
out[7] = 0;
out[8] = zx + wy;
out[9] = zy - wx;
out[10] = 1 - xx - yy;
out[11] = 0;
out[12] = 0;
out[13] = 0;
out[14] = 0;
out[15] = 1;
}
/**
* Set a 4x4 matrix to the identity matrix
*
* @param {!Float32Array} out the receiving matrix
* @private
*/
static identity_(out) {
for (let i = 0; i < 16; i++) {
out[i] = (i % 5) == 0 ? 1 : 0;
}
}
/**
* Returns the scaling factor component of a transformation
* matrix. If a matrix is built with fromRotationTranslationScale
* with a normalized Quaternion paramter, the returned vector will be
* the same as the scaling vector
* originally supplied.
* @param {!Float32Array} out Vector to receive scaling factor component
* @param {!Float32Array} mat Matrix to be decomposed (input)
* @private
*/
static getScaling_(out, mat) {
const m11 = mat[0];
const m12 = mat[1];
const m13 = mat[2];
const m21 = mat[4];
const m22 = mat[5];
const m23 = mat[6];
const m31 = mat[8];
const m32 = mat[9];
const m33 = mat[10];
out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
}
};
/**
* @const {number}
* @private
*/
shaka.ui.Matrix4x4.EPSILON_ = 0.000001;