glam 0.5.1

use approx::assert_ulps_eq;
use glam::f32::*;

const IDENTITY: [[f32; 4]; 4] = [
    [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],
];

const MATRIX: [[f32; 4]; 4] = [
    [1.0, 2.0, 3.0, 4.0],
    [5.0, 6.0, 7.0, 8.0],
    [9.0, 10.0, 11.0, 12.0],
    [13.0, 14.0, 15.0, 16.0],
];

const ZERO: [[f32; 4]; 4] = [[0.0; 4]; 4];

#[test]
fn test_mat4_identity() {
    let identity = Mat4::identity();
    assert_eq!(IDENTITY, Into::<[[f32; 4]; 4]>::into(identity));
    assert_eq!(Into::<Mat4>::into(IDENTITY), identity);
    assert_eq!(identity, identity * identity);
}

#[test]
fn test_mat4_zero() {
    assert_eq!(Into::<Mat4>::into(ZERO), Mat4::zero());
}

#[test]
fn test_mat4_accessors() {
    let mut m = Mat4::zero();
    m.set_x_axis(Vec4::new(1.0, 2.0, 3.0, 4.0));
    m.set_y_axis(Vec4::new(5.0, 6.0, 7.0, 8.0));
    m.set_z_axis(Vec4::new(9.0, 10.0, 11.0, 12.0));
    m.set_w_axis(Vec4::new(13.0, 14.0, 15.0, 16.0));
    assert_eq!(Into::<Mat4>::into(MATRIX), m);
    assert_eq!(Vec4::new(1.0, 2.0, 3.0, 4.0), m.x_axis());
    assert_eq!(Vec4::new(5.0, 6.0, 7.0, 8.0), m.y_axis());
    assert_eq!(Vec4::new(9.0, 10.0, 11.0, 12.0), m.z_axis());
    assert_eq!(Vec4::new(13.0, 14.0, 15.0, 16.0), m.w_axis());
}

#[test]
fn test_mat4_from_axes() {
    let a: Mat4 = [
        [1.0, 2.0, 3.0, 4.0],
        [5.0, 6.0, 7.0, 8.0],
        [9.0, 10.0, 11.0, 12.0],
        [13.0, 14.0, 15.0, 16.0],
    ]
    .into();
    assert_eq!(MATRIX, Into::<[[f32; 4]; 4]>::into(a));
    let b = Mat4::new(
        vec4(1.0, 2.0, 3.0, 4.0),
        vec4(5.0, 6.0, 7.0, 8.0),
        vec4(9.0, 10.0, 11.0, 12.0),
        vec4(13.0, 14.0, 15.0, 16.0),
    );
    assert_eq!(a, b);
    let c = mat4(
        vec4(1.0, 2.0, 3.0, 4.0),
        vec4(5.0, 6.0, 7.0, 8.0),
        vec4(9.0, 10.0, 11.0, 12.0),
        vec4(13.0, 14.0, 15.0, 16.0),
    );
    assert_eq!(a, c);
}

#[test]
fn test_mat4_translation() {
    let translate = Mat4::from_translation(vec3(1.0, 2.0, 3.0));
    assert_eq!(
        Mat4::new(
            vec4(1.0, 0.0, 0.0, 0.0),
            vec4(0.0, 1.0, 0.0, 0.0),
            vec4(0.0, 0.0, 1.0, 0.0),
            vec4(1.0, 2.0, 3.0, 1.0)
        ),
        translate
    );
}

#[test]
fn test_from_rotation() {
    let rot_x1 = Mat4::from_rotation_x(deg(180.0));
    let rot_x2 = Mat4::from_axis_angle(Vec3::unit_x(), deg(180.0));
    assert_ulps_eq!(rot_x1, rot_x2);
    let rot_y1 = Mat4::from_rotation_y(deg(180.0));
    let rot_y2 = Mat4::from_axis_angle(Vec3::unit_y(), deg(180.0));
    assert_ulps_eq!(rot_y1, rot_y2);
    let rot_z1 = Mat4::from_rotation_z(deg(180.0));
    let rot_z2 = Mat4::from_axis_angle(Vec3::unit_z(), deg(180.0));
    assert_ulps_eq!(rot_z1, rot_z2);
}

#[test]
fn test_mat4_mul() {
    let mat_a = Mat4::from_axis_angle(Vec3::unit_z(), deg(90.0));
    let result3 = Vec3::unit_y().rotate_mat4(&mat_a);
    assert_ulps_eq!(vec3(-1.0, 0.0, 0.0), result3);
    assert_ulps_eq!(result3, (Vec3::unit_y().extend(0.0) * mat_a).truncate());
    let result4 = Vec4::unit_y().transform_mat4(&mat_a);
    assert_ulps_eq!(vec4(-1.0, 0.0, 0.0, 0.0), result4);
    assert_ulps_eq!(result4, Vec4::unit_y() * mat_a);

    let mat_b = Mat4::from_scale_rotation_translation(
        Vec3::new(0.5, 1.5, 2.0),
        Quat::from_rotation_x(deg(90.0)),
        Vec3::new(1.0, 2.0, 3.0),
    );
    let result3 = Vec3::unit_y().rotate_mat4(&mat_b);
    assert_ulps_eq!(vec3(0.0, 0.0, 1.5), result3, epsilon = 1.0e-6);
    assert_ulps_eq!(result3, (Vec3::unit_y().extend(0.0) * mat_b).truncate());

    let result3 = Vec3::unit_y().transform_mat4(&mat_b);
    assert_ulps_eq!(vec3(1.0, 2.0, 4.5), result3, epsilon = 1.0e-6);
    assert_ulps_eq!(result3, (Vec3::unit_y().extend(1.0) * mat_b).truncate());
}

#[test]
fn test_from_ypr() {
    let zero = deg(0.0);
    let yaw = deg(30.0);
    let pitch = deg(60.0);
    let roll = deg(90.0);
    let y0 = Mat4::from_rotation_y(yaw);
    let y1 = Mat4::from_rotation_ypr(yaw, zero, zero);
    assert_ulps_eq!(y0, y1);

    let x0 = Mat4::from_rotation_x(pitch);
    let x1 = Mat4::from_rotation_ypr(zero, pitch, zero);
    assert_ulps_eq!(x0, x1);

    let z0 = Mat4::from_rotation_z(roll);
    let z1 = Mat4::from_rotation_ypr(zero, zero, roll);
    assert_ulps_eq!(z0, z1);

    let yx0 = y0 * x0;
    let yx1 = Mat4::from_rotation_ypr(yaw, pitch, zero);
    assert_ulps_eq!(yx0, yx1);

    let yxz0 = y0 * x0 * z0;
    let yxz1 = Mat4::from_rotation_ypr(yaw, pitch, roll);
    assert_ulps_eq!(yxz0, yxz1);
}

#[test]
fn test_from_scale() {
    let m = Mat4::from_scale(Vec3::new(2.0, 4.0, 8.0));
    assert_ulps_eq!(
        Vec3::new(1.0, 1.0, 1.0).transform_mat4(&m),
        Vec3::new(2.0, 4.0, 8.0)
    );
    assert_ulps_eq!(Vec4::unit_x() * 2.0, m.x_axis());
    assert_ulps_eq!(Vec4::unit_y() * 4.0, m.y_axis());
    assert_ulps_eq!(Vec4::unit_z() * 8.0, m.z_axis());
    assert_ulps_eq!(Vec4::unit_w(), m.w_axis());
}

#[test]
fn test_mat4_transpose() {
    let m = mat4(
        vec4(1.0, 2.0, 3.0, 4.0),
        vec4(5.0, 6.0, 7.0, 8.0),
        vec4(9.0, 10.0, 11.0, 12.0),
        vec4(13.0, 14.0, 15.0, 16.0),
    );
    let mt = m.transpose();
    assert_eq!(mt.x_axis(), vec4(1.0, 5.0, 9.0, 13.0));
    assert_eq!(mt.y_axis(), vec4(2.0, 6.0, 10.0, 14.0));
    assert_eq!(mt.z_axis(), vec4(3.0, 7.0, 11.0, 15.0));
    assert_eq!(mt.w_axis(), vec4(4.0, 8.0, 12.0, 16.0));
}

#[test]
fn test_mat4_det() {
    assert_eq!(0.0, Mat4::zero().determinant());
    assert_eq!(1.0, Mat4::identity().determinant());
    assert_eq!(1.0, Mat4::from_rotation_x(deg(90.0)).determinant());
    assert_eq!(1.0, Mat4::from_rotation_y(deg(180.0)).determinant());
    assert_eq!(1.0, Mat4::from_rotation_z(deg(270.0)).determinant());
    assert_eq!(
        2.0 * 2.0 * 2.0,
        Mat4::from_scale(vec3(2.0, 2.0, 2.0)).determinant()
    );
}

#[test]
fn test_mat4_inverse() {
    // assert_eq!(None, Mat4::zero().inverse());
    let inv = Mat4::identity().inverse();
    // assert_ne!(None, inv);
    assert_ulps_eq!(Mat4::identity(), inv);

    let rotz = Mat4::from_rotation_z(deg(90.0));
    let rotz_inv = rotz.inverse();
    // assert_ne!(None, rotz_inv);
    // let rotz_inv = rotz_inv.unwrap();
    assert_ulps_eq!(Mat4::identity(), rotz * rotz_inv);
    assert_ulps_eq!(Mat4::identity(), rotz_inv * rotz);

    let trans = Mat4::from_translation(vec3(1.0, 2.0, 3.0));
    let trans_inv = trans.inverse();
    // assert_ne!(None, trans_inv);
    // let trans_inv = trans_inv.unwrap();
    assert_ulps_eq!(Mat4::identity(), trans * trans_inv);
    assert_ulps_eq!(Mat4::identity(), trans_inv * trans);

    let scale = Mat4::from_scale(vec3(4.0, 5.0, 6.0));
    let scale_inv = scale.inverse();
    // assert_ne!(None, scale_inv);
    // let scale_inv = scale_inv.unwrap();
    assert_ulps_eq!(Mat4::identity(), scale * scale_inv);
    assert_ulps_eq!(Mat4::identity(), scale_inv * scale);

    let m = scale * rotz * trans;
    let m_inv = m.inverse();
    // assert_ne!(None, m_inv);
    // let m_inv = m_inv.unwrap();
    assert_ulps_eq!(Mat4::identity(), m * m_inv);
    assert_ulps_eq!(Mat4::identity(), m_inv * m);
    assert_ulps_eq!(m_inv, trans_inv * rotz_inv * scale_inv);
}

#[test]
fn test_mat4_look_at() {
    let eye = Vec3::new(0.0, 0.0, -5.0);
    let center = Vec3::new(0.0, 0.0, 0.0);
    let up = Vec3::new(1.0, 0.0, 0.0);
    let lh = Mat4::look_at_lh(eye, center, up);
    let rh = Mat4::look_at_rh(eye, center, up);
    let point = Vec3::new(1.0, 0.0, 0.0);
    assert_ulps_eq!(point.transform_mat4(&lh), Vec3::new(0.0, 1.0, -5.0));
    assert_ulps_eq!(point.transform_mat4(&rh), Vec3::new(0.0, 1.0, 5.0));
}

#[test]
fn test_mat4_ops() {
    let m0: Mat4 = MATRIX.into();
    let m0x2 = Mat4::from([
        [2.0, 4.0, 6.0, 8.0],
        [10.0, 12.0, 14.0, 16.0],
        [18.0, 20.0, 22.0, 24.0],
        [26.0, 28.0, 30.0, 32.0],
    ]);
    assert_eq!(m0x2, m0 * 2.0);
    assert_eq!(m0x2, 2.0 * m0);
    assert_eq!(m0x2, m0 + m0);
    assert_eq!(Mat4::zero(), m0 - m0);
    // TODO: Mat4 * Mat4 that's not identity
    assert_ulps_eq!(m0, m0 * Mat4::identity());
    assert_ulps_eq!(m0, Mat4::identity() * m0);
}