-module(matrix@mat4f).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/matrix/mat4f.gleam").
-export([new/16, from_cols/4, from_diagonal/1, transpose/1, diagonal/1, determinant/1, mul_vec4/2, mul_transpose_vec4/2, scale/2, add/2, subtract/2]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(" 4x4 matrices of floats\n").

-file("src/matrix/mat4f.gleam", 31).
?DOC(
    " Constructs a `Mat4f` from its components.\n"
    " ```text\n"
    " | ax  bx  cx  dx |\n"
    " | ay  by  cy  dy |\n"
    " | az  bz  cz  dz |\n"
    " | aw  bw  cw  dw |\n"
    " ```\n"
).
-spec new(
    float(),
    float(),
    float(),
    float(),
    float(),
    float(),
    float(),
    float(),
    float(),
    float(),
    float(),
    float(),
    float(),
    float(),
    float(),
    float()
) -> vec@vec4:vec4(vec@vec4:vec4(float())).
new(Ax, Ay, Az, Aw, Bx, By, Bz, Bw, Cx, Cy, Cz, Cw, Dx, Dy, Dz, Dw) ->
    {vec4,
        {vec4, Ax, Ay, Az, Aw},
        {vec4, Bx, By, Bz, Bw},
        {vec4, Cx, Cy, Cz, Cw},
        {vec4, Dx, Dy, Dz, Dw}}.

-file("src/matrix/mat4f.gleam", 64).
?DOC(
    " Constructs a `Mat4f` from its four columns.\n"
    " ```text\n"
    " | a.x  b.x  c.x  d.x |\n"
    " | a.y  b.y  c.y  d.y |\n"
    " | a.z  b.z  c.z  d.z |\n"
    " | a.w  b.w  c.w  d.w |\n"
    " ```\n"
).
-spec from_cols(
    vec@vec4:vec4(float()),
    vec@vec4:vec4(float()),
    vec@vec4:vec4(float()),
    vec@vec4:vec4(float())
) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_cols(A, B, C, D) ->
    {vec4, A, B, C, D}.

-file("src/matrix/mat4f.gleam", 69).
?DOC(" Creates a 4x4 matrix with its diagonal set to `diagonal` and all other entries are 0.\n").
-spec from_diagonal(vec@vec4:vec4(float())) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_diagonal(Diagonal) ->
    from_cols(
        {vec4, erlang:element(2, Diagonal), +0.0, +0.0, +0.0},
        {vec4, +0.0, erlang:element(3, Diagonal), +0.0, +0.0},
        {vec4, +0.0, +0.0, erlang:element(4, Diagonal), +0.0},
        {vec4, +0.0, +0.0, +0.0, erlang:element(5, Diagonal)}
    ).

-file("src/matrix/mat4f.gleam", 79).
?DOC(" Transposes the `Mat4f` along the diagonal.\n").
-spec transpose(vec@vec4:vec4(vec@vec4:vec4(float()))) -> vec@vec4:vec4(vec@vec4:vec4(float())).
transpose(Mat) ->
    from_cols(
        {vec4,
            erlang:element(2, erlang:element(2, Mat)),
            erlang:element(2, erlang:element(3, Mat)),
            erlang:element(2, erlang:element(4, Mat)),
            erlang:element(2, erlang:element(5, Mat))},
        {vec4,
            erlang:element(3, erlang:element(2, Mat)),
            erlang:element(3, erlang:element(3, Mat)),
            erlang:element(3, erlang:element(4, Mat)),
            erlang:element(3, erlang:element(5, Mat))},
        {vec4,
            erlang:element(4, erlang:element(2, Mat)),
            erlang:element(4, erlang:element(3, Mat)),
            erlang:element(4, erlang:element(4, Mat)),
            erlang:element(4, erlang:element(5, Mat))},
        {vec4,
            erlang:element(5, erlang:element(2, Mat)),
            erlang:element(5, erlang:element(3, Mat)),
            erlang:element(5, erlang:element(4, Mat)),
            erlang:element(5, erlang:element(5, Mat))}
    ).

-file("src/matrix/mat4f.gleam", 89).
?DOC(" Extracts the diagonal of the `Mat4f`.\n").
-spec diagonal(vec@vec4:vec4(vec@vec4:vec4(float()))) -> vec@vec4:vec4(float()).
diagonal(Mat) ->
    {vec4,
        erlang:element(2, erlang:element(2, Mat)),
        erlang:element(3, erlang:element(3, Mat)),
        erlang:element(4, erlang:element(4, Mat)),
        erlang:element(5, erlang:element(5, Mat))}.

-file("src/matrix/mat4f.gleam", 94).
?DOC(" Returns the determinant of the `Mat4f`.\n").
-spec determinant(vec@vec4:vec4(vec@vec4:vec4(float()))) -> float().
determinant(Mat) ->
    {vec4, M00, M01, M02, M03} = erlang:element(2, Mat),
    {vec4, M10, M11, M12, M13} = erlang:element(3, Mat),
    {vec4, M20, M21, M22, M23} = erlang:element(4, Mat),
    {vec4, M30, M31, M32, M33} = erlang:element(5, Mat),
    A2323 = (M22 * M33) - (M23 * M32),
    A1323 = (M21 * M33) - (M23 * M31),
    A1223 = (M21 * M32) - (M22 * M31),
    A0323 = (M20 * M33) - (M23 * M30),
    A0223 = (M20 * M32) - (M22 * M30),
    A0123 = (M20 * M31) - (M21 * M30),
    (((M00 * (((M11 * A2323) - (M12 * A1323)) + (M13 * A1223))) - (M01 * (((M10
    * A2323)
    - (M12 * A0323))
    + (M13 * A0223))))
    + (M02 * (((M10 * A1323) - (M11 * A0323)) + (M13 * A0123))))
    - (M03 * (((M10 * A1223) - (M11 * A0223)) + (M12 * A0123))).

-file("src/matrix/mat4f.gleam", 118).
?DOC(" Transforms a 4D vector by this `Mat4f`.\n").
-spec mul_vec4(vec@vec4:vec4(vec@vec4:vec4(float())), vec@vec4:vec4(float())) -> vec@vec4:vec4(float()).
mul_vec4(Mat, Rhs) ->
    _pipe = vec@vec4:map2(Mat, Rhs, fun vec@vec4f:scale/2),
    _pipe@1 = vec@vec4:to_list(_pipe),
    vec@vec4f:sum(_pipe@1).

-file("src/matrix/mat4f.gleam", 127).
?DOC(
    " Transforms a 4D vector by the transpose of the `Mat4f`.\n"
    "\n"
    " Equivalent to matrix multiplication where the vector is on the left.\n"
).
-spec mul_transpose_vec4(
    vec@vec4:vec4(vec@vec4:vec4(float())),
    vec@vec4:vec4(float())
) -> vec@vec4:vec4(float()).
mul_transpose_vec4(Mat, Rhs) ->
    vec@vec4:map(Mat, fun(_capture) -> vec@vec4f:dot(_capture, Rhs) end).

-file("src/matrix/mat4f.gleam", 132).
?DOC(" Scales the `Mat4f` by a `Float`.\n").
-spec scale(vec@vec4:vec4(vec@vec4:vec4(float())), float()) -> vec@vec4:vec4(vec@vec4:vec4(float())).
scale(Mat, Scale) ->
    vec@vec4:map(Mat, fun(_capture) -> vec@vec4f:scale(_capture, Scale) end).

-file("src/matrix/mat4f.gleam", 137).
?DOC(" Adds two `Mat4f`s together\n").
-spec add(
    vec@vec4:vec4(vec@vec4:vec4(float())),
    vec@vec4:vec4(vec@vec4:vec4(float()))
) -> vec@vec4:vec4(vec@vec4:vec4(float())).
add(A, B) ->
    vec@vec4:map2(A, B, fun vec@vec4f:add/2).

-file("src/matrix/mat4f.gleam", 142).
?DOC(" Subtracts `Mat4f` `b` from `a`\n").
-spec subtract(
    vec@vec4:vec4(vec@vec4:vec4(float())),
    vec@vec4:vec4(vec@vec4:vec4(float()))
) -> vec@vec4:vec4(vec@vec4:vec4(float())).
subtract(A, B) ->
    vec@vec4:map2(A, B, fun vec@vec4f:subtract/2).