mat.h

#pragma once
 
#include <kiba/defines.h>
#include <kiba/math/math.h>
#include <kiba/math/vec.h>
 
static inline f32 radians_to_degrees(f32 angle) { return angle * (180.f / PI_F32); }
 
static inline f32 degrees_to_radians(f32 angle) { return angle * (PI_F32 / 180.f); }
 
typedef union {
    vec4 rows[4];
 
    struct {
        f32 _v00, _v01, _v02, _v03;
        f32 _v10, _v11, _v12, _v13;
        f32 _v20, _v21, _v22, _v23;
        f32 _v30, _v31, _v32, _v33;
    };
    f32  raw[4][4];
} mat4;
 
STATIC_ASSERT(sizeof(mat4) == sizeof(f32[4][4]), "mat4's general layout must be identical to its raw format");
 
static mat4 mat4_identity(void) {
    return (mat4){
        .raw[0][0] = 1,
        .raw[1][1] = 1,
        .raw[2][2] = 1,
        .raw[3][3] = 1,
    };
}
 
void mat4_print(mat4 m);
 
void mat4_print(mat4 m) {
    UNUSED(m);
    for (u32 i = 0; i < 4; ++i) {
        KB_DEBUG("{f32} {f32} {f32} {f32}", m.raw[i][0], m.raw[i][1], m.raw[i][2], m.raw[i][3]);
    }
}
 
mat4 mat4_transpose(mat4 m);
 
mat4 mat4_transpose(mat4 m) {
    return (mat4){
        .raw[0][0] = m.raw[0][0],
        .raw[0][1] = m.raw[1][0],
        .raw[0][2] = m.raw[2][0],
        .raw[0][3] = m.raw[3][0],
        .raw[1][0] = m.raw[0][1],
        .raw[1][1] = m.raw[1][1],
        .raw[1][2] = m.raw[2][1],
        .raw[1][3] = m.raw[3][1],
        .raw[2][0] = m.raw[0][2],
        .raw[2][1] = m.raw[1][2],
        .raw[2][2] = m.raw[2][2],
        .raw[2][3] = m.raw[3][2],
        .raw[3][0] = m.raw[0][3],
        .raw[3][1] = m.raw[1][3],
        .raw[3][2] = m.raw[2][3],
        .raw[3][3] = m.raw[3][3],
    };
}
 
static mat4 mat4_rotate(mat4 input, f32 angle_radians, vec3 axis) {
    f32  sin_a   = sin_f32(angle_radians);
    f32  cos_a   = cos_f32(angle_radians);
    mat4 rot_mat = {
        .raw[0][0] = cos_a + axis.x * axis.x * (1.f - cos_a),
        .raw[0][1] = axis.x * axis.y * (1.f - cos_a) - axis.z * sin_a,
        .raw[0][2] = axis.x * axis.z * (1.f - cos_a) + axis.y * sin_a,
        .raw[0][3] = 0.f,
        .raw[1][0] = axis.y * axis.x * (1.f - cos_a) + axis.z * sin_a,
        .raw[1][1] = cos_a + axis.y * axis.y * (1.f - cos_a),
        .raw[1][2] = axis.y * axis.z * (1.f - cos_a) - axis.x * sin_a,
        .raw[1][3] = 0.f,
        .raw[2][0] = axis.z * axis.x * (1.f - cos_a) - axis.y * sin_a,
        .raw[2][1] = axis.z * axis.y * (1.f - cos_a) + axis.x * sin_a,
        .raw[2][2] = cos_a + axis.z * axis.z * (1.f - cos_a),
        .raw[2][3] = 0.f,
        .raw[3][0] = 0.f,
        .raw[3][1] = 0.f,
        .raw[3][2] = 0.f,
        .raw[3][3] = 1.f,
    };
 
    UNUSED(input);
    return rot_mat;
}
 
static mat4 mat4_look_at(vec3 eye, vec3 center, vec3 up) {
    vec3 forward     = vec3_normalize(vec3_sub(center, eye));
    vec3 u           = vec3_normalize(vec3_cross_product(forward, up));
    vec3 v           = vec3_normalize(vec3_cross_product(u, forward));
    vec3 w           = vec3_mul_scalar(forward, -1.f);
    vec3 translation = vec3_create(vec3_dot(eye, u), vec3_dot(eye, v), vec3_dot(eye, w));
    return (mat4){
        .raw[0][0] = u.x,
        .raw[1][0] = u.y,
        .raw[2][0] = u.z,
        .raw[0][1] = v.x,
        .raw[1][1] = v.y,
        .raw[2][1] = v.z,
        .raw[0][2] = w.x,
        .raw[1][2] = w.y,
        .raw[2][2] = w.z,
        .raw[0][3] = 0.f,
        .raw[1][3] = 0.f,
        .raw[2][3] = 0.f,
        .raw[3][3] = 1.f,
        .raw[3][0] = -translation.x,
        .raw[3][1] = -translation.y,
        .raw[3][2] = -translation.z,
    };
}
 
static inline mat4 mat4_perspective(f32 vert_angle_radians, f32 aspect_ratio, f32 near, f32 far) {
    f32 f = 1.f / tanf(vert_angle_radians / 2);
    return (mat4){
        .raw[0][0] = f / aspect_ratio,
        .raw[1][1] = -f,
        .raw[2][2] = far / (near - far),
        .raw[2][3] = -1.f,
        .raw[3][2] = -(far * near) / (far - near),
        .raw[3][3] = 1.f,
    };
}
 
static inline f32 mat3_minor(const mat4 m, usize row, usize col) {
    const usize first_r  = (row + 1) % 3;
    const usize second_r = (row + 2) % 3;
    const usize first_c  = (col + 1) % 3;
    const usize second_c = (col + 2) % 3;
    return m.raw[first_r][first_c] * m.raw[second_r][second_c] - m.raw[first_r][second_c] * m.raw[second_r][first_c];
}
 
static inline mat4 mat3_cofactor(const mat4 m) {
    mat4  res    = mat4_identity();
    for (usize r = 0; r < 3; ++r) {
        for (usize c = 0; c < 3; ++c) {
            res.raw[r][c] = mat3_minor(m, r, c);
        }
    }
    return res;
}
 
static inline mat4 mat3_adjoint(const mat4 m) { return mat4_transpose(mat3_cofactor(m)); }
 
static inline f32 mat3_det(const mat4 m) {
    return m._v00 * m._v11 * m._v22 + m._v01 * m._v12 * m._v20 + m._v02 * m._v10 * m._v21 - m._v00 * m._v12 * m._v21
         - m._v01 * m._v10 * m._v22 - m._v02 * m._v11 * m._v20;
}
 
static inline mat4 mat3_inverse(const mat4 m) {
    const f32 det = mat3_det(m);
    if (det == 0.f) {
        return mat4_identity();
    }
    mat4 res = mat3_adjoint(m);
    for (usize r = 0; r < 3; ++r) {
        for (usize c = 0; c < 3; ++c) {
            res.raw[r][c] /= det;
        }
    }
    return res;
}