Current section
Files
Jump to
Current section
Files
src/matrix@mat4f.erl
-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, from_mat3/1, from_mat3_translation/2, from_translation/1, from_axis_angle/2, from_rotation_x/1, from_rotation_y/1, from_rotation_z/1, from_scale/1, inverse/1, look_to_rh/3, look_to_lh/3, look_at_lh/3, look_at_rh/3, transform_point3/2, transform_vector3/2, from_scale_rotation_translation/3, from_rotation_translation/2, from_quaternion/1, to_scale_rotation_translation/1]).
-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).
-file("src/matrix/mat4f.gleam", 219).
?DOC(
" Creates an affine transformation matrix from the given 3x3 linear transformation\n"
" matrix.\n"
"\n"
" The resulting matrix can be used to transform 3D points and vectors.\n"
).
-spec from_mat3(vec@vec3:vec3(vec@vec3:vec3(float()))) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_mat3(M) ->
from_cols(
matrix@internal@projection:extend3(erlang:element(2, M), +0.0),
matrix@internal@projection:extend3(erlang:element(3, M), +0.0),
matrix@internal@projection:extend3(erlang:element(4, M), +0.0),
{vec4, +0.0, +0.0, +0.0, 1.0}
).
-file("src/matrix/mat4f.gleam", 227).
?DOC(
" Creates an affine transformation matrics from a 3x3 matrix (expressing scale, shear and\n"
" rotation) and a translation vector.\n"
"\n"
" Equivalent to `multiply(from_translation(translation), from_mat3(mat3))`\n"
).
-spec from_mat3_translation(
vec@vec3:vec3(vec@vec3:vec3(float())),
vec@vec3:vec3(float())
) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_mat3_translation(Mat3, Translation) ->
from_cols(
matrix@internal@projection:extend3(erlang:element(2, Mat3), +0.0),
matrix@internal@projection:extend3(erlang:element(3, Mat3), +0.0),
matrix@internal@projection:extend3(erlang:element(4, Mat3), +0.0),
matrix@internal@projection:extend3(Translation, 1.0)
).
-file("src/matrix/mat4f.gleam", 239).
?DOC(
" Creates an affine transformation matrix from the given 3D `translation`.\n"
"\n"
" The resulting matrix can be used to transform 3D points and vectors.\n"
).
-spec from_translation(vec@vec3:vec3(float())) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_translation(Translation) ->
from_cols(
{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},
matrix@internal@projection:extend3(Translation, 1.0)
).
-file("src/matrix/mat4f.gleam", 247).
?DOC(
" Creates an affine transformation matrix containing a 3D rotation around a normalized\n"
" rotation `axis` of `angle` (in radians).\n"
"\n"
" The resulting matrix can be used to transform 3D points and vectors.\n"
).
-spec from_axis_angle(vec@vec3:vec3(float()), float()) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_axis_angle(Axis, Angle) ->
Axis@1 = vec@vec3f:normalize(Axis),
Sin = gleam_community@maths:sin(Angle),
Cos = gleam_community@maths:cos(Angle),
Axis_sin = vec@vec3f:scale(Axis@1, Sin),
Axis_sq = vec@vec3f:multiply(Axis@1, Axis@1),
Omc = 1.0 - Cos,
Xyomc = (erlang:element(2, Axis@1) * erlang:element(3, Axis@1)) * Omc,
Xzomc = (erlang:element(2, Axis@1) * erlang:element(4, Axis@1)) * Omc,
Yzomc = (erlang:element(3, Axis@1) * erlang:element(4, Axis@1)) * Omc,
from_cols(
{vec4,
(erlang:element(2, Axis_sq) * Omc) + Cos,
Xyomc + erlang:element(4, Axis_sin),
Xzomc - erlang:element(3, Axis_sin),
+0.0},
{vec4,
Xyomc - erlang:element(4, Axis_sin),
(erlang:element(3, Axis_sq) * Omc) + Cos,
Yzomc + erlang:element(2, Axis_sin),
+0.0},
{vec4,
Xzomc + erlang:element(3, Axis_sin),
Yzomc - erlang:element(2, Axis_sin),
(erlang:element(4, Axis_sq) * Omc) + Cos,
+0.0},
{vec4, +0.0, +0.0, +0.0, 1.0}
).
-file("src/matrix/mat4f.gleam", 269).
?DOC(
" Creates an affine transformation matrix containing a 3D rotation around the x axis of\n"
" `angle` (in radians).\n"
"\n"
" The resulting matrix can be used to transform 3D points and vectors.\n"
).
-spec from_rotation_x(float()) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_rotation_x(Angle) ->
Sin = gleam_community@maths:sin(Angle),
Cos = gleam_community@maths:cos(Angle),
from_cols(
{vec4, 1.0, +0.0, +0.0, +0.0},
{vec4, +0.0, Cos, Sin, +0.0},
{vec4, +0.0, +0.0 - Sin, Cos, +0.0},
{vec4, +0.0, +0.0, +0.0, 1.0}
).
-file("src/matrix/mat4f.gleam", 284).
?DOC(
" Creates an affine transformation matrix containing a 3D rotation around the y axis of\n"
" `angle` (in radians).\n"
"\n"
" The resulting matrix can be used to transform 3D points and vectors.\n"
).
-spec from_rotation_y(float()) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_rotation_y(Angle) ->
Sin = gleam_community@maths:sin(Angle),
Cos = gleam_community@maths:cos(Angle),
from_cols(
{vec4, Cos, +0.0, +0.0 - Sin, +0.0},
{vec4, +0.0, 1.0, +0.0, +0.0},
{vec4, Sin, +0.0, Cos, +0.0},
{vec4, +0.0, +0.0, +0.0, 1.0}
).
-file("src/matrix/mat4f.gleam", 299).
?DOC(
" Creates an affine transformation matrix containing a 3D rotation around the z axis of\n"
" `angle` (in radians).\n"
"\n"
" The resulting matrix can be used to transform 3D points and vectors.\n"
).
-spec from_rotation_z(float()) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_rotation_z(Angle) ->
Sin = gleam_community@maths:sin(Angle),
Cos = gleam_community@maths:cos(Angle),
from_cols(
{vec4, Cos, Sin, +0.0, +0.0},
{vec4, +0.0 - Sin, Cos, +0.0, +0.0},
{vec4, +0.0, +0.0, 1.0, +0.0},
{vec4, +0.0, +0.0, +0.0, 1.0}
).
-file("src/matrix/mat4f.gleam", 313).
?DOC(
" Creates an affine transformation matrix containing the given 3D non-uniform `scale`.\n"
"\n"
" The resulting matrix can be used to transform 3D points and vectors.\n"
).
-spec from_scale(vec@vec3:vec3(float())) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_scale(Scale) ->
from_diagonal(matrix@internal@projection:extend3(Scale, 1.0)).
-file("src/matrix/mat4f.gleam", 318).
?DOC(" Inverts the `Mat4f`, returning an error if the matrix is not invertible.\n").
-spec inverse(vec@vec4:vec4(vec@vec4:vec4(float()))) -> {ok,
vec@vec4:vec4(vec@vec4:vec4(float()))} |
{error, nil}.
inverse(Mat) ->
{vec4,
{vec4, M00, M01, M02, M03},
{vec4, M10, M11, M12, M13},
{vec4, M20, M21, M22, M23},
{vec4, M30, M31, M32, M33}} = Mat,
Coef00 = (M22 * M33) - (M32 * M23),
Coef02 = (M12 * M33) - (M32 * M13),
Coef03 = (M12 * M23) - (M22 * M13),
Coef04 = (M21 * M33) - (M31 * M23),
Coef06 = (M11 * M33) - (M31 * M13),
Coef07 = (M11 * M23) - (M21 * M13),
Coef08 = (M21 * M32) - (M31 * M22),
Coef10 = (M11 * M32) - (M31 * M12),
Coef11 = (M11 * M22) - (M21 * M12),
Coef12 = (M20 * M33) - (M30 * M23),
Coef14 = (M10 * M33) - (M30 * M13),
Coef15 = (M10 * M23) - (M20 * M13),
Coef16 = (M20 * M32) - (M30 * M22),
Coef18 = (M10 * M32) - (M30 * M12),
Coef19 = (M10 * M22) - (M20 * M12),
Coef20 = (M20 * M31) - (M30 * M21),
Coef22 = (M10 * M31) - (M30 * M11),
Coef23 = (M10 * M21) - (M20 * M11),
Fac0 = {vec4, Coef00, Coef00, Coef02, Coef03},
Fac1 = {vec4, Coef04, Coef04, Coef06, Coef07},
Fac2 = {vec4, Coef08, Coef08, Coef10, Coef11},
Fac3 = {vec4, Coef12, Coef12, Coef14, Coef15},
Fac4 = {vec4, Coef16, Coef16, Coef18, Coef19},
Fac5 = {vec4, Coef20, Coef20, Coef22, Coef23},
Vec0 = {vec4, M10, M00, M00, M00},
Vec1 = {vec4, M11, M01, M01, M01},
Vec2 = {vec4, M12, M02, M02, M02},
Vec3 = {vec4, M13, M03, M03, M03},
Inv0 = begin
_pipe = Vec1,
_pipe@1 = vec@vec4f:multiply(_pipe, Fac0),
_pipe@3 = vec@vec4f:subtract(
_pipe@1,
begin
_pipe@2 = Vec2,
vec@vec4f:multiply(_pipe@2, Fac1)
end
),
vec@vec4f:add(
_pipe@3,
begin
_pipe@4 = Vec3,
vec@vec4f:multiply(_pipe@4, Fac2)
end
)
end,
Inv1 = begin
_pipe@5 = Vec0,
_pipe@6 = vec@vec4f:multiply(_pipe@5, Fac0),
_pipe@8 = vec@vec4f:subtract(
_pipe@6,
begin
_pipe@7 = Vec2,
vec@vec4f:multiply(_pipe@7, Fac3)
end
),
vec@vec4f:add(
_pipe@8,
begin
_pipe@9 = Vec3,
vec@vec4f:multiply(_pipe@9, Fac4)
end
)
end,
Inv2 = begin
_pipe@10 = Vec0,
_pipe@11 = vec@vec4f:multiply(_pipe@10, Fac1),
_pipe@13 = vec@vec4f:subtract(
_pipe@11,
begin
_pipe@12 = Vec1,
vec@vec4f:multiply(_pipe@12, Fac3)
end
),
vec@vec4f:add(
_pipe@13,
begin
_pipe@14 = Vec3,
vec@vec4f:multiply(_pipe@14, Fac5)
end
)
end,
Inv3 = begin
_pipe@15 = Vec0,
_pipe@16 = vec@vec4f:multiply(_pipe@15, Fac2),
_pipe@18 = vec@vec4f:subtract(
_pipe@16,
begin
_pipe@17 = Vec1,
vec@vec4f:multiply(_pipe@17, Fac4)
end
),
vec@vec4f:add(
_pipe@18,
begin
_pipe@19 = Vec2,
vec@vec4f:multiply(_pipe@19, Fac5)
end
)
end,
Sign_a = {vec4, 1.0, -1.0, 1.0, -1.0},
Sign_b = {vec4, -1.0, 1.0, -1.0, 1.0},
Inverse = from_cols(
begin
_pipe@20 = Inv0,
vec@vec4f:multiply(_pipe@20, Sign_a)
end,
begin
_pipe@21 = Inv1,
vec@vec4f:multiply(_pipe@21, Sign_b)
end,
begin
_pipe@22 = Inv2,
vec@vec4f:multiply(_pipe@22, Sign_a)
end,
begin
_pipe@23 = Inv3,
vec@vec4f:multiply(_pipe@23, Sign_b)
end
),
Col0 = {vec4,
erlang:element(2, erlang:element(2, Inverse)),
erlang:element(2, erlang:element(3, Inverse)),
erlang:element(2, erlang:element(4, Inverse)),
erlang:element(2, erlang:element(5, Inverse))},
Dot0 = begin
_pipe@24 = erlang:element(2, Mat),
vec@vec4f:multiply(_pipe@24, Col0)
end,
Dot1 = ((erlang:element(2, Dot0) + erlang:element(3, Dot0)) + erlang:element(
4,
Dot0
))
+ erlang:element(5, Dot0),
gleam@result:map(
gleam@float:divide(1.0, Dot1),
fun(_capture) -> scale(Inverse, _capture) end
).
-file("src/matrix/mat4f.gleam", 409).
?DOC(
" Creates a right-handed view matrix using a camera position, a facing direction, and an up\n"
" direction.\n"
"\n"
" For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n"
).
-spec look_to_rh(
vec@vec3:vec3(float()),
vec@vec3:vec3(float()),
vec@vec3:vec3(float())
) -> vec@vec4:vec4(vec@vec4:vec4(float())).
look_to_rh(Eye, Dir, Up) ->
F = Dir,
S = begin
_pipe = vec@vec3f:cross(F, Up),
vec@vec3f:normalize(_pipe)
end,
U = vec@vec3f:cross(S, F),
Neg_f = vec@vec3f:negate(F),
Neg_dot_s = gleam@float:negate(vec@vec3f:dot(Eye, S)),
Neg_dot_u = gleam@float:negate(vec@vec3f:dot(Eye, U)),
Dot_f = vec@vec3f:dot(Eye, F),
from_cols(
{vec4,
erlang:element(2, S),
erlang:element(2, U),
erlang:element(2, Neg_f),
+0.0},
{vec4,
erlang:element(3, S),
erlang:element(3, U),
erlang:element(3, Neg_f),
+0.0},
{vec4,
erlang:element(4, S),
erlang:element(4, U),
erlang:element(4, Neg_f),
+0.0},
{vec4, Neg_dot_s, Neg_dot_u, Dot_f, 1.0}
).
-file("src/matrix/mat4f.gleam", 401).
?DOC(
" Creates a left-handed view matrix using a camera position, a facing direction and an up\n"
" direction\n"
"\n"
" For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n"
).
-spec look_to_lh(
vec@vec3:vec3(float()),
vec@vec3:vec3(float()),
vec@vec3:vec3(float())
) -> vec@vec4:vec4(vec@vec4:vec4(float())).
look_to_lh(Eye, Dir, Up) ->
look_to_rh(Eye, vec@vec3f:negate(Dir), Up).
-file("src/matrix/mat4f.gleam", 430).
?DOC(
" Creates a left-handed view matrix using a camera position, a focal points and an up\n"
" direction.\n"
"\n"
" For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n"
).
-spec look_at_lh(
vec@vec3:vec3(float()),
vec@vec3:vec3(float()),
vec@vec3:vec3(float())
) -> vec@vec4:vec4(vec@vec4:vec4(float())).
look_at_lh(Eye, Center, Up) ->
look_to_lh(
Eye,
begin
_pipe = Center,
_pipe@1 = vec@vec3f:subtract(_pipe, Eye),
vec@vec3f:normalize(_pipe@1)
end,
Up
).
-file("src/matrix/mat4f.gleam", 438).
?DOC(
" Creates a right-handed view matrix using a camera position, a focal point, and an up\n"
" direction.\n"
"\n"
" For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n"
).
-spec look_at_rh(
vec@vec3:vec3(float()),
vec@vec3:vec3(float()),
vec@vec3:vec3(float())
) -> vec@vec4:vec4(vec@vec4:vec4(float())).
look_at_rh(Eye, Center, Up) ->
look_to_rh(
Eye,
begin
_pipe = Center,
_pipe@1 = vec@vec3f:subtract(_pipe, Eye),
vec@vec3f:normalize(_pipe@1)
end,
Up
).
-file("src/matrix/mat4f.gleam", 448).
?DOC(
" Transforms the given 3D vector as a point.\n"
"\n"
" This is the equivalent of multiplying the 3D vector as a 4D vector where `w` is\n"
" `1.0`.\n"
"\n"
" This function assumes that `mat` contains a valid affine transform.\n"
).
-spec transform_point3(
vec@vec4:vec4(vec@vec4:vec4(float())),
vec@vec3:vec3(float())
) -> vec@vec3:vec3(float()).
transform_point3(Mat, Rhs) ->
_pipe = vec@vec4f:scale(erlang:element(2, Mat), erlang:element(2, Rhs)),
_pipe@1 = vec@vec4f:add(
_pipe,
vec@vec4f:scale(erlang:element(3, Mat), erlang:element(3, Rhs))
),
_pipe@2 = vec@vec4f:add(
_pipe@1,
vec@vec4f:scale(erlang:element(4, Mat), erlang:element(4, Rhs))
),
_pipe@3 = vec@vec4f:add(_pipe@2, erlang:element(5, Mat)),
matrix@internal@projection:to_xyz(_pipe@3).
-file("src/matrix/mat4f.gleam", 462).
?DOC(
" Transforms the given 3D vector as a direction.\n"
"\n"
" This is the equivalent of multiplying the 3D vector as a 4D vector where `w` is\n"
" `0.0`.\n"
"\n"
" This method assumes that `mat` contains a valid affine transform.\n"
).
-spec transform_vector3(
vec@vec4:vec4(vec@vec4:vec4(float())),
vec@vec3:vec3(float())
) -> vec@vec3:vec3(float()).
transform_vector3(Mat, Rhs) ->
_pipe = vec@vec4f:scale(erlang:element(2, Mat), erlang:element(2, Rhs)),
_pipe@1 = vec@vec4f:add(
_pipe,
vec@vec4f:scale(erlang:element(3, Mat), erlang:element(3, Rhs))
),
_pipe@2 = vec@vec4f:add(
_pipe@1,
vec@vec4f:scale(erlang:element(4, Mat), erlang:element(4, Rhs))
),
matrix@internal@projection:to_xyz(_pipe@2).
-file("src/matrix/mat4f.gleam", 471).
-spec quat_to_axes(vec@vec4:vec4(float())) -> vec@vec3:vec3(vec@vec4:vec4(float())).
quat_to_axes(Rotation) ->
{vec4, X, Y, Z, W} = vec@vec4f:normalize(Rotation),
X2 = X + X,
Y2 = Y + Y,
Z2 = Z + Z,
Xx = X * X2,
Xy = X * Y2,
Xz = X * Z2,
Yy = Y * Y2,
Yz = Y * Z2,
Zz = Z * Z2,
Wx = W * X2,
Wy = Y * Y2,
Wz = W * Z2,
X_axis = {vec4, 1.0 - (Yy + Zz), Xy + Wz, Xz - Wy, +0.0},
Y_axis = {vec4, Xy - Wz, 1.0 - (Xx + Zz), Yz + Wx, +0.0},
Z_axis = {vec4, Xz + Wy, Yz - Wx, 1.0 - (Xx + Yy), +0.0},
{vec3, X_axis, Y_axis, Z_axis}.
-file("src/matrix/mat4f.gleam", 150).
?DOC(
" Creates an affine transformation matrix from the given 3D `scale`, `rotation` and\n"
" `translation`.\n"
"\n"
" The resulting matrix can be used to transform 3D points and vectors.\n"
).
-spec from_scale_rotation_translation(
vec@vec3:vec3(float()),
vec@vec4:vec4(float()),
vec@vec3:vec3(float())
) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_scale_rotation_translation(Scale, Rotation, Translation) ->
Axes = begin
_pipe = Rotation,
_pipe@1 = quat_to_axes(_pipe),
vec@vec3:map2(_pipe@1, Scale, fun vec@vec4f:scale/2)
end,
from_cols(
erlang:element(2, Axes),
erlang:element(3, Axes),
erlang:element(4, Axes),
matrix@internal@projection:extend3(Translation, 1.0)
).
-file("src/matrix/mat4f.gleam", 166).
?DOC(
" Creates an affine transformation matrix from the given 3D `translation`.\n"
"\n"
" The resulting matrix can be used to transform 3D points and vectors.\n"
).
-spec from_rotation_translation(vec@vec4:vec4(float()), vec@vec3:vec3(float())) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_rotation_translation(Rotation, Translation) ->
from_scale_rotation_translation(
{vec3, 1.0, 1.0, 1.0},
Rotation,
Translation
).
-file("src/matrix/mat4f.gleam", 210).
?DOC(
" Creates an affine transformation matrix from the given `rotation` quaternion.\n"
"\n"
" The resulting matrix can be used to transform 3D points and vectors.\n"
).
-spec from_quaternion(vec@vec4:vec4(float())) -> vec@vec4:vec4(vec@vec4:vec4(float())).
from_quaternion(Q) ->
Rotation = quat_to_axes(Q),
from_cols(
erlang:element(2, Rotation),
erlang:element(3, Rotation),
erlang:element(4, Rotation),
{vec4, +0.0, +0.0, +0.0, 1.0}
).
-file("src/matrix/mat4f.gleam", 493).
-spec quat_from_rotation_axes(
vec@vec3:vec3(float()),
vec@vec3:vec3(float()),
vec@vec3:vec3(float())
) -> vec@vec4:vec4(float()).
quat_from_rotation_axes(X_axis, Y_axis, Z_axis) ->
{vec3, M00, M01, M02} = X_axis,
{vec3, M10, M11, M12} = Y_axis,
{vec3, M20, M21, M22} = Z_axis,
case M22 =< +0.0 of
true ->
Dif10 = M11 - M00,
Omm22 = 1.0 - M22,
case Dif10 =< +0.0 of
true ->
Four_xsq = Omm22 - Dif10,
Inv4x = begin
Four_x@1 = case gleam@float:square_root(Four_xsq) of
{ok, Four_x} -> Four_x;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"matrix/mat4f"/utf8>>,
function => <<"quat_from_rotation_axes"/utf8>>,
line => 512,
value => _assert_fail,
start => 15383,
'end' => 15434,
pattern_start => 15394,
pattern_end => 15404})
end,
case Four_x@1 of
+0.0 -> +0.0;
-0.0 -> -0.0;
Gleam@denominator -> 0.5 / Gleam@denominator
end
end,
{vec4,
Four_xsq * Inv4x,
(M01 + M10) * Inv4x,
(M02 + M20) * Inv4x,
(M12 - M21) * Inv4x};
false ->
Four_ysq = Omm22 + Dif10,
Inv4y = begin
Four_y@1 = case gleam@float:square_root(Four_ysq) of
{ok, Four_y} -> Four_y;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"matrix/mat4f"/utf8>>,
function => <<"quat_from_rotation_axes"/utf8>>,
line => 526,
value => _assert_fail@1,
start => 15772,
'end' => 15823,
pattern_start => 15783,
pattern_end => 15793})
end,
case Four_y@1 of
+0.0 -> +0.0;
-0.0 -> -0.0;
Gleam@denominator@1 -> 0.5 / Gleam@denominator@1
end
end,
{vec4,
(M01 + M10) * Inv4y,
Four_ysq * Inv4y,
(M12 + M21) * Inv4y,
(M20 - M02) * Inv4y}
end;
false ->
Sum10 = M11 + M00,
Opm22 = 1.0 + M22,
case Sum10 =< +0.0 of
true ->
Four_zsq = Opm22 - Sum10,
Inv4z = begin
Four_z@1 = case gleam@float:square_root(Four_zsq) of
{ok, Four_z} -> Four_z;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"matrix/mat4f"/utf8>>,
function => <<"quat_from_rotation_axes"/utf8>>,
line => 547,
value => _assert_fail@2,
start => 16306,
'end' => 16357,
pattern_start => 16317,
pattern_end => 16327})
end,
case Four_z@1 of
+0.0 -> +0.0;
-0.0 -> -0.0;
Gleam@denominator@2 -> 0.5 / Gleam@denominator@2
end
end,
{vec4,
(M02 + M20) * Inv4z,
(M12 + M21) * Inv4z,
Four_zsq * Inv4z,
(M01 - M10) * Inv4z};
false ->
Four_wsq = Opm22 + Sum10,
Inv4w = begin
Four_w@1 = case gleam@float:square_root(Four_wsq) of
{ok, Four_w} -> Four_w;
_assert_fail@3 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"matrix/mat4f"/utf8>>,
function => <<"quat_from_rotation_axes"/utf8>>,
line => 561,
value => _assert_fail@3,
start => 16695,
'end' => 16746,
pattern_start => 16706,
pattern_end => 16716})
end,
case Four_w@1 of
+0.0 -> +0.0;
-0.0 -> -0.0;
Gleam@denominator@3 -> 0.5 / Gleam@denominator@3
end
end,
{vec4,
(M12 - M21) * Inv4w,
(M20 - M02) * Inv4w,
(M01 - M10) * Inv4w,
Four_wsq * Inv4w}
end
end.
-file("src/matrix/mat4f.gleam", 175).
?DOC(
" Extracts `scale`, `rotation` and `translation` from `mat`. The input matrix is\n"
" expected to be a 3D affine transformation matrix otherwise the output will be invalid.\n"
"\n"
" Will return `Error(Nil)` if the determinant of `mat` is zero or if the resulting scale vector\n"
" contains any zero elements.\n"
).
-spec to_scale_rotation_translation(vec@vec4:vec4(vec@vec4:vec4(float()))) -> {ok,
{vec@vec3:vec3(float()), vec@vec4:vec4(float()), vec@vec3:vec3(float())}} |
{error, nil}.
to_scale_rotation_translation(Mat) ->
Det = determinant(Mat),
gleam@result:'try'(
gleam@float:divide(Det, gleam@float:absolute_value(Det)),
fun(Signum) ->
Scale = {vec3,
vec@vec4f:length(erlang:element(2, Mat)) * Signum,
vec@vec4f:length(erlang:element(3, Mat)),
vec@vec4f:length(erlang:element(4, Mat))},
gleam@bool:guard(
not vec@vec3f:loosely_equals(
Scale,
{vec3, +0.0, +0.0, +0.0},
0.0000001
),
{error, nil},
fun() ->
gleam@result:map(
begin
_pipe = Scale,
_pipe@1 = vec@vec3:map(
_pipe,
fun(_capture) ->
gleam@float:divide(1.0, _capture)
end
),
vec@vec3:result(_pipe@1)
end,
fun(Inv_scale) ->
Rotation = quat_from_rotation_axes(
begin
_pipe@2 = erlang:element(2, Mat),
_pipe@3 = vec@vec4f:scale(
_pipe@2,
erlang:element(2, Inv_scale)
),
matrix@internal@projection:to_xyz(_pipe@3)
end,
begin
_pipe@4 = erlang:element(3, Mat),
_pipe@5 = vec@vec4f:scale(
_pipe@4,
erlang:element(3, Inv_scale)
),
matrix@internal@projection:to_xyz(_pipe@5)
end,
begin
_pipe@6 = erlang:element(4, Mat),
_pipe@7 = vec@vec4f:scale(
_pipe@6,
erlang:element(4, Inv_scale)
),
matrix@internal@projection:to_xyz(_pipe@7)
end
),
{Scale,
Rotation,
matrix@internal@projection:to_xyz(
erlang:element(5, Mat)
)}
end
)
end
)
end
).