admin/omath
1
0
Fork 0
mirror of https://github.com/orange-cpp/omath.git synced 2026-02-13 07:03:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

changed code style

Browse Source
This commit is contained in:
Orange
2025-05-03 20:31:59 +03:00
parent be3fae63b8
commit df6d75e554
70 changed files with 1258 additions and 1312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
tests/engines/unit_test_iw_engine.cpp
View File

@@ -9,69 +9,69 @@
TEST(UnitTestIwEngine, ForwardVector)
{
const auto forward = omath::iw_engine::ForwardVector({});
const auto forward = omath::iw_engine::forward_vector({});
EXPECT_EQ(forward, omath::iw_engine::kAbsForward);
EXPECT_EQ(forward, omath::iw_engine::k_abs_forward);
}
TEST(UnitTestIwEngine, RightVector)
{
const auto right = omath::iw_engine::RightVector({});
const auto right = omath::iw_engine::right_vector({});
EXPECT_EQ(right, omath::iw_engine::kAbsRight);
EXPECT_EQ(right, omath::iw_engine::k_abs_right);
}
TEST(UnitTestIwEngine, UpVector)
{
const auto up = omath::iw_engine::UpVector({});
EXPECT_EQ(up, omath::iw_engine::kAbsUp);
const auto up = omath::iw_engine::up_vector({});
EXPECT_EQ(up, omath::iw_engine::k_abs_up);
}
TEST(UnitTestIwEngine, ForwardVectorRotationYaw)
{
omath::iw_engine::ViewAngles angles;
angles.yaw = omath::iw_engine::YawAngle::FromDegrees(-90.f);
angles.yaw = omath::iw_engine::YawAngle::from_degrees(-90.f);
const auto forward = omath::iw_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::iw_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::iw_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::iw_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::iw_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestIwEngine, ForwardVectorRotationPitch)
{
omath::iw_engine::ViewAngles angles;
angles.pitch = omath::iw_engine::PitchAngle::FromDegrees(-89.f);
angles.pitch = omath::iw_engine::PitchAngle::from_degrees(-89.f);
const auto forward = omath::iw_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::kAbsUp.x, 0.02f);
EXPECT_NEAR(forward.y, omath::iw_engine::kAbsUp.y, 0.01f);
EXPECT_NEAR(forward.z, omath::iw_engine::kAbsUp.z, 0.01f);
const auto forward = omath::iw_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::k_abs_up.x, 0.02f);
EXPECT_NEAR(forward.y, omath::iw_engine::k_abs_up.y, 0.01f);
EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_up.z, 0.01f);
}
TEST(UnitTestIwEngine, ForwardVectorRotationRoll)
{
omath::iw_engine::ViewAngles angles;
angles.roll = omath::iw_engine::RollAngle::FromDegrees(90.f);
angles.roll = omath::iw_engine::RollAngle::from_degrees(90.f);
const auto forward = omath::iw_engine::UpVector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::iw_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::iw_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::iw_engine::up_vector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::iw_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestIwEngine, ProjectTargetMovedFromCamera)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
const auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
for (float distance = 0.02f; distance < 1000.f; distance += 0.01f)
{
const auto projected = cam.WorldToScreen({distance, 0, 0});
const auto projected = cam.world_to_screen({distance, 0, 0});
EXPECT_TRUE(projected.has_value());
@@ -85,21 +85,21 @@ TEST(UnitTestIwEngine, ProjectTargetMovedFromCamera)
TEST(UnitTestIwEngine, CameraSetAndGetFov)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}
TEST(UnitTestIwEngine, CameraSetAndGetOrigin)
{
auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}

60
tests/engines/unit_test_open_gl.cpp
View File

@@ -9,32 +9,32 @@
TEST(UnitTestOpenGL, ForwardVector)
{
const auto forward = omath::opengl_engine::ForwardVector({});
EXPECT_EQ(forward, omath::opengl_engine::kAbsForward);
const auto forward = omath::opengl_engine::forward_vector({});
EXPECT_EQ(forward, omath::opengl_engine::k_abs_forward);
}
TEST(UnitTestOpenGL, RightVector)
{
const auto right = omath::opengl_engine::RightVector({});
EXPECT_EQ(right, omath::opengl_engine::kAbsRight);
const auto right = omath::opengl_engine::right_vector({});
EXPECT_EQ(right, omath::opengl_engine::k_abs_right);
}
TEST(UnitTestOpenGL, UpVector)
{
const auto up = omath::opengl_engine::UpVector({});
EXPECT_EQ(up, omath::opengl_engine::kAbsUp);
const auto up = omath::opengl_engine::up_vector({});
EXPECT_EQ(up, omath::opengl_engine::k_abs_up);
}
TEST(UnitTestOpenGL, ForwardVectorRotationYaw)
{
omath::opengl_engine::ViewAngles angles;
angles.yaw = omath::opengl_engine::YawAngle::FromDegrees(90.f);
angles.yaw = omath::opengl_engine::YawAngle::from_degrees(90.f);
const auto forward = omath::opengl_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::opengl_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_right.z, 0.00001f);
}
@@ -43,35 +43,35 @@ TEST(UnitTestOpenGL, ForwardVectorRotationPitch)
{
omath::opengl_engine::ViewAngles angles;
angles.pitch = omath::opengl_engine::PitchAngle::FromDegrees(-90.f);
angles.pitch = omath::opengl_engine::PitchAngle::from_degrees(-90.f);
const auto forward = omath::opengl_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsUp.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsUp.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsUp.z, 0.00001f);
const auto forward = omath::opengl_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::k_abs_up.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::k_abs_up.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_up.z, 0.00001f);
}
TEST(UnitTestOpenGL, ForwardVectorRotationRoll)
{
omath::opengl_engine::ViewAngles angles;
angles.roll = omath::opengl_engine::RollAngle::FromDegrees(-90.f);
angles.roll = omath::opengl_engine::RollAngle::from_degrees(-90.f);
const auto forward = omath::opengl_engine::UpVector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::opengl_engine::up_vector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
const auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
for (float distance = -10.f; distance > -1000.f; distance -= 0.01f)
{
const auto projected = cam.WorldToScreen({0, 0, distance});
const auto projected = cam.world_to_screen({0, 0, distance});
EXPECT_TRUE(projected.has_value());
@@ -85,21 +85,21 @@ TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
TEST(UnitTestOpenGL, CameraSetAndGetFov)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}
TEST(UnitTestOpenGL, CameraSetAndGetOrigin)
{
auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}

64
tests/engines/unit_test_source_engine.cpp
View File

@@ -9,69 +9,69 @@
TEST(UnitTestSourceEngine, ForwardVector)
{
const auto forward = omath::source_engine::ForwardVector({});
const auto forward = omath::source_engine::forward_vector({});
EXPECT_EQ(forward, omath::source_engine::kAbsForward);
EXPECT_EQ(forward, omath::source_engine::k_abs_forward);
}
TEST(UnitTestSourceEngine, RightVector)
{
const auto right = omath::source_engine::RightVector({});
const auto right = omath::source_engine::right_vector({});
EXPECT_EQ(right, omath::source_engine::kAbsRight);
EXPECT_EQ(right, omath::source_engine::k_abs_right);
}
TEST(UnitTestSourceEngine, UpVector)
{
const auto up = omath::source_engine::UpVector({});
EXPECT_EQ(up, omath::source_engine::kAbsUp);
const auto up = omath::source_engine::up_vector({});
EXPECT_EQ(up, omath::source_engine::k_abs_up);
}
TEST(UnitTestSourceEngine, ForwardVectorRotationYaw)
{
omath::source_engine::ViewAngles angles;
angles.yaw = omath::source_engine::YawAngle::FromDegrees(-90.f);
angles.yaw = omath::source_engine::YawAngle::from_degrees(-90.f);
const auto forward = omath::source_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::source_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::source_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::source_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::source_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::source_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestSourceEngine, ForwardVectorRotationPitch)
{
omath::source_engine::ViewAngles angles;
angles.pitch = omath::source_engine::PitchAngle::FromDegrees(-89.f);
angles.pitch = omath::source_engine::PitchAngle::from_degrees(-89.f);
const auto forward = omath::source_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::kAbsUp.x, 0.02f);
EXPECT_NEAR(forward.y, omath::source_engine::kAbsUp.y, 0.01f);
EXPECT_NEAR(forward.z, omath::source_engine::kAbsUp.z, 0.01f);
const auto forward = omath::source_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::k_abs_up.x, 0.02f);
EXPECT_NEAR(forward.y, omath::source_engine::k_abs_up.y, 0.01f);
EXPECT_NEAR(forward.z, omath::source_engine::k_abs_up.z, 0.01f);
}
TEST(UnitTestSourceEngine, ForwardVectorRotationRoll)
{
omath::source_engine::ViewAngles angles;
angles.roll = omath::source_engine::RollAngle::FromDegrees(90.f);
angles.roll = omath::source_engine::RollAngle::from_degrees(90.f);
const auto forward = omath::source_engine::UpVector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::source_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::source_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::source_engine::up_vector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::source_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::source_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
for (float distance = 0.02f; distance < 1000.f; distance += 0.01f)
{
const auto projected = cam.WorldToScreen({distance, 0, 0});
const auto projected = cam.world_to_screen({distance, 0, 0});
EXPECT_TRUE(projected.has_value());
@@ -85,13 +85,13 @@ TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
TEST(UnitTestSourceEngine, ProjectTargetMovedUp)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
auto prev = 1080.f;
for (float distance = 0.0f; distance < 10.f; distance += 1.f)
{
const auto projected = cam.WorldToScreen({100.f, 0, distance});
const auto projected = cam.world_to_screen({100.f, 0, distance});
EXPECT_TRUE(projected.has_value());
if (!projected.has_value())
@@ -105,21 +105,21 @@ TEST(UnitTestSourceEngine, ProjectTargetMovedUp)
TEST(UnitTestSourceEngine, CameraSetAndGetFov)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}
TEST(UnitTestSourceEngine, CameraSetAndGetOrigin)
{
auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}

64
tests/engines/unit_test_unity_engine.cpp
View File

@@ -9,69 +9,69 @@
TEST(UnitTestUnityEngine, ForwardVector)
{
const auto forward = omath::unity_engine::ForwardVector({});
const auto forward = omath::unity_engine::forward_vector({});
EXPECT_EQ(forward, omath::unity_engine::kAbsForward);
EXPECT_EQ(forward, omath::unity_engine::k_abs_forward);
}
TEST(UnitTestUnityEngine, ForwardVectorRotationYaw)
{
omath::unity_engine::ViewAngles angles;
angles.yaw = omath::unity_engine::YawAngle::FromDegrees(90.f);
angles.yaw = omath::unity_engine::YawAngle::from_degrees(90.f);
const auto forward = omath::unity_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::unity_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestUnityEngine, ForwardVectorRotationPitch)
{
omath::unity_engine::ViewAngles angles;
angles.pitch = omath::unity_engine::PitchAngle::FromDegrees(-90.f);
angles.pitch = omath::unity_engine::PitchAngle::from_degrees(-90.f);
const auto forward = omath::unity_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::kAbsUp.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::kAbsUp.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::kAbsUp.z, 0.00001f);
const auto forward = omath::unity_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::k_abs_up.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::k_abs_up.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_up.z, 0.00001f);
}
TEST(UnitTestUnityEngine, ForwardVectorRotationRoll)
{
omath::unity_engine::ViewAngles angles;
angles.roll = omath::unity_engine::RollAngle::FromDegrees(-90.f);
angles.roll = omath::unity_engine::RollAngle::from_degrees(-90.f);
const auto forward = omath::unity_engine::UpVector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::unity_engine::up_vector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestUnityEngine, RightVector)
{
const auto right = omath::unity_engine::RightVector({});
const auto right = omath::unity_engine::right_vector({});
EXPECT_EQ(right, omath::unity_engine::kAbsRight);
EXPECT_EQ(right, omath::unity_engine::k_abs_right);
}
TEST(UnitTestUnityEngine, UpVector)
{
const auto up = omath::unity_engine::UpVector({});
EXPECT_EQ(up, omath::unity_engine::kAbsUp);
const auto up = omath::unity_engine::up_vector({});
EXPECT_EQ(up, omath::unity_engine::k_abs_up);
}
TEST(UnitTestUnityEngine, ProjectTargetMovedFromCamera)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(60.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.01f, 1000.f);
for (float distance = 0.02f; distance < 100.f; distance += 0.01f)
{
const auto projected = cam.WorldToScreen({0, 0, distance});
const auto projected = cam.world_to_screen({0, 0, distance});
EXPECT_TRUE(projected.has_value());
@@ -84,30 +84,30 @@ TEST(UnitTestUnityEngine, ProjectTargetMovedFromCamera)
}
TEST(UnitTestUnityEngine, Project)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(60.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
const auto proj = cam.WorldToScreen({5.f, 3, 10.f});
const auto proj = cam.world_to_screen({5.f, 3, 10.f});
std::println("{} {}", proj->x, proj->y);
}
TEST(UnitTestUnityEngine, CameraSetAndGetFov)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}
TEST(UnitTestUnityEngine, CameraSetAndGetOrigin)
{
auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}

13
tests/general/unit_test_a_star.cpp
View File

@@ -4,14 +4,13 @@
#include <gtest/gtest.h>
#include <omath/pathfinding/a_star.hpp>
TEST(UnitTestAstar, FindingRightPath)
TEST(unit_test_a_star, finding_right_path)
{
omath::pathfinding::NavigationMesh mesh;
mesh.m_verTextMap[{0.f, 0.f, 0.f}] = {{0.f, 1.f, 0.f}};
mesh.m_verTextMap[{0.f, 1.f, 0.f}] = {{0.f, 2.f, 0.f}};
mesh.m_verTextMap[{0.f, 2.f, 0.f}] = {{0.f, 3.f, 0.f}};
mesh.m_verTextMap[{0.f, 3.f, 0.f}] = {};
std::ignore = omath::pathfinding::Astar::FindPath({}, {0.f, 3.f, 0.f}, mesh);
mesh.m_vertex_map[{0.f, 0.f, 0.f}] = {{0.f, 1.f, 0.f}};
mesh.m_vertex_map[{0.f, 1.f, 0.f}] = {{0.f, 2.f, 0.f}};
mesh.m_vertex_map[{0.f, 2.f, 0.f}] = {{0.f, 3.f, 0.f}};
mesh.m_vertex_map[{0.f, 3.f, 0.f}] = {};
std::ignore = omath::pathfinding::Astar::find_path({}, {0.f, 3.f, 0.f}, mesh);
}

24
tests/general/unit_test_angles.cpp
View File

@@ -4,46 +4,46 @@
#include <gtest/gtest.h>
#include <omath/angles.hpp>
TEST(UnitTestAngles, RadiansToDeg)
TEST(unit_test_angles, radians_to_deg)
{
constexpr float rad = 67;
EXPECT_NEAR(omath::angles::RadiansToDegrees(rad), 3838.82f, 0.01f);
EXPECT_NEAR(omath::angles::radians_to_degrees(rad), 3838.82f, 0.01f);
}
TEST(UnitTestAngles, DegreesToRadians)
TEST(unit_test_angles, degrees_to_radians)
{
constexpr float degree = 90;
EXPECT_NEAR(omath::angles::DegreesToRadians(degree), 1.5708f, 0.01f);
EXPECT_NEAR(omath::angles::degrees_to_radians(degree), 1.5708f, 0.01f);
}
TEST(UnitTestAngles, HorizontalFovToVerical)
TEST(unit_test_angles, horizontal_fov_to_verical)
{
constexpr float hFov = 90;
constexpr float aspectRation = 16.0f / 9.0f;
const auto verticalFov = omath::angles::HorizontalFovToVertical(hFov, aspectRation);
const auto verticalFov = omath::angles::horizontal_fov_to_vertical(hFov, aspectRation);
EXPECT_NEAR(verticalFov, 58.71f, 0.01f);
}
TEST(UnitTestAngles, VerticalToHorizontal)
TEST(unit_test_angles, vertical_to_horizontal)
{
constexpr float vFov = 58.71;
constexpr float aspectRation = 16.0f / 9.0f;
const auto horizontalFov = omath::angles::VerticalFovToHorizontal(vFov, aspectRation);
const auto horizontalFov = omath::angles::vertical_fov_to_horizontal(vFov, aspectRation);
EXPECT_NEAR(horizontalFov, 89.99f, 0.01f);
}
TEST(UnitTestAngles, WrapAngle)
TEST(unit_test_angles, wrap_angle)
{
const float wrapped = omath::angles::WrapAngle(361.f, 0.f, 360.f);
const float wrapped = omath::angles::wrap_angle(361.f, 0.f, 360.f);
EXPECT_NEAR(wrapped, 1.f, 0.01f);
}
TEST(UnitTestAngles, WrapAngleNegativeRange)
TEST(unit_test_angles, wrap_angle_negative_range)
{
const float wrapped = omath::angles::WrapAngle(-90.f, 0.f, 360.f);
const float wrapped = omath::angles::wrap_angle(-90.f, 0.f, 360.f);
EXPECT_NEAR(wrapped, 270.f, 0.01f);
}

20
tests/general/unit_test_color.cpp
View File

@@ -15,8 +15,8 @@ protected:
void SetUp() override
{
color1 = Color::Red();
color2 = Color::Green();
color1 = Color::red();
color2 = Color::green();
}
};
@@ -43,7 +43,7 @@ TEST_F(UnitTestColor, Constructor_Vector4)
// Test static methods for color creation
TEST_F(UnitTestColor, FromRGBA)
{
constexpr Color color = Color::FromRGBA(128, 64, 32, 255);
constexpr Color color = Color::from_rgba(128, 64, 32, 255);
EXPECT_FLOAT_EQ(color.x, 128.0f / 255.0f);
EXPECT_FLOAT_EQ(color.y, 64.0f / 255.0f);
EXPECT_FLOAT_EQ(color.z, 32.0f / 255.0f);
@@ -52,7 +52,7 @@ TEST_F(UnitTestColor, FromRGBA)
TEST_F(UnitTestColor, FromHSV)
{
constexpr Color color = Color::FromHSV(0.0f, 1.0f, 1.0f); // Red in HSV
constexpr Color color = Color::from_hsv(0.0f, 1.0f, 1.0f); // Red in HSV
EXPECT_FLOAT_EQ(color.x, 1.0f);
EXPECT_FLOAT_EQ(color.y, 0.0f);
EXPECT_FLOAT_EQ(color.z, 0.0f);
@@ -62,7 +62,7 @@ TEST_F(UnitTestColor, FromHSV)
// Test HSV conversion
TEST_F(UnitTestColor, ToHSV)
{
HSV hsv = color1.ToHSV(); // Red color
Hsv hsv = color1.to_hsv(); // Red color
EXPECT_FLOAT_EQ(hsv.hue, 0.0f);
EXPECT_FLOAT_EQ(hsv.saturation, 1.0f);
EXPECT_FLOAT_EQ(hsv.value, 1.0f);
@@ -71,7 +71,7 @@ TEST_F(UnitTestColor, ToHSV)
// Test color blending
TEST_F(UnitTestColor, Blend)
{
Color blended = color1.Blend(color2, 0.5f);
Color blended = color1.blend(color2, 0.5f);
EXPECT_FLOAT_EQ(blended.x, 0.5f);
EXPECT_FLOAT_EQ(blended.y, 0.5f);
EXPECT_FLOAT_EQ(blended.z, 0.0f);
@@ -81,9 +81,9 @@ TEST_F(UnitTestColor, Blend)
// Test predefined colors
TEST_F(UnitTestColor, PredefinedColors)
{
constexpr Color red = Color::Red();
constexpr Color green = Color::Green();
constexpr Color blue = Color::Blue();
constexpr Color red = Color::red();
constexpr Color green = Color::green();
constexpr Color blue = Color::blue();
EXPECT_FLOAT_EQ(red.x, 1.0f);
EXPECT_FLOAT_EQ(red.y, 0.0f);
@@ -106,7 +106,7 @@ TEST_F(UnitTestColor, BlendVector3)
{
constexpr Color v1(1.0f, 0.0f, 0.0f, 1.f); // Red
constexpr Color v2(0.0f, 1.0f, 0.0f, 1.f); // Green
constexpr Color blended = v1.Blend(v2, 0.5f);
constexpr Color blended = v1.blend(v2, 0.5f);
EXPECT_FLOAT_EQ(blended.x, 0.5f);
EXPECT_FLOAT_EQ(blended.y, 0.5f);
EXPECT_FLOAT_EQ(blended.z, 0.0f);

11
tests/general/unit_test_line_trace.cpp
View File

@@ -59,7 +59,7 @@ namespace
TEST_P(CanTraceLineParam, VariousRays)
{
const auto& p = GetParam();
EXPECT_EQ(LineTracer::CanTraceLine(p.ray, triangle), p.expected_clear);
EXPECT_EQ(LineTracer::can_trace_line(p.ray, triangle), p.expected_clear);
}
INSTANTIATE_TEST_SUITE_P(
@@ -84,7 +84,7 @@ namespace
constexpr Ray ray{{0.3f, 0.3f, -1.f}, {0.3f, 0.3f, 1.f}};
constexpr Vec3 expected{0.3f, 0.3f, 0.f};
const Vec3 hit = LineTracer::GetRayHitPoint(ray, triangle);
const Vec3 hit = LineTracer::get_ray_hit_point(ray, triangle);
ASSERT_FALSE(VecEqual(hit, ray.end));
EXPECT_TRUE(VecEqual(hit, expected));
}
@@ -99,7 +99,7 @@ namespace
{1001.f, 1000.f, 1000.f},
{1000.f, 1001.f, 1000.f}};
EXPECT_TRUE(LineTracer::CanTraceLine(short_ray, distant));
EXPECT_TRUE(LineTracer::can_trace_line(short_ray, distant));
}
TEST(LineTracerTraceRayEdge, CantHit)
@@ -108,14 +108,13 @@ namespace
constexpr Ray ray{{}, {1.0, 0, 0}, false};
EXPECT_TRUE(omath::collision::LineTracer::CanTraceLine(ray, triangle));
EXPECT_TRUE(omath::collision::LineTracer::can_trace_line(ray, triangle));
}
TEST(LineTracerTraceRayEdge, CanHit)
{
constexpr omath::Triangle<Vector3<float>> triangle{{2, 0, 0}, {2, 2, 0}, {2, 2, 2}};
constexpr Ray ray{{}, {2.1, 0, 0}, false};
auto endPoint = omath::collision::LineTracer::GetRayHitPoint(ray, triangle);
EXPECT_FALSE(omath::collision::LineTracer::CanTraceLine(ray, triangle));
EXPECT_FALSE(omath::collision::LineTracer::can_trace_line(ray, triangle));
}
} // namespace

132
tests/general/unit_test_mat.cpp
View File

@@ -22,22 +22,22 @@ protected:
TEST_F(UnitTestMat, Constructor_Default)
{
Mat<3, 3> m;
EXPECT_EQ(m.RowCount(), 3);
EXPECT_EQ(m.ColumnsCount(), 3);
EXPECT_EQ(m.row_count(), 3);
EXPECT_EQ(m.columns_count(), 3);
for (size_t i = 0; i < 3; ++i)
for (size_t j = 0; j < 3; ++j)
EXPECT_FLOAT_EQ(m.At(i, j), 0.0f);
EXPECT_FLOAT_EQ(m.at(i, j), 0.0f);
}
TEST_F(UnitTestMat, Constructor_InitializerList)
{
constexpr Mat<2, 2> m{{1.0f, 2.0f}, {3.0f, 4.0f}};
EXPECT_EQ(m.RowCount(), 2);
EXPECT_EQ(m.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m.At(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m.At(0, 1), 2.0f);
EXPECT_FLOAT_EQ(m.At(1, 0), 3.0f);
EXPECT_FLOAT_EQ(m.At(1, 1), 4.0f);
EXPECT_EQ(m.row_count(), 2);
EXPECT_EQ(m.columns_count(), 2);
EXPECT_FLOAT_EQ(m.at(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m.at(0, 1), 2.0f);
EXPECT_FLOAT_EQ(m.at(1, 0), 3.0f);
EXPECT_FLOAT_EQ(m.at(1, 1), 4.0f);
}
TEST_F(UnitTestMat, Operator_SquareBrackets)
@@ -51,19 +51,19 @@ TEST_F(UnitTestMat, Operator_SquareBrackets)
TEST_F(UnitTestMat, Constructor_Copy)
{
Mat<2, 2> m3 = m2;
EXPECT_EQ(m3.RowCount(), m2.RowCount());
EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
EXPECT_FLOAT_EQ(m3.At(1, 1), m2.At(1, 1));
EXPECT_EQ(m3.row_count(), m2.row_count());
EXPECT_EQ(m3.columns_count(), m2.columns_count());
EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
EXPECT_FLOAT_EQ(m3.at(1, 1), m2.at(1, 1));
}
TEST_F(UnitTestMat, Constructor_Move)
{
Mat<2, 2> m3 = std::move(m2);
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 4.0f);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 4.0f);
// m2 is in a valid but unspecified state after move
}
@@ -71,36 +71,36 @@ TEST_F(UnitTestMat, Constructor_Move)
TEST_F(UnitTestMat, Operator_Multiplication_Matrix)
{
Mat<2, 2> m3 = m2 * m2;
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 7.0f);
EXPECT_FLOAT_EQ(m3.At(0, 1), 10.0f);
EXPECT_FLOAT_EQ(m3.At(1, 0), 15.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 22.0f);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 7.0f);
EXPECT_FLOAT_EQ(m3.at(0, 1), 10.0f);
EXPECT_FLOAT_EQ(m3.at(1, 0), 15.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 22.0f);
}
TEST_F(UnitTestMat, Operator_Multiplication_Scalar)
{
Mat<2, 2> m3 = m2 * 2.0f;
EXPECT_FLOAT_EQ(m3.At(0, 0), 2.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 8.0f);
EXPECT_FLOAT_EQ(m3.at(0, 0), 2.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 8.0f);
}
TEST_F(UnitTestMat, Operator_Division_Scalar)
{
Mat<2, 2> m3 = m2 / 2.0f;
EXPECT_FLOAT_EQ(m3.At(0, 0), 0.5f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 2.0f);
EXPECT_FLOAT_EQ(m3.at(0, 0), 0.5f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 2.0f);
}
// Test matrix functions
TEST_F(UnitTestMat, Transpose)
{
Mat<2, 2> m3 = m2.Transposed();
EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
EXPECT_FLOAT_EQ(m3.At(0, 1), m2.At(1, 0));
EXPECT_FLOAT_EQ(m3.At(1, 0), m2.At(0, 1));
EXPECT_FLOAT_EQ(m3.At(1, 1), m2.At(1, 1));
EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
EXPECT_FLOAT_EQ(m3.at(0, 1), m2.at(1, 0));
EXPECT_FLOAT_EQ(m3.at(1, 0), m2.at(0, 1));
EXPECT_FLOAT_EQ(m3.at(1, 1), m2.at(1, 1));
}
TEST_F(UnitTestMat, Determinant)
@@ -111,21 +111,21 @@ TEST_F(UnitTestMat, Determinant)
TEST_F(UnitTestMat, Sum)
{
const float sum = m2.Sum();
const float sum = m2.sum();
EXPECT_FLOAT_EQ(sum, 10.0f);
}
TEST_F(UnitTestMat, Clear)
{
m2.Clear();
for (size_t i = 0; i < m2.RowCount(); ++i)
for (size_t j = 0; j < m2.ColumnsCount(); ++j)
EXPECT_FLOAT_EQ(m2.At(i, j), 0.0f);
m2.clear();
for (size_t i = 0; i < m2.row_count(); ++i)
for (size_t j = 0; j < m2.columns_count(); ++j)
EXPECT_FLOAT_EQ(m2.at(i, j), 0.0f);
}
TEST_F(UnitTestMat, ToString)
{
const std::string str = m2.ToString();
const std::string str = m2.to_string();
EXPECT_FALSE(str.empty());
EXPECT_EQ(str, "[[ 1.000, 2.000]\n [ 3.000, 4.000]]");
}
@@ -135,31 +135,31 @@ TEST_F(UnitTestMat, AssignmentOperator_Copy)
{
Mat<2, 2> m3;
m3 = m2;
EXPECT_EQ(m3.RowCount(), m2.RowCount());
EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
EXPECT_EQ(m3.row_count(), m2.row_count());
EXPECT_EQ(m3.columns_count(), m2.columns_count());
EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
}
TEST_F(UnitTestMat, AssignmentOperator_Move)
{
Mat<2, 2> m3;
m3 = std::move(m2);
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 4.0f);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 4.0f);
// m2 is in a valid but unspecified state after move
}
// Test static methods
TEST_F(UnitTestMat, StaticMethod_ToScreenMat)
{
Mat<4, 4> screenMat = Mat<4, 4>::ToScreenMat(800.0f, 600.0f);
EXPECT_FLOAT_EQ(screenMat.At(0, 0), 400.0f);
EXPECT_FLOAT_EQ(screenMat.At(1, 1), -300.0f);
EXPECT_FLOAT_EQ(screenMat.At(3, 0), 400.0f);
EXPECT_FLOAT_EQ(screenMat.At(3, 1), 300.0f);
EXPECT_FLOAT_EQ(screenMat.At(3, 3), 1.0f);
Mat<4, 4> screenMat = Mat<4, 4>::to_screen_mat(800.0f, 600.0f);
EXPECT_FLOAT_EQ(screenMat.at(0, 0), 400.0f);
EXPECT_FLOAT_EQ(screenMat.at(1, 1), -300.0f);
EXPECT_FLOAT_EQ(screenMat.at(3, 0), 400.0f);
EXPECT_FLOAT_EQ(screenMat.at(3, 1), 300.0f);
EXPECT_FLOAT_EQ(screenMat.at(3, 3), 1.0f);
}
@@ -183,13 +183,13 @@ TEST(UnitTestMatStandalone, Determinant_3x3)
TEST(UnitTestMatStandalone, Strip_3x3)
{
constexpr Mat<3, 3> m{{3, 0, 2}, {2, 0, -2}, {0, 1, 1}};
auto minor = m.Strip(0, 0);
EXPECT_EQ(minor.RowCount(), 2);
EXPECT_EQ(minor.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(minor.At(0, 0), 0.0f);
EXPECT_FLOAT_EQ(minor.At(0, 1), -2.0f);
EXPECT_FLOAT_EQ(minor.At(1, 0), 1.0f);
EXPECT_FLOAT_EQ(minor.At(1, 1), 1.0f);
auto minor = m.strip(0, 0);
EXPECT_EQ(minor.row_count(), 2);
EXPECT_EQ(minor.columns_count(), 2);
EXPECT_FLOAT_EQ(minor.at(0, 0), 0.0f);
EXPECT_FLOAT_EQ(minor.at(0, 1), -2.0f);
EXPECT_FLOAT_EQ(minor.at(1, 0), 1.0f);
EXPECT_FLOAT_EQ(minor.at(1, 1), 1.0f);
}
// Test Transpose for non-square matrix
@@ -197,14 +197,14 @@ TEST(UnitTestMatStandalone, Transpose_NonSquare)
{
constexpr Mat<2, 3> m{{1.0f, 2.0f, 3.0f}, {4.0f, 5.0f, 6.0f}};
auto transposed = m.Transposed();
EXPECT_EQ(transposed.RowCount(), 3);
EXPECT_EQ(transposed.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(transposed.At(0, 0), 1.0f);
EXPECT_FLOAT_EQ(transposed.At(1, 0), 2.0f);
EXPECT_FLOAT_EQ(transposed.At(2, 0), 3.0f);
EXPECT_FLOAT_EQ(transposed.At(0, 1), 4.0f);
EXPECT_FLOAT_EQ(transposed.At(1, 1), 5.0f);
EXPECT_FLOAT_EQ(transposed.At(2, 1), 6.0f);
EXPECT_EQ(transposed.row_count(), 3);
EXPECT_EQ(transposed.columns_count(), 2);
EXPECT_FLOAT_EQ(transposed.at(0, 0), 1.0f);
EXPECT_FLOAT_EQ(transposed.at(1, 0), 2.0f);
EXPECT_FLOAT_EQ(transposed.at(2, 0), 3.0f);
EXPECT_FLOAT_EQ(transposed.at(0, 1), 4.0f);
EXPECT_FLOAT_EQ(transposed.at(1, 1), 5.0f);
EXPECT_FLOAT_EQ(transposed.at(2, 1), 6.0f);
}
TEST(UnitTestMatStandalone, Enverse)
@@ -212,5 +212,5 @@ TEST(UnitTestMatStandalone, Enverse)
constexpr Mat<2, 2> m{{1.0f, 3.0f}, {2.0f, 5.0f}};
constexpr Mat<2,2> mv{{-5.0f, 3.0f}, {2.0f, -1.0f}};
EXPECT_EQ(mv, m.Inverted());
EXPECT_EQ(mv, m.inverted());
}

102
tests/general/unit_test_matrix.cpp
View File

@@ -25,8 +25,8 @@ protected:
TEST_F(UnitTestMatrix, Constructor_Size)
{
const Matrix m(3, 3);
EXPECT_EQ(m.RowCount(), 3);
EXPECT_EQ(m.ColumnsCount(), 3);
EXPECT_EQ(m.row_count(), 3);
EXPECT_EQ(m.columns_count(), 3);
}
TEST_F(UnitTestMatrix, Operator_SquareBrackets)
@@ -41,120 +41,120 @@ TEST_F(UnitTestMatrix, Operator_SquareBrackets)
TEST_F(UnitTestMatrix, Constructor_InitializerList)
{
Matrix m{{1.0f, 2.0f}, {3.0f, 4.0f}};
EXPECT_EQ(m.RowCount(), 2);
EXPECT_EQ(m.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m.At(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m.At(1, 1), 4.0f);
EXPECT_EQ(m.row_count(), 2);
EXPECT_EQ(m.columns_count(), 2);
EXPECT_FLOAT_EQ(m.at(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m.at(1, 1), 4.0f);
}
TEST_F(UnitTestMatrix, Constructor_Copy)
{
Matrix m3 = m2;
EXPECT_EQ(m3.RowCount(), m2.RowCount());
EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
EXPECT_EQ(m3.row_count(), m2.row_count());
EXPECT_EQ(m3.columns_count(), m2.columns_count());
EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
}
TEST_F(UnitTestMatrix, Constructor_Move)
{
Matrix m3 = std::move(m2);
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
EXPECT_EQ(m2.RowCount(), 0); // m2 should be empty after the move
EXPECT_EQ(m2.ColumnsCount(), 0);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
EXPECT_EQ(m2.row_count(), 0); // m2 should be empty after the move
EXPECT_EQ(m2.columns_count(), 0);
}
// Test matrix operations
TEST_F(UnitTestMatrix, Operator_Multiplication_Matrix)
{
Matrix m3 = m2 * m2;
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 7.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 22.0f);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 7.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 22.0f);
}
TEST_F(UnitTestMatrix, Operator_Multiplication_Scalar)
{
Matrix m3 = m2 * 2.0f;
EXPECT_FLOAT_EQ(m3.At(0, 0), 2.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 8.0f);
EXPECT_FLOAT_EQ(m3.at(0, 0), 2.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 8.0f);
}
TEST_F(UnitTestMatrix, Operator_Division_Scalar)
{
Matrix m3 = m2 / 2.0f;
EXPECT_FLOAT_EQ(m3.At(0, 0), 0.5f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 2.0f);
EXPECT_FLOAT_EQ(m3.at(0, 0), 0.5f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 2.0f);
}
// Test matrix functions
TEST_F(UnitTestMatrix, Transpose)
{
Matrix m3 = m2.Transpose();
EXPECT_FLOAT_EQ(m3.At(0, 1), 3.0f);
EXPECT_FLOAT_EQ(m3.At(1, 0), 2.0f);
Matrix m3 = m2.transpose();
EXPECT_FLOAT_EQ(m3.at(0, 1), 3.0f);
EXPECT_FLOAT_EQ(m3.at(1, 0), 2.0f);
}
TEST_F(UnitTestMatrix, Determinant)
{
const float det = m2.Determinant();
const float det = m2.determinant();
EXPECT_FLOAT_EQ(det, -2.0f);
}
TEST_F(UnitTestMatrix, Minor)
{
const float minor = m2.Minor(0, 0);
const float minor = m2.minor(0, 0);
EXPECT_FLOAT_EQ(minor, 4.0f);
}
TEST_F(UnitTestMatrix, AlgComplement)
{
const float algComp = m2.AlgComplement(0, 0);
const float algComp = m2.alg_complement(0, 0);
EXPECT_FLOAT_EQ(algComp, 4.0f);
}
TEST_F(UnitTestMatrix, Strip)
{
Matrix m3 = m2.Strip(0, 0);
EXPECT_EQ(m3.RowCount(), 1);
EXPECT_EQ(m3.ColumnsCount(), 1);
EXPECT_FLOAT_EQ(m3.At(0, 0), 4.0f);
Matrix m3 = m2.strip(0, 0);
EXPECT_EQ(m3.row_count(), 1);
EXPECT_EQ(m3.columns_count(), 1);
EXPECT_FLOAT_EQ(m3.at(0, 0), 4.0f);
}
TEST_F(UnitTestMatrix, ProjectionMatrix)
{
const Matrix proj = Matrix::ProjectionMatrix(45.0f, 1.33f, 0.1f, 100.0f);
EXPECT_EQ(proj.RowCount(), 4);
EXPECT_EQ(proj.ColumnsCount(), 4);
const Matrix proj = Matrix::projection_matrix(45.0f, 1.33f, 0.1f, 100.0f);
EXPECT_EQ(proj.row_count(), 4);
EXPECT_EQ(proj.columns_count(), 4);
// Further checks on projection matrix elements could be added
}
// Test other member functions
TEST_F(UnitTestMatrix, Set)
{
m1.Set(3.0f);
EXPECT_FLOAT_EQ(m1.At(0, 0), 3.0f);
EXPECT_FLOAT_EQ(m1.At(1, 1), 3.0f);
m1.set(3.0f);
EXPECT_FLOAT_EQ(m1.at(0, 0), 3.0f);
EXPECT_FLOAT_EQ(m1.at(1, 1), 3.0f);
}
TEST_F(UnitTestMatrix, Sum)
{
const float sum = m2.Sum();
const float sum = m2.sum();
EXPECT_FLOAT_EQ(sum, 10.0f);
}
TEST_F(UnitTestMatrix, Clear)
{
m2.Clear();
EXPECT_FLOAT_EQ(m2.At(0, 0), 0.0f);
EXPECT_FLOAT_EQ(m2.At(1, 1), 0.0f);
m2.clear();
EXPECT_FLOAT_EQ(m2.at(0, 0), 0.0f);
EXPECT_FLOAT_EQ(m2.at(1, 1), 0.0f);
}
TEST_F(UnitTestMatrix, ToString)
{
const std::string str = m2.ToString();
const std::string str = m2.to_string();
EXPECT_FALSE(str.empty());
}
@@ -163,18 +163,18 @@ TEST_F(UnitTestMatrix, AssignmentOperator_Copy)
{
Matrix m3(2, 2);
m3 = m2;
EXPECT_EQ(m3.RowCount(), m2.RowCount());
EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
EXPECT_EQ(m3.row_count(), m2.row_count());
EXPECT_EQ(m3.columns_count(), m2.columns_count());
EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
}
TEST_F(UnitTestMatrix, AssignmentOperator_Move)
{
Matrix m3(2, 2);
m3 = std::move(m2);
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
EXPECT_EQ(m2.RowCount(), 0); // m2 should be empty after the move
EXPECT_EQ(m2.ColumnsCount(), 0);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
EXPECT_EQ(m2.row_count(), 0); // m2 should be empty after the move
EXPECT_EQ(m2.columns_count(), 0);
}

8
tests/general/unit_test_prediction.cpp
View File

@@ -4,13 +4,13 @@
TEST(UnitTestPrediction, PredictionTest)
{
constexpr omath::projectile_prediction::Target target{
.m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_isAirborne = false};
.m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
constexpr omath::projectile_prediction::Projectile proj = {
.m_origin = {3, 2, 1}, .m_launchSpeed = 5000, .m_gravityScale = 0.4};
.m_origin = {3, 2, 1}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
const auto viewPoint =
omath::projectile_prediction::ProjPredEngineLegacy(400, 1.f / 1000.f, 50, 5.f).MaybeCalculateAimPoint(proj, target);
omath::projectile_prediction::ProjPredEngineLegacy(400, 1.f / 1000.f, 50, 5.f).maybe_calculate_aim_point(proj, target);
const auto [pitch, yaw, _] = proj.m_origin.ViewAngleTo(viewPoint.value()).AsTuple();
const auto [pitch, yaw, _] = proj.m_origin.view_angle_to(viewPoint.value()).as_tuple();
EXPECT_NEAR(42.547142, pitch, 0.01f);
EXPECT_NEAR(-1.181189, yaw, 0.01f);

4
tests/general/unit_test_projection.cpp
View File

@@ -9,9 +9,9 @@
TEST(UnitTestProjection, Projection)
{
const auto x = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::FromDegrees(90.f);
const auto x = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::from_degrees(90.f);
auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, x, 0.01f, 1000.f);
const auto projected = cam.WorldToScreen({1000, 0, 50});
const auto projected = cam.world_to_screen({1000, 0, 50});
std::print("{} {} {}", projected->x, projected->y, projected->z);
}

26
tests/general/unit_test_triangle.cpp
View File

@@ -68,14 +68,14 @@ TEST_F(UnitTestTriangle, Constructor)
TEST_F(UnitTestTriangle, CalculateNormal)
{
// For t1, the normal should point in the +Z direction (0, 0, 1) or (0, 0, -1)
const Vector3 normal_t1 = t1.CalculateNormal();
const Vector3 normal_t1 = t1.calculate_normal();
// Check if it's normalized and pointed along Z (sign can differ, so use absolute check)
EXPECT_NEAR(std::fabs(normal_t1.z), 1.0f, 1e-5f);
EXPECT_NEAR(normal_t1.Length(), 1.0f, 1e-5f);
EXPECT_NEAR(normal_t1.length(), 1.0f, 1e-5f);
// For t3, we expect the normal to be along +Z as well
const Vector3 normal_t3 = t3.CalculateNormal();
const Vector3 normal_t3 = t3.calculate_normal();
EXPECT_NEAR(std::fabs(normal_t3.z), 1.0f, 1e-5f);
}
@@ -83,29 +83,29 @@ TEST_F(UnitTestTriangle, CalculateNormal)
TEST_F(UnitTestTriangle, SideLengths)
{
// For t1 side lengths
EXPECT_FLOAT_EQ(t1.SideALength(), std::sqrt(1.0f)); // distance between (0,0,0) and (1,0,0)
EXPECT_FLOAT_EQ(t1.SideBLength(), std::sqrt(1.0f + 1.0f)); // distance between (4,5,6) & (7,8,9)... but we are testing t1, so let's be accurate:
EXPECT_FLOAT_EQ(t1.side_a_length(), std::sqrt(1.0f)); // distance between (0,0,0) and (1,0,0)
EXPECT_FLOAT_EQ(t1.side_b_length(), std::sqrt(1.0f + 1.0f)); // distance between (4,5,6) & (7,8,9)... but we are testing t1, so let's be accurate:
// Actually, for t1: vertex2=(1,0,0), vertex3=(0,1,0)
// Dist between (0,1,0) and (1,0,0) = sqrt((1-0)^2 + (0-1)^2) = sqrt(1 + 1) = sqrt(2)
EXPECT_FLOAT_EQ(t1.SideBLength(), std::sqrt(2.0f));
EXPECT_FLOAT_EQ(t1.side_b_length(), std::sqrt(2.0f));
// For t3, side a = distance between vertex1=(0,0,0) and vertex2=(2,0,0), which is 2
// side b = distance between vertex3=(0,2,0) and vertex2=(2,0,0), which is sqrt(2^2 + (-2)^2)= sqrt(8)= 2.828...
// We'll just check side a first:
EXPECT_FLOAT_EQ(t3.SideALength(), 2.0f);
EXPECT_FLOAT_EQ(t3.side_a_length(), 2.0f);
// Then side b:
EXPECT_FLOAT_EQ(t3.SideBLength(), std::sqrt(8.0f));
EXPECT_FLOAT_EQ(t3.side_b_length(), std::sqrt(8.0f));
}
// Test side vectors
TEST_F(UnitTestTriangle, SideVectors)
{
const Vector3 sideA_t1 = t1.SideAVector(); // m_vertex1 - m_vertex2
const Vector3 sideA_t1 = t1.side_a_vector(); // m_vertex1 - m_vertex2
EXPECT_FLOAT_EQ(sideA_t1.x, 0.0f - 1.0f);
EXPECT_FLOAT_EQ(sideA_t1.y, 0.0f - 0.0f);
EXPECT_FLOAT_EQ(sideA_t1.z, 0.0f - 0.0f);
const Vector3 sideB_t1 = t1.SideBVector(); // m_vertex3 - m_vertex2
const Vector3 sideB_t1 = t1.side_b_vector(); // m_vertex3 - m_vertex2
EXPECT_FLOAT_EQ(sideB_t1.x, 0.0f - 1.0f);
EXPECT_FLOAT_EQ(sideB_t1.y, 1.0f - 0.0f);
EXPECT_FLOAT_EQ(sideB_t1.z, 0.0f - 0.0f);
@@ -113,19 +113,19 @@ TEST_F(UnitTestTriangle, SideVectors)
TEST_F(UnitTestTriangle, IsRectangular)
{
EXPECT_TRUE(Triangle<Vector3<float>>({2,0,0}, {}, {0,2,0}).IsRectangular());
EXPECT_TRUE(Triangle<Vector3<float>>({2,0,0}, {}, {0,2,0}).is_rectangular());
}
// Test midpoint
TEST_F(UnitTestTriangle, MidPoint)
{
// For t1, midpoint of (0,0,0), (1,0,0), (0,1,0)
const Vector3 mid1 = t1.MidPoint();
const Vector3 mid1 = t1.mid_point();
EXPECT_FLOAT_EQ(mid1.x, (0.0f + 1.0f + 0.0f) / 3.0f);
EXPECT_FLOAT_EQ(mid1.y, (0.0f + 0.0f + 1.0f) / 3.0f);
EXPECT_FLOAT_EQ(mid1.z, 0.0f);
// For t2, midpoint of (1,2,3), (4,5,6), (7,8,9)
const Vector3 mid2 = t2.MidPoint();
const Vector3 mid2 = t2.mid_point();
EXPECT_FLOAT_EQ(mid2.x, (1.0f + 4.0f + 7.0f) / 3.0f);
EXPECT_FLOAT_EQ(mid2.y, (2.0f + 5.0f + 8.0f) / 3.0f);
EXPECT_FLOAT_EQ(mid2.z, (3.0f + 6.0f + 9.0f) / 3.0f);

46
tests/general/unit_test_vector2.cpp
View File

@@ -150,76 +150,76 @@ TEST_F(UnitTestVector2, SubtractionAssignmentOperator_Float)
// Test other member functions
TEST_F(UnitTestVector2, DistTo)
{
const float dist = v1.DistTo(v2);
const float dist = v1.distance_to(v2);
EXPECT_FLOAT_EQ(dist, std::sqrt(18.0f));
}
TEST_F(UnitTestVector2, DistTo_SamePoint)
{
const float dist = v1.DistTo(v1);
const float dist = v1.distance_to(v1);
EXPECT_FLOAT_EQ(dist, 0.0f);
}
TEST_F(UnitTestVector2, DistToSqr)
{
constexpr float distSqr = Vector2(1.0f, 2.0f).DistToSqr(Vector2(4.0f, 5.0f));
constexpr float distSqr = Vector2(1.0f, 2.0f).distance_to_sqr(Vector2(4.0f, 5.0f));
EXPECT_FLOAT_EQ(distSqr, 18.0f);
}
TEST_F(UnitTestVector2, DistToSqr_SamePoint)
{
constexpr float distSqr = Vector2(1.0f, 2.0f).DistToSqr(Vector2(1.0f, 2.0f));
constexpr float distSqr = Vector2(1.0f, 2.0f).distance_to_sqr(Vector2(1.0f, 2.0f));
EXPECT_FLOAT_EQ(distSqr, 0.0f);
}
TEST_F(UnitTestVector2, DotProduct)
{
constexpr float dot = Vector2(1.0f, 2.0f).Dot(Vector2(4.0f, 5.0f));
constexpr float dot = Vector2(1.0f, 2.0f).dot(Vector2(4.0f, 5.0f));
EXPECT_FLOAT_EQ(dot, 14.0f);
}
TEST_F(UnitTestVector2, DotProduct_PerpendicularVectors)
{
constexpr float dot = Vector2(1.0f, 0.0f).Dot(Vector2(0.0f, 1.0f));
constexpr float dot = Vector2(1.0f, 0.0f).dot(Vector2(0.0f, 1.0f));
EXPECT_FLOAT_EQ(dot, 0.0f);
}
TEST_F(UnitTestVector2, DotProduct_ParallelVectors)
{
constexpr float dot = Vector2(1.0f, 1.0f).Dot(Vector2(2.0f, 2.0f));
constexpr float dot = Vector2(1.0f, 1.0f).dot(Vector2(2.0f, 2.0f));
EXPECT_FLOAT_EQ(dot, 4.0f);
}
TEST_F(UnitTestVector2, Length)
{
const float length = v1.Length();
const float length = v1.length();
EXPECT_FLOAT_EQ(length, std::sqrt(5.0f));
}
TEST_F(UnitTestVector2, Length_ZeroVector)
{
constexpr Vector2 v_zero(0.0f, 0.0f);
const float length = v_zero.Length();
const float length = v_zero.length();
EXPECT_FLOAT_EQ(length, 0.0f);
}
TEST_F(UnitTestVector2, Length_LargeValues)
{
constexpr Vector2 v_large(FLT_MAX, FLT_MAX);
const float length = v_large.Length();
const float length = v_large.length();
EXPECT_TRUE(std::isinf(length));
}
TEST_F(UnitTestVector2, LengthSqr)
{
constexpr float lengthSqr = Vector2(1.0f, 2.0f).LengthSqr();
constexpr float lengthSqr = Vector2(1.0f, 2.0f).length_sqr();
EXPECT_FLOAT_EQ(lengthSqr, 5.0f);
}
TEST_F(UnitTestVector2, Abs)
{
Vector2 v3(-1.0f, -2.0f);
v3.Abs();
v3.abs();
EXPECT_FLOAT_EQ(v3.x, 1.0f);
EXPECT_FLOAT_EQ(v3.y, 2.0f);
}
@@ -227,7 +227,7 @@ TEST_F(UnitTestVector2, Abs)
TEST_F(UnitTestVector2, Abs_PositiveValues)
{
Vector2 v3(1.0f, 2.0f);
v3.Abs();
v3.abs();
EXPECT_FLOAT_EQ(v3.x, 1.0f);
EXPECT_FLOAT_EQ(v3.y, 2.0f);
}
@@ -235,26 +235,26 @@ TEST_F(UnitTestVector2, Abs_PositiveValues)
TEST_F(UnitTestVector2, Abs_ZeroValues)
{
Vector2 v3(0.0f, 0.0f);
v3.Abs();
v3.abs();
EXPECT_FLOAT_EQ(v3.x, 0.0f);
EXPECT_FLOAT_EQ(v3.y, 0.0f);
}
TEST_F(UnitTestVector2, Sum)
{
constexpr float sum = Vector2(1.0f, 2.0f).Sum();
constexpr float sum = Vector2(1.0f, 2.0f).sum();
EXPECT_FLOAT_EQ(sum, 3.0f);
}
TEST_F(UnitTestVector2, Sum_NegativeValues)
{
constexpr float sum = Vector2(-1.0f, -2.0f).Sum();
constexpr float sum = Vector2(-1.0f, -2.0f).sum();
EXPECT_FLOAT_EQ(sum, -3.0f);
}
TEST_F(UnitTestVector2, Normalized)
{
const Vector2 v3 = v1.Normalized();
const Vector2 v3 = v1.normalized();
EXPECT_NEAR(v3.x, 0.44721f, 0.0001f);
EXPECT_NEAR(v3.y, 0.89443f, 0.0001f);
}
@@ -262,7 +262,7 @@ TEST_F(UnitTestVector2, Normalized)
TEST_F(UnitTestVector2, Normalized_ZeroVector)
{
constexpr Vector2 v_zero(0.0f, 0.0f);
const Vector2 v_norm = v_zero.Normalized();
const Vector2 v_norm = v_zero.normalized();
EXPECT_FLOAT_EQ(v_norm.x, 0.0f);
EXPECT_FLOAT_EQ(v_norm.y, 0.0f);
}
@@ -270,7 +270,7 @@ TEST_F(UnitTestVector2, Normalized_ZeroVector)
// Test AsTuple method
TEST_F(UnitTestVector2, AsTuple)
{
const auto tuple = v1.AsTuple();
const auto tuple = v1.as_tuple();
EXPECT_FLOAT_EQ(std::get<0>(tuple), v1.x);
EXPECT_FLOAT_EQ(std::get<1>(tuple), v1.y);
}
@@ -347,7 +347,7 @@ TEST_F(UnitTestVector2, NegationOperator_ZeroVector)
}
// Static assertions (compile-time checks)
static_assert(Vector2(1.0f, 2.0f).LengthSqr() == 5.0f, "LengthSqr should be 5");
static_assert(Vector2(1.0f, 2.0f).Dot(Vector2(4.0f, 5.0f)) == 14.0f, "Dot product should be 14");
static_assert(Vector2(4.0f, 5.0f).DistToSqr(Vector2(1.0f, 2.0f)) == 18.0f, "DistToSqr should be 18");
static_assert(Vector2(-1.0f, -2.0f).Abs() == Vector2(1.0f, 2.0f), "Abs should convert negative values to positive");
static_assert(Vector2(1.0f, 2.0f).length_sqr() == 5.0f, "LengthSqr should be 5");
static_assert(Vector2(1.0f, 2.0f).dot(Vector2(4.0f, 5.0f)) == 14.0f, "Dot product should be 14");
static_assert(Vector2(4.0f, 5.0f).distance_to_sqr(Vector2(1.0f, 2.0f)) == 18.0f, "DistToSqr should be 18");
static_assert(Vector2(-1.0f, -2.0f).abs() == Vector2(1.0f, 2.0f), "Abs should convert negative values to positive");

54
tests/general/unit_test_vector3.cpp
View File

@@ -164,26 +164,26 @@ TEST_F(UnitTestVector3, NegationOperator)
// Test other member functions
TEST_F(UnitTestVector3, DistToSqr)
{
constexpr auto distSqr = Vector3(1.0f, 2.0f, 3.0f).DistToSqr(Vector3(4.0f, 5.0f, 6.0f));
constexpr auto distSqr = Vector3(1.0f, 2.0f, 3.0f).distance_to_sqr(Vector3(4.0f, 5.0f, 6.0f));
EXPECT_FLOAT_EQ(distSqr, 27.0f);
}
TEST_F(UnitTestVector3, DotProduct)
{
constexpr auto dot = Vector3(1.0f, 2.0f, 3.0f).Dot(Vector3(4.0f, 5.0f, 6.0f));
constexpr auto dot = Vector3(1.0f, 2.0f, 3.0f).dot(Vector3(4.0f, 5.0f, 6.0f));
EXPECT_FLOAT_EQ(dot, 32.0f);
}
TEST_F(UnitTestVector3, LengthSqr)
{
constexpr auto lengthSqr = Vector3(1.0f, 2.0f, 3.0f).LengthSqr();
constexpr auto lengthSqr = Vector3(1.0f, 2.0f, 3.0f).length_sqr();
EXPECT_FLOAT_EQ(lengthSqr, 14.0f);
}
TEST_F(UnitTestVector3, Abs)
{
auto v3 = Vector3(-1.0f, -2.0f, -3.0f);
v3.Abs();
v3.abs();
EXPECT_FLOAT_EQ(v3.x, 1.0f);
EXPECT_FLOAT_EQ(v3.y, 2.0f);
EXPECT_FLOAT_EQ(v3.z, 3.0f);
@@ -191,19 +191,19 @@ TEST_F(UnitTestVector3, Abs)
TEST_F(UnitTestVector3, Sum)
{
constexpr auto sum = Vector3(1.0f, 2.0f, 3.0f).Sum();
constexpr auto sum = Vector3(1.0f, 2.0f, 3.0f).sum();
EXPECT_FLOAT_EQ(sum, 6.0f);
}
TEST_F(UnitTestVector3, Sum2D)
{
constexpr auto sum2D = Vector3(1.0f, 2.0f, 3.0f).Sum2D();
constexpr auto sum2D = Vector3(1.0f, 2.0f, 3.0f).sum_2d();
EXPECT_FLOAT_EQ(sum2D, 3.0f);
}
TEST_F(UnitTestVector3, CrossProduct)
{
constexpr Vector3 v3 = Vector3(1.0f, 2.0f, 3.0f).Cross(Vector3(4.0f, 5.0f, 6.0f));
constexpr Vector3 v3 = Vector3(1.0f, 2.0f, 3.0f).cross(Vector3(4.0f, 5.0f, 6.0f));
EXPECT_FLOAT_EQ(v3.x, -3.0f);
EXPECT_FLOAT_EQ(v3.y, 6.0f);
EXPECT_FLOAT_EQ(v3.z, -3.0f);
@@ -298,41 +298,41 @@ TEST_F(UnitTestVector3, Division_WithNaN)
// Test Length, Length2D, and Normalized
TEST_F(UnitTestVector3, Length)
{
const float length = v1.Length();
const float length = v1.length();
EXPECT_FLOAT_EQ(length, std::sqrt(14.0f));
}
TEST_F(UnitTestVector3, Length_ZeroVector)
{
constexpr Vector3 v_zero(0.0f, 0.0f, 0.0f);
const float length = v_zero.Length();
const float length = v_zero.length();
EXPECT_FLOAT_EQ(length, 0.0f);
}
TEST_F(UnitTestVector3, Length_LargeValues)
{
constexpr Vector3 v_large(FLT_MAX, FLT_MAX, FLT_MAX);
const float length = v_large.Length();
const float length = v_large.length();
EXPECT_TRUE(std::isinf(length));
}
TEST_F(UnitTestVector3, Length2D)
{
const float length2D = v1.Length2D();
const float length2D = v1.length_2d();
EXPECT_FLOAT_EQ(length2D, std::sqrt(5.0f));
}
TEST_F(UnitTestVector3, Normalized)
{
const Vector3 v_norm = v1.Normalized();
const float length = v_norm.Length();
const Vector3 v_norm = v1.normalized();
const float length = v_norm.length();
EXPECT_NEAR(length, 1.0f, 0.0001f);
}
TEST_F(UnitTestVector3, Normalized_ZeroVector)
{
constexpr Vector3 v_zero(0.0f, 0.0f, 0.0f);
const Vector3 v_norm = v_zero.Normalized();
const Vector3 v_norm = v_zero.normalized();
EXPECT_FLOAT_EQ(v_norm.x, 0.0f);
EXPECT_FLOAT_EQ(v_norm.y, 0.0f);
EXPECT_FLOAT_EQ(v_norm.z, 0.0f);
@@ -343,7 +343,7 @@ TEST_F(UnitTestVector3, CrossProduct_ParallelVectors)
{
constexpr Vector3 v_a(1.0f, 2.0f, 3.0f);
constexpr Vector3 v_b = v_a * 2.0f; // Parallel to v_a
constexpr Vector3 cross = v_a.Cross(v_b);
constexpr Vector3 cross = v_a.cross(v_b);
EXPECT_FLOAT_EQ(cross.x, 0.0f);
EXPECT_FLOAT_EQ(cross.y, 0.0f);
EXPECT_FLOAT_EQ(cross.z, 0.0f);
@@ -353,7 +353,7 @@ TEST_F(UnitTestVector3, CrossProduct_OrthogonalVectors)
{
constexpr Vector3 v_a(1.0f, 0.0f, 0.0f);
constexpr Vector3 v_b(0.0f, 1.0f, 0.0f);
constexpr Vector3 cross = v_a.Cross(v_b);
constexpr Vector3 cross = v_a.cross(v_b);
EXPECT_FLOAT_EQ(cross.x, 0.0f);
EXPECT_FLOAT_EQ(cross.y, 0.0f);
EXPECT_FLOAT_EQ(cross.z, 1.0f);
@@ -381,7 +381,7 @@ TEST_F(UnitTestVector3, Subtraction_NegativeValues)
// Test AsTuple method
TEST_F(UnitTestVector3, AsTuple)
{
const auto tuple = v1.AsTuple();
const auto tuple = v1.as_tuple();
EXPECT_FLOAT_EQ(std::get<0>(tuple), v1.x);
EXPECT_FLOAT_EQ(std::get<1>(tuple), v1.y);
EXPECT_FLOAT_EQ(std::get<2>(tuple), v1.z);
@@ -390,20 +390,20 @@ TEST_F(UnitTestVector3, AsTuple)
// Test AsTuple method
TEST_F(UnitTestVector3, AngleBeatween)
{
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).AngleBetween({1, 0 ,0}).value().AsDegrees(), 90.0f);
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).AngleBetween({0.0f, 0.0f, 1.0f}).value().AsDegrees(), 0.0f);
EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).AngleBetween({0.0f, 0.0f, 1.0f}).has_value());
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).angle_between({1, 0 ,0}).value().as_degrees(), 90.0f);
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).angle_between({0.0f, 0.0f, 1.0f}).value().as_degrees(), 0.0f);
EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).angle_between({0.0f, 0.0f, 1.0f}).has_value());
}
TEST_F(UnitTestVector3, IsPerpendicular)
{
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).IsPerpendicular({1, 0 ,0}), true);
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).IsPerpendicular({0.0f, 0.0f, 1.0f}), false);
EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).IsPerpendicular({0.0f, 0.0f, 1.0f}));
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({1, 0 ,0}), true);
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({0.0f, 0.0f, 1.0f}), false);
EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).is_perpendicular({0.0f, 0.0f, 1.0f}));
}
// Static assertions (compile-time checks)
static_assert(Vector3(1.0f, 2.0f, 3.0f).LengthSqr() == 14.0f, "LengthSqr should be 14");
static_assert(Vector3(1.0f, 2.0f, 3.0f).Dot(Vector3(4.0f, 5.0f, 6.0f)) == 32.0f, "Dot product should be 32");
static_assert(Vector3(4.0f, 5.0f, 6.0f).DistToSqr(Vector3(1.0f, 2.0f, 3.0f)) == 27.0f, "DistToSqr should be 27");
static_assert(Vector3(-1.0f, -2.0f, -3.0f).Abs() == Vector3(1.0f, 2.0f, 3.0f), "Abs should convert negative values to positive");
static_assert(Vector3(1.0f, 2.0f, 3.0f).length_sqr() == 14.0f, "LengthSqr should be 14");
static_assert(Vector3(1.0f, 2.0f, 3.0f).dot(Vector3(4.0f, 5.0f, 6.0f)) == 32.0f, "Dot product should be 32");
static_assert(Vector3(4.0f, 5.0f, 6.0f).distance_to_sqr(Vector3(1.0f, 2.0f, 3.0f)) == 27.0f, "DistToSqr should be 27");
static_assert(Vector3(-1.0f, -2.0f, -3.0f).abs() == Vector3(1.0f, 2.0f, 3.0f), "Abs should convert negative values to positive");

10
tests/general/unit_test_vector4.cpp
View File

@@ -180,20 +180,20 @@ TEST_F(UnitTestVector4, NegationOperator)
// Test other member functions
TEST_F(UnitTestVector4, LengthSqr)
{
constexpr float lengthSqr = Vector4(1.0f, 2.0f, 3.0f, 4.0f).LengthSqr();
constexpr float lengthSqr = Vector4(1.0f, 2.0f, 3.0f, 4.0f).length_sqr();
EXPECT_FLOAT_EQ(lengthSqr, 30.0f);
}
TEST_F(UnitTestVector4, DotProduct)
{
constexpr float dot = Vector4(1.0f, 2.0f, 3.0f, 4.0f).Dot(Vector4(4.0f, 5.0f, 6.0f, 7.0f));
constexpr float dot = Vector4(1.0f, 2.0f, 3.0f, 4.0f).dot(Vector4(4.0f, 5.0f, 6.0f, 7.0f));
EXPECT_FLOAT_EQ(dot, 60.0f);
}
TEST_F(UnitTestVector4, Abs)
{
Vector4 v3 = Vector4(-1.0f, -2.0f, -3.0f, -4.0f);
v3.Abs();
v3.abs();
EXPECT_FLOAT_EQ(v3.x, 1.0f);
EXPECT_FLOAT_EQ(v3.y, 2.0f);
EXPECT_FLOAT_EQ(v3.z, 3.0f);
@@ -202,14 +202,14 @@ TEST_F(UnitTestVector4, Abs)
TEST_F(UnitTestVector4, Sum)
{
constexpr float sum = Vector4(1.0f, 2.0f, 3.0f, 4.0f).Sum();
constexpr float sum = Vector4(1.0f, 2.0f, 3.0f, 4.0f).sum();
EXPECT_FLOAT_EQ(sum, 10.0f);
}
TEST_F(UnitTestVector4, Clamp)
{
Vector4 v3 = Vector4(1.0f, 2.0f, 3.0f, 4.0f);
v3.Clamp(1.5f, 2.5f);
v3.clamp(1.5f, 2.5f);
EXPECT_FLOAT_EQ(v3.x, 1.5f);
EXPECT_FLOAT_EQ(v3.y, 2.0f);
EXPECT_FLOAT_EQ(v3.z, 2.5f);