pub type Vec4 = [f32; 4];
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Mat4(pub [f32; 16]);
impl Default for Mat4 {
fn default() -> Self {
Self::IDENTITY
}
}
impl Mat4 {
pub const IDENTITY: Self = Self([
1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
]);
#[inline]
pub fn at(&self, row: usize, column: usize) -> f32 {
self.0[column * 4 + row]
}
pub fn mul(&self, other: &Self) -> Self {
let mut out = [0.0; 16];
for column in 0..4 {
for row in 0..4 {
let mut sum = 0.0;
for k in 0..4 {
sum += self.at(row, k) * other.at(k, column);
}
out[column * 4 + row] = sum;
}
}
Self(out)
}
#[inline]
pub fn transform(&self, v: Vec4) -> Vec4 {
let m = &self.0;
[
m[0] * v[0] + m[4] * v[1] + m[8] * v[2] + m[12] * v[3],
m[1] * v[0] + m[5] * v[1] + m[9] * v[2] + m[13] * v[3],
m[2] * v[0] + m[6] * v[1] + m[10] * v[2] + m[14] * v[3],
m[3] * v[0] + m[7] * v[1] + m[11] * v[2] + m[15] * v[3],
]
}
#[inline]
pub fn transform_direction(&self, v: [f32; 3]) -> [f32; 3] {
let m = &self.0;
[
m[0] * v[0] + m[4] * v[1] + m[8] * v[2],
m[1] * v[0] + m[5] * v[1] + m[9] * v[2],
m[2] * v[0] + m[6] * v[1] + m[10] * v[2],
]
}
pub fn transpose(&self) -> Self {
let mut out = [0.0; 16];
for row in 0..4 {
for column in 0..4 {
out[column * 4 + row] = self.at(column, row);
}
}
Self(out)
}
pub fn inverse(&self) -> Self {
let m = &self.0;
let mut inv = [0.0f32; 16];
inv[0] = m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15]
+ m[9] * m[7] * m[14]
+ m[13] * m[6] * m[11]
- m[13] * m[7] * m[10];
inv[4] = -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] + m[8] * m[6] * m[15]
- m[8] * m[7] * m[14]
- m[12] * m[6] * m[11]
+ m[12] * m[7] * m[10];
inv[8] = m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15]
+ m[8] * m[7] * m[13]
+ m[12] * m[5] * m[11]
- m[12] * m[7] * m[9];
inv[12] = -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] + m[8] * m[5] * m[14]
- m[8] * m[6] * m[13]
- m[12] * m[5] * m[10]
+ m[12] * m[6] * m[9];
inv[1] = -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] + m[9] * m[2] * m[15]
- m[9] * m[3] * m[14]
- m[13] * m[2] * m[11]
+ m[13] * m[3] * m[10];
inv[5] = m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15]
+ m[8] * m[3] * m[14]
+ m[12] * m[2] * m[11]
- m[12] * m[3] * m[10];
inv[9] = -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15]
- m[8] * m[3] * m[13]
- m[12] * m[1] * m[11]
+ m[12] * m[3] * m[9];
inv[13] = m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14]
+ m[8] * m[2] * m[13]
+ m[12] * m[1] * m[10]
- m[12] * m[2] * m[9];
inv[2] = m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15]
+ m[5] * m[3] * m[14]
+ m[13] * m[2] * m[7]
- m[13] * m[3] * m[6];
inv[6] = -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15]
- m[4] * m[3] * m[14]
- m[12] * m[2] * m[7]
+ m[12] * m[3] * m[6];
inv[10] = m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15]
+ m[4] * m[3] * m[13]
+ m[12] * m[1] * m[7]
- m[12] * m[3] * m[5];
inv[14] = -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14]
- m[4] * m[2] * m[13]
- m[12] * m[1] * m[6]
+ m[12] * m[2] * m[5];
inv[3] = -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11]
- m[5] * m[3] * m[10]
- m[9] * m[2] * m[7]
+ m[9] * m[3] * m[6];
inv[7] = m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11]
+ m[4] * m[3] * m[10]
+ m[8] * m[2] * m[7]
- m[8] * m[3] * m[6];
inv[11] = -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11]
- m[4] * m[3] * m[9]
- m[8] * m[1] * m[7]
+ m[8] * m[3] * m[5];
inv[15] = m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10]
+ m[4] * m[2] * m[9]
+ m[8] * m[1] * m[6]
- m[8] * m[2] * m[5];
let det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
if det == 0.0 || !det.is_finite() {
return Self::IDENTITY;
}
let scale = 1.0 / det;
for value in &mut inv {
*value *= scale;
}
Self(inv)
}
pub fn translate(x: f32, y: f32, z: f32) -> Self {
let mut m = Self::IDENTITY;
m.0[12] = x;
m.0[13] = y;
m.0[14] = z;
m
}
pub fn scale(x: f32, y: f32, z: f32) -> Self {
let mut m = Self::IDENTITY;
m.0[0] = x;
m.0[5] = y;
m.0[10] = z;
m
}
pub fn rotate(angle: f32, x: f32, y: f32, z: f32) -> Self {
let length = (x * x + y * y + z * z).sqrt();
if length == 0.0 {
return Self::IDENTITY;
}
let (x, y, z) = (x / length, y / length, z / length);
let (s, c) = angle.to_radians().sin_cos();
let t = 1.0 - c;
Self([
x * x * t + c,
y * x * t + z * s,
x * z * t - y * s,
0.0,
x * y * t - z * s,
y * y * t + c,
y * z * t + x * s,
0.0,
x * z * t + y * s,
y * z * t - x * s,
z * z * t + c,
0.0,
0.0,
0.0,
0.0,
1.0,
])
}
pub fn ortho(l: f64, r: f64, b: f64, t: f64, n: f64, f: f64) -> Self {
let mut m = Self::IDENTITY;
m.0[0] = (2.0 / (r - l)) as f32;
m.0[5] = (2.0 / (t - b)) as f32;
m.0[10] = (-2.0 / (f - n)) as f32;
m.0[12] = (-(r + l) / (r - l)) as f32;
m.0[13] = (-(t + b) / (t - b)) as f32;
m.0[14] = (-(f + n) / (f - n)) as f32;
m
}
pub fn frustum(l: f64, r: f64, b: f64, t: f64, n: f64, f: f64) -> Self {
let mut m = Self([0.0; 16]);
m.0[0] = (2.0 * n / (r - l)) as f32;
m.0[5] = (2.0 * n / (t - b)) as f32;
m.0[8] = ((r + l) / (r - l)) as f32;
m.0[9] = ((t + b) / (t - b)) as f32;
m.0[10] = (-(f + n) / (f - n)) as f32;
m.0[11] = -1.0;
m.0[14] = (-2.0 * f * n / (f - n)) as f32;
m
}
}
#[inline]
pub fn dot3(a: [f32; 3], b: [f32; 3]) -> f32 {
a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
}
#[inline]
pub fn normalize3(v: [f32; 3]) -> [f32; 3] {
let length = dot3(v, v).sqrt();
if length == 0.0 {
v
} else {
[v[0] / length, v[1] / length, v[2] / length]
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rotation_and_inverse_round_trip() {
let m = Mat4::rotate(90.0, 0.0, 0.0, 1.0).mul(&Mat4::translate(1.0, 2.0, 3.0));
let v = m.transform([1.0, 0.0, 0.0, 1.0]);
assert!((v[0] - -2.0).abs() < 1e-5 && (v[1] - 2.0).abs() < 1e-5);
let back = m.inverse().transform(v);
assert!((back[0] - 1.0).abs() < 1e-5 && back[1].abs() < 1e-5);
}
#[test]
fn frustum_maps_near_plane_to_minus_one() {
let m = Mat4::frustum(-1.0, 1.0, -1.0, 1.0, 1.0, 10.0);
let v = m.transform([0.0, 0.0, -1.0, 1.0]);
assert!((v[2] / v[3] - -1.0).abs() < 1e-5);
let v = m.transform([0.0, 0.0, -10.0, 1.0]);
assert!((v[2] / v[3] - 1.0).abs() < 1e-5);
}
}