matrix4.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025-2026 Igal Alkon
// SPDX-FileCopyrightText: 2026 ALKONTEK <git@alkontek.com>
// SPDX-License-Identifier: BSD-3-Clause
 
#include <vecmat.h>

matrix4 mat4_identity(void)
{
    matrix4 res = {0};
    mat4_identity_ptr(&res);
    return res;
}

matrix4 mat4_mul(const matrix4 a, const matrix4 b)
{
    matrix4 res = {0};
    mat4_mul_ptr(&res, &a, &b);
    return res;
}

matrix4 mat4_transpose(const matrix4 m)
{
    matrix4 res = {0};
    mat4_transpose_ptr(&res, &m);
    return res;
}

matrix4 mat4_inverse(const matrix4 m)
{
    matrix4 res = {0};
    mat4_inverse_ptr(&res, &m);
    return res;
}

matrix4 mat4_translate(const vector3 v)
{
    matrix4 res = {0};
    mat4_translate_ptr(&res, &v);
    return res;
}

matrix4 mat4_scale(const vector3 v)
{
    matrix4 res = {0};
    mat4_scale_ptr(&res, &v);
    return res;
}

matrix4 mat4_rotation(const vector3 axis, const vm_float_t angle)
{
    matrix4 res = {0};
    mat4_rotation_ptr(&res, &axis, angle);
    return res;
}

matrix4 mat4_perspective(const vm_float_t fov, const vm_float_t aspect, const vm_float_t near, const vm_float_t far)
{
    matrix4 res = {0};
    mat4_perspective_ptr(&res, fov, aspect, near, far);
    return res;
}

matrix4 mat4_ortho(const vm_float_t left, const vm_float_t right, const vm_float_t bottom,
    const vm_float_t top, const vm_float_t near, const vm_float_t far)
{
    matrix4 res = {0};
    mat4_ortho_ptr(&res, left, right, bottom, top, near, far);
    return res;
}

matrix4 mat4_look_at(const vector3 position, const vector3 target, const vector3 up)
{
    matrix4 res = {0};
    mat4_look_at_ptr(&res, &position, &target, &up);
    return res;
}

matrix4 mat4_perspective_fov(const vm_float_t fov, const vm_float_t w, const vm_float_t h,
    const vm_float_t n, const vm_float_t f)
{
    matrix4 res = {0};
    mat4_perspective_fov_ptr(&res, fov, w, h, n, f);
    return res;
}

matrix4 mat4_perspective_infinite(const vm_float_t fov_y, const vm_float_t aspect, const vm_float_t n)
{
    matrix4 res = {0};
    mat4_perspective_infinite_ptr(&res, fov_y, aspect, n);
    return res;
}

vm_float_t mat4_determinant(const matrix4 m)
{
    const vm_float_t cofactor_1 =  m.v[5] * m.v[10] * m.v[15] - m.v[5] * m.v[14] * m.v[11] - m.v[9] * m.v[6] * m.v[15] +
                                   m.v[9] * m.v[14] * m.v[7] + m.v[13] * m.v[6] * m.v[11] - m.v[13] * m.v[10] * m.v[7];
 
    const vm_float_t cofactor_2 = -m.v[4] * m.v[10] * m.v[15] + m.v[4] * m.v[14] * m.v[11] + m.v[8] * m.v[6] * m.v[15] -
                                   m.v[8] * m.v[14] * m.v[7] - m.v[12] * m.v[6] * m.v[11] + m.v[12] * m.v[10] * m.v[7];
 
    const vm_float_t cofactor_3 =  m.v[4] * m.v[9]  * m.v[15] - m.v[4] * m.v[13] * m.v[11] - m.v[8] * m.v[5] * m.v[15] +
                                   m.v[8] * m.v[13] * m.v[7] + m.v[12] * m.v[5] * m.v[11] - m.v[12] * m.v[9]  * m.v[7];
 
    const vm_float_t cofactor_4 = -m.v[4] * m.v[9]  * m.v[14] + m.v[4] * m.v[13] * m.v[10] + m.v[8] * m.v[5] * m.v[14] -
                                   m.v[8] * m.v[13] * m.v[6] - m.v[12] * m.v[5] * m.v[10] + m.v[12] * m.v[9]  * m.v[6];
 
    return m.v[0] * cofactor_1 + m.v[1] * cofactor_2 + m.v[2] * cofactor_3 + m.v[3] * cofactor_4;
}

vector4 mat4_mul_vec4(const matrix4 m, const vector4 v)
{
    vector4 res;
    mat4_mul_vec4_ptr(&res, &m, &v);
    return res;
}

vector3 mat4_mul_vec3(const matrix4 m, const vector3 v, const vm_float_t w)
{
    vector3 res;
    mat4_mul_vec3_ptr(&res, &m, &v, w);
    return res;
}

matrix4 mat4_rotation_x(const vm_float_t degrees)
{
    matrix4 res;
    mat4_rotation_x_ptr(&res, degrees);
    return res;
}

matrix4 mat4_rotation_y(const vm_float_t degrees)
{
    matrix4 res;
    mat4_rotation_y_ptr(&res, degrees);
    return res;
}

matrix4 mat4_rotation_z(const vm_float_t degrees)
{
    matrix4 res;
    mat4_rotation_z_ptr(&res, degrees);
    return res;
}

matrix4 mat4_trs(const vector3 translation, const quaternion rotation, const vector3 scale)
{
    matrix4 res;
    mat4_trs_ptr(&res, &translation, &rotation, &scale);
    return res;
}

matrix4 mat4_from_mat3(const matrix3 m)
{
    matrix4 res;
    mat4_from_mat3_ptr(&res, &m);
    return res;
}

vector3 mat4_extract_translation(const matrix4 m)
{
    vector3 res;
    mat4_extract_translation_ptr(&res, &m);
    return res;
}

vector3 mat4_extract_scale(const matrix4 m)
{
    vector3 res;
    mat4_extract_scale_ptr(&res, &m);
    return res;
}

quaternion mat4_extract_rotation(const matrix4 m)
{
    quaternion res;
    mat4_extract_rotation_ptr(&res, &m);
    return res;
}