mirror of
https://github.com/luanti-org/luanti.git
synced 2025-07-22 17:18:39 +00:00
112 lines
3.1 KiB
C++
112 lines
3.1 KiB
C++
// Luanti
|
|
// SPDX-License-Identifier: LGPL-2.1-or-later
|
|
|
|
#include "catch.h"
|
|
#include "catch_amalgamated.hpp"
|
|
#include "irrMath.h"
|
|
#include "matrix4.h"
|
|
#include "irr_v3d.h"
|
|
|
|
using matrix4 = core::matrix4;
|
|
|
|
static bool matrix_equals(const matrix4 &a, const matrix4 &b) {
|
|
return a.equals(b, 0.00001f);
|
|
}
|
|
|
|
constexpr v3f x{1, 0, 0};
|
|
constexpr v3f y{0, 1, 0};
|
|
constexpr v3f z{0, 0, 1};
|
|
|
|
TEST_CASE("matrix4") {
|
|
|
|
SECTION("setRotationRadians") {
|
|
SECTION("rotation order is ZYX (matrix notation)") {
|
|
v3f rot{1, 2, 3};
|
|
matrix4 X, Y, Z, ZYX;
|
|
X.setRotationRadians({rot.X, 0, 0});
|
|
Y.setRotationRadians({0, rot.Y, 0});
|
|
Z.setRotationRadians({0, 0, rot.Z});
|
|
ZYX.setRotationRadians(rot);
|
|
CHECK(!matrix_equals(X * Y * Z, ZYX));
|
|
CHECK(!matrix_equals(X * Z * Y, ZYX));
|
|
CHECK(!matrix_equals(Y * X * Z, ZYX));
|
|
CHECK(!matrix_equals(Y * Z * X, ZYX));
|
|
CHECK(!matrix_equals(Z * X * Y, ZYX));
|
|
CHECK(matrix_equals(Z * Y * X, ZYX));
|
|
}
|
|
|
|
const f32 quarter_turn = core::PI / 2;
|
|
|
|
// See https://en.wikipedia.org/wiki/Right-hand_rule#/media/File:Cartesian_coordinate_system_handedness.svg
|
|
// for a visualization of what handedness means for rotations
|
|
|
|
SECTION("rotation is right-handed") {
|
|
SECTION("rotation around the X-axis is Z-up, counter-clockwise") {
|
|
matrix4 X;
|
|
X.setRotationRadians({quarter_turn, 0, 0});
|
|
CHECK(X.transformVect(x).equals(x));
|
|
CHECK(X.transformVect(y).equals(z));
|
|
CHECK(X.transformVect(z).equals(-y));
|
|
}
|
|
|
|
SECTION("rotation around the Y-axis is Z-up, clockwise") {
|
|
matrix4 Y;
|
|
Y.setRotationRadians({0, quarter_turn, 0});
|
|
CHECK(Y.transformVect(y).equals(y));
|
|
CHECK(Y.transformVect(x).equals(-z));
|
|
CHECK(Y.transformVect(z).equals(x));
|
|
}
|
|
|
|
SECTION("rotation around the Z-axis is Y-up, counter-clockwise") {
|
|
matrix4 Z;
|
|
Z.setRotationRadians({0, 0, quarter_turn});
|
|
CHECK(Z.transformVect(z).equals(z));
|
|
CHECK(Z.transformVect(x).equals(y));
|
|
CHECK(Z.transformVect(y).equals(-x));
|
|
}
|
|
}
|
|
}
|
|
|
|
SECTION("getScale") {
|
|
SECTION("correctly gets the length of each row of the 3x3 submatrix") {
|
|
matrix4 A(
|
|
1, 2, 3, 0,
|
|
4, 5, 6, 0,
|
|
7, 8, 9, 0,
|
|
0, 0, 0, 1
|
|
);
|
|
v3f scale = A.getScale();
|
|
CHECK(scale.equals(v3f(
|
|
v3f(1, 2, 3).getLength(),
|
|
v3f(4, 5, 6).getLength(),
|
|
v3f(7, 8, 9).getLength()
|
|
)));
|
|
}
|
|
}
|
|
|
|
SECTION("getRotationDegrees") {
|
|
auto test_rotation_degrees = [](v3f deg) {
|
|
matrix4 S;
|
|
Catch::Generators::RandomFloatingGenerator<f32> gen(0.1f, 10, Catch::getSeed());
|
|
S.setScale({gen.get(), gen.get(), gen.get()});
|
|
|
|
matrix4 R;
|
|
R.setRotationDegrees(deg);
|
|
v3f rot = (R * S).getRotationDegrees();
|
|
matrix4 B;
|
|
B.setRotationDegrees(rot);
|
|
CHECK(matrix_equals(R, B));
|
|
};
|
|
SECTION("returns a rotation equivalent to the original rotation") {
|
|
test_rotation_degrees({100, 200, 300});
|
|
Catch::Generators::RandomFloatingGenerator<f32> gen(0, 360, Catch::getSeed());
|
|
for (int i = 0; i < 1000; ++i)
|
|
test_rotation_degrees(v3f{gen.get(), gen.get(), gen.get()});
|
|
for (f32 i = 0; i < 360; i += 90)
|
|
for (f32 j = 0; j < 360; j += 90)
|
|
for (f32 k = 0; k < 360; k += 90)
|
|
test_rotation_degrees({i, j, k});
|
|
}
|
|
}
|
|
|
|
}
|