diff --git a/include/omath/Matrix.h b/include/omath/Matrix.h index 1cb2633..a8d0028 100644 --- a/include/omath/Matrix.h +++ b/include/omath/Matrix.h @@ -11,6 +11,7 @@ namespace omath class Matrix final { public: + Matrix(); Matrix(size_t rows, size_t columns); Matrix(const std::initializer_list>& rows); @@ -99,8 +100,8 @@ namespace omath ~Matrix(); private: - size_t m_rows = 0; - size_t m_columns = 0; - std::unique_ptr m_data = nullptr; + size_t m_rows; + size_t m_columns; + std::unique_ptr m_data; }; } \ No newline at end of file diff --git a/include/omath/Vector4.h b/include/omath/Vector4.h index 18ca171..32fa324 100644 --- a/include/omath/Vector4.h +++ b/include/omath/Vector4.h @@ -13,7 +13,7 @@ namespace omath float w = 0.f; Vector4(const float x = 0.f, const float y = 0.f, const float z = 0.f, const float w = 0.f) : Vector3(x, y, z), w(w) {} - Vector4() = default; + Vector4(); [[nodiscard]] bool operator==(const Vector4& src) const; diff --git a/include/omath/color.h b/include/omath/color.h index 856833f..2a5f2ba 100644 --- a/include/omath/color.h +++ b/include/omath/color.h @@ -21,11 +21,11 @@ namespace omath::color [[nodiscard]] Vector3 Blend(const Vector3& first, const Vector3& second, float ratio); - class Color : public Vector4 + class Color final : public Vector4 { public: Color(float r, float g, float b, float a); - + explicit Color(); [[nodiscard]] static Color FromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a); diff --git a/source/Vector4.cpp b/source/Vector4.cpp index 526a9d1..43ee175 100644 --- a/source/Vector4.cpp +++ b/source/Vector4.cpp @@ -131,4 +131,11 @@ namespace omath { return x + y + z + w; } + + Vector4::Vector4() + { + x = 0.f; + y = 0.f; + z = 0.f; + } } diff --git a/source/color.cpp b/source/color.cpp index 880c431..cbe1995 100644 --- a/source/color.cpp +++ b/source/color.cpp @@ -95,4 +95,9 @@ namespace omath::color return hsvData; } + + Color::Color() : Vector4(0.f, 0.f, 0.f, 0.f) + { + + } } diff --git a/source/matrix.cpp b/source/matrix.cpp index cd98ee3..37a5742 100644 --- a/source/matrix.cpp +++ b/source/matrix.cpp @@ -83,6 +83,10 @@ namespace omath m_columns = other.m_columns; m_data = std::move(other.m_data); + other.m_rows = 0; + other.m_columns = 0; + + other.m_data = nullptr; } size_t Matrix::ColumnsCount() const noexcept @@ -196,6 +200,9 @@ namespace omath m_columns = other.m_columns; m_data = std::move(other.m_data); + other.m_rows = 0.f; + other.m_columns = 0.f; + return *this; } @@ -357,7 +364,7 @@ namespace omath }; } - const float * Matrix::Raw() const + const float* Matrix::Raw() const { return m_data.get(); } @@ -367,4 +374,11 @@ namespace omath for (size_t i = 0; i < m_columns*m_rows; ++i) At(i / m_rows, i % m_columns) = pRawMatrix[i]; } + + Matrix::Matrix() + { + m_columns = 0; + m_rows = 0; + m_data = nullptr; + } } \ No newline at end of file diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index f47be28..f2f2c9f 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -2,10 +2,15 @@ enable_testing() project(unit-tests) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}") -file(GLOB TEST_SRC_FILES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp) include(GoogleTest) -add_executable(unit-tests UnitTestPrediction.cpp UnitTestMatrix.cpp UnitTestAstar.cpp UnitTestProjection.cpp) +add_executable(unit-tests + UnitTestPrediction.cpp + UnitTestMatrix.cpp + UnitTestAstar.cpp + UnitTestProjection.cpp + UnitTestVector3.cpp + UnitTestColor.cpp) target_link_libraries(unit-tests PRIVATE gtest gtest_main omath) diff --git a/tests/UnitTestColor.cpp b/tests/UnitTestColor.cpp new file mode 100644 index 0000000..ffe828c --- /dev/null +++ b/tests/UnitTestColor.cpp @@ -0,0 +1,113 @@ +// +// Created by Vlad on 01.09.2024. +// +#include +#include + + +using namespace omath::color; + +class UnitTestColor : public ::testing::Test +{ +protected: + Color color1; + Color color2; + + void SetUp() override + { + color1 = Color::Red(); + color2 = Color::Green(); + } +}; + +// Test constructors +TEST_F(UnitTestColor, Constructor_Float) +{ + Color color(0.5f, 0.5f, 0.5f, 1.0f); + EXPECT_FLOAT_EQ(color.x, 0.5f); + EXPECT_FLOAT_EQ(color.y, 0.5f); + EXPECT_FLOAT_EQ(color.z, 0.5f); + EXPECT_FLOAT_EQ(color.w, 1.0f); +} + +TEST_F(UnitTestColor, Constructor_Vector4) +{ + omath::Vector4 vec(0.2f, 0.4f, 0.6f, 0.8f); + Color color(vec); + EXPECT_FLOAT_EQ(color.x, 0.2f); + EXPECT_FLOAT_EQ(color.y, 0.4f); + EXPECT_FLOAT_EQ(color.z, 0.6f); + EXPECT_FLOAT_EQ(color.w, 0.8f); +} + +// Test static methods for color creation +TEST_F(UnitTestColor, FromRGBA) +{ + Color color = Color::FromRGBA(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); + EXPECT_FLOAT_EQ(color.w, 1.0f); +} + +TEST_F(UnitTestColor, FromHSV) +{ + Color color = Color::FromHSV(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); + EXPECT_FLOAT_EQ(color.w, 1.0f); +} + +// Test HSV conversion +TEST_F(UnitTestColor, ToHSV) +{ + HSV hsv = color1.ToHSV(); // Red color + EXPECT_FLOAT_EQ(hsv.m_hue, 0.0f); + EXPECT_FLOAT_EQ(hsv.m_saturation, 1.0f); + EXPECT_FLOAT_EQ(hsv.m_value, 1.0f); +} + +// Test color blending +TEST_F(UnitTestColor, Blend) +{ + 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); + EXPECT_FLOAT_EQ(blended.w, 1.0f); +} + +// Test predefined colors +TEST_F(UnitTestColor, PredefinedColors) +{ + Color red = Color::Red(); + Color green = Color::Green(); + Color blue = Color::Blue(); + + EXPECT_FLOAT_EQ(red.x, 1.0f); + EXPECT_FLOAT_EQ(red.y, 0.0f); + EXPECT_FLOAT_EQ(red.z, 0.0f); + EXPECT_FLOAT_EQ(red.w, 1.0f); + + EXPECT_FLOAT_EQ(green.x, 0.0f); + EXPECT_FLOAT_EQ(green.y, 1.0f); + EXPECT_FLOAT_EQ(green.z, 0.0f); + EXPECT_FLOAT_EQ(green.w, 1.0f); + + EXPECT_FLOAT_EQ(blue.x, 0.0f); + EXPECT_FLOAT_EQ(blue.y, 0.0f); + EXPECT_FLOAT_EQ(blue.z, 1.0f); + EXPECT_FLOAT_EQ(blue.w, 1.0f); +} + +// Test non-member function: Blend for Vector3 +TEST_F(UnitTestColor, BlendVector3) +{ + omath::Vector3 v1(1.0f, 0.0f, 0.0f); // Red + omath::Vector3 v2(0.0f, 1.0f, 0.0f); // Green + omath::Vector3 blended = Blend(v1, v2, 0.5f); + EXPECT_FLOAT_EQ(blended.x, 0.5f); + EXPECT_FLOAT_EQ(blended.y, 0.5f); + EXPECT_FLOAT_EQ(blended.z, 0.0f); +} \ No newline at end of file diff --git a/tests/UnitTestMatrix.cpp b/tests/UnitTestMatrix.cpp index a86692f..c2f0840 100644 --- a/tests/UnitTestMatrix.cpp +++ b/tests/UnitTestMatrix.cpp @@ -3,15 +3,179 @@ // #include #include -#include +#include "omath/Vector3.h" + +using namespace omath; -TEST(UnitTestMatrix, ToString) +class UnitTestMatrix : public ::testing::Test { - omath::Matrix matrix(2, 2); - matrix.Set(1.1); - const auto str = matrix.ToSrtring(); +protected: + Matrix m1; + Matrix m2; - std::cout << str; + void SetUp() override { + m1 = Matrix(2, 2); + m2 = Matrix{{1.0f, 2.0f}, {3.0f, 4.0f}}; + } +}; +// Test constructors +TEST_F(UnitTestMatrix, Constructor_Size) +{ + Matrix m(3, 3); + EXPECT_EQ(m.RowCount(), 3); + EXPECT_EQ(m.ColumnsCount(), 3); +} + +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); +} + +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)); +} + +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); +} + +// 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); +} + +TEST_F(UnitTestMatrix, Operator_Multiplication_Vector3) +{ + Vector3 v(1.0f, 2.0f, 3.0f); + Matrix m3(3, 3, new float[9]{1, 0, 0, 0, 1, 0, 0, 0, 1}); + Matrix result = m3 * v; + + EXPECT_FLOAT_EQ(result.At(0, 0), 1.0f); + EXPECT_FLOAT_EQ(result.At(1, 0), 2.0f); + EXPECT_FLOAT_EQ(result.At(2, 0), 3.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); +} + +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); +} + +// 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); +} + +TEST_F(UnitTestMatrix, Determinant) +{ + float det = m2.Determinant(); + EXPECT_FLOAT_EQ(det, -2.0f); +} + +TEST_F(UnitTestMatrix, Minor) +{ + float minor = m2.Minor(0, 0); + EXPECT_FLOAT_EQ(minor, 4.0f); +} + +TEST_F(UnitTestMatrix, AlgComplement) +{ + float algComp = m2.AlgComplement(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); +} + +TEST_F(UnitTestMatrix, ProjectionMatrix) +{ + Matrix proj = Matrix::ProjectionMatrix(45.0f, 1.33f, 0.1f, 100.0f); + EXPECT_EQ(proj.RowCount(), 4); + EXPECT_EQ(proj.ColumnsCount(), 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); +} + +TEST_F(UnitTestMatrix, Sum) +{ + 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); +} + +TEST_F(UnitTestMatrix, ToString) +{ + std::string str = m2.ToSrtring(); + EXPECT_FALSE(str.empty()); +} + +// Test assignment operators +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)); +} + +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); } \ No newline at end of file diff --git a/tests/UnitTestProjection.cpp b/tests/UnitTestProjection.cpp index 2d92930..fc2c54d 100644 --- a/tests/UnitTestProjection.cpp +++ b/tests/UnitTestProjection.cpp @@ -12,7 +12,5 @@ TEST(UnitTestProjection, IsPointOnScreen) const omath::projection::Camera camera({0.f, 0.f, 0.f}, {0, 0.f, 0.f} , {1920.f, 1080.f}, 110.f, 0.1f, 500.f); const auto proj = camera.WorldToScreen({100, 0, 15}); - if (proj) - std::print("{} {}", proj->x, proj->y); EXPECT_TRUE(proj.has_value()); } \ No newline at end of file diff --git a/tests/UnitTestVector3.cpp b/tests/UnitTestVector3.cpp new file mode 100644 index 0000000..e55b786 --- /dev/null +++ b/tests/UnitTestVector3.cpp @@ -0,0 +1,263 @@ +// +// Created by Vlad on 01.09.2024. +// +#include +#include + +using namespace omath; + +class UnitTestVector3 : public ::testing::Test +{ +protected: + Vector3 v1; + Vector3 v2; + + void SetUp() override + { + v1 = Vector3(1.0f, 2.0f, 3.0f); + v2 = Vector3(4.0f, 5.0f, 6.0f); + } +}; + +// Test constructor and default values +TEST_F(UnitTestVector3, Constructor_Default) +{ + Vector3 v; + EXPECT_FLOAT_EQ(v.x, 0.0f); + EXPECT_FLOAT_EQ(v.y, 0.0f); + EXPECT_FLOAT_EQ(v.z, 0.0f); +} + +TEST_F(UnitTestVector3, Constructor_Values) +{ + Vector3 v(1.0f, 2.0f, 3.0f); + EXPECT_FLOAT_EQ(v.x, 1.0f); + EXPECT_FLOAT_EQ(v.y, 2.0f); + EXPECT_FLOAT_EQ(v.z, 3.0f); +} + +// Test equality operators +TEST_F(UnitTestVector3, EqualityOperator) +{ + Vector3 v3(1.0f, 2.0f, 3.0f); + EXPECT_TRUE(v1 == v3); + EXPECT_FALSE(v1 == v2); +} + +TEST_F(UnitTestVector3, InequalityOperator) +{ + Vector3 v3(1.0f, 2.0f, 3.0f); + EXPECT_FALSE(v1 != v3); + EXPECT_TRUE(v1 != v2); +} + +// Test arithmetic operators +TEST_F(UnitTestVector3, AdditionOperator) +{ + Vector3 v3 = v1 + v2; + EXPECT_FLOAT_EQ(v3.x, 5.0f); + EXPECT_FLOAT_EQ(v3.y, 7.0f); + EXPECT_FLOAT_EQ(v3.z, 9.0f); +} + +TEST_F(UnitTestVector3, SubtractionOperator) +{ + Vector3 v3 = v2 - v1; + EXPECT_FLOAT_EQ(v3.x, 3.0f); + EXPECT_FLOAT_EQ(v3.y, 3.0f); + EXPECT_FLOAT_EQ(v3.z, 3.0f); +} + +TEST_F(UnitTestVector3, MultiplicationOperator) +{ + Vector3 v3 = v1 * 2.0f; + EXPECT_FLOAT_EQ(v3.x, 2.0f); + EXPECT_FLOAT_EQ(v3.y, 4.0f); + EXPECT_FLOAT_EQ(v3.z, 6.0f); +} + +TEST_F(UnitTestVector3, MultiplicationWithVectorOperator) +{ + Vector3 v3 = v1 * v2; + EXPECT_FLOAT_EQ(v3.x, 4.0f); + EXPECT_FLOAT_EQ(v3.y, 10.0f); + EXPECT_FLOAT_EQ(v3.z, 18.0f); +} + +TEST_F(UnitTestVector3, DivisionOperator) +{ + Vector3 v3 = v2 / 2.0f; + EXPECT_FLOAT_EQ(v3.x, 2.0f); + EXPECT_FLOAT_EQ(v3.y, 2.5f); + EXPECT_FLOAT_EQ(v3.z, 3.0f); +} + +TEST_F(UnitTestVector3, DivisionWithVectorOperator) +{ + Vector3 v3 = v2 / v1; + EXPECT_FLOAT_EQ(v3.x, 4.0f); + EXPECT_FLOAT_EQ(v3.y, 2.5f); + EXPECT_FLOAT_EQ(v3.z, 2.0f); +} + +// Test compound assignment operators +TEST_F(UnitTestVector3, AdditionAssignmentOperator) +{ + v1 += v2; + EXPECT_FLOAT_EQ(v1.x, 5.0f); + EXPECT_FLOAT_EQ(v1.y, 7.0f); + EXPECT_FLOAT_EQ(v1.z, 9.0f); +} + +TEST_F(UnitTestVector3, SubtractionAssignmentOperator) +{ + v1 -= v2; + EXPECT_FLOAT_EQ(v1.x, -3.0f); + EXPECT_FLOAT_EQ(v1.y, -3.0f); + EXPECT_FLOAT_EQ(v1.z, -3.0f); +} + +TEST_F(UnitTestVector3, MultiplicationAssignmentOperator) +{ + v1 *= 2.0f; + EXPECT_FLOAT_EQ(v1.x, 2.0f); + EXPECT_FLOAT_EQ(v1.y, 4.0f); + EXPECT_FLOAT_EQ(v1.z, 6.0f); +} + +TEST_F(UnitTestVector3, MultiplicationWithVectorAssignmentOperator) +{ + v1 *= v2; + EXPECT_FLOAT_EQ(v1.x, 4.0f); + EXPECT_FLOAT_EQ(v1.y, 10.0f); + EXPECT_FLOAT_EQ(v1.z, 18.0f); +} + +TEST_F(UnitTestVector3, DivisionAssignmentOperator) +{ + v1 /= 2.0f; + EXPECT_FLOAT_EQ(v1.x, 0.5f); + EXPECT_FLOAT_EQ(v1.y, 1.0f); + EXPECT_FLOAT_EQ(v1.z, 1.5f); +} + +TEST_F(UnitTestVector3, DivisionWithVectorAssignmentOperator) +{ + v1 /= v2; + EXPECT_FLOAT_EQ(v1.x, 0.25f); + EXPECT_FLOAT_EQ(v1.y, 0.4f); + EXPECT_FLOAT_EQ(v1.z, 0.5f); +} + +TEST_F(UnitTestVector3, NegationOperator) +{ + Vector3 v3 = -v1; + EXPECT_FLOAT_EQ(v3.x, -1.0f); + EXPECT_FLOAT_EQ(v3.y, -2.0f); + EXPECT_FLOAT_EQ(v3.z, -3.0f); +} + +// Test other member functions +TEST_F(UnitTestVector3, DistTo) +{ + float dist = v1.DistTo(v2); + EXPECT_FLOAT_EQ(dist, sqrt(27.0f)); +} + +TEST_F(UnitTestVector3, DistToSqr) +{ + float distSqr = v1.DistToSqr(v2); + EXPECT_FLOAT_EQ(distSqr, 27.0f); +} + +TEST_F(UnitTestVector3, DotProduct) +{ + float dot = v1.Dot(v2); + EXPECT_FLOAT_EQ(dot, 32.0f); +} + +TEST_F(UnitTestVector3, CrossProduct) +{ + Vector3 v3 = v1.Cross(v2); + EXPECT_FLOAT_EQ(v3.x, -3.0f); + EXPECT_FLOAT_EQ(v3.y, 6.0f); + EXPECT_FLOAT_EQ(v3.z, -3.0f); +} + +TEST_F(UnitTestVector3, Length) +{ + float length = v1.Length(); + EXPECT_FLOAT_EQ(length, sqrt(14.0f)); +} + +TEST_F(UnitTestVector3, LengthSqr) +{ + float lengthSqr = v1.LengthSqr(); + EXPECT_FLOAT_EQ(lengthSqr, 14.0f); +} + +TEST_F(UnitTestVector3, Length2D) +{ + float length2D = v1.Length2D(); + EXPECT_FLOAT_EQ(length2D, sqrt(5.0f)); +} + +TEST_F(UnitTestVector3, Abs) +{ + Vector3 v3(-1.0f, -2.0f, -3.0f); + v3.Abs(); + EXPECT_FLOAT_EQ(v3.x, 1.0f); + EXPECT_FLOAT_EQ(v3.y, 2.0f); + EXPECT_FLOAT_EQ(v3.z, 3.0f); +} + +TEST_F(UnitTestVector3, Sum) +{ + float sum = v1.Sum(); + EXPECT_FLOAT_EQ(sum, 6.0f); +} + +TEST_F(UnitTestVector3, Sum2D) +{ + float sum2D = v1.Sum2D(); + EXPECT_FLOAT_EQ(sum2D, 3.0f); +} + +TEST_F(UnitTestVector3, ViewAngleTo) +{ + Vector3 angle = v1.ViewAngleTo(v1 + Vector3(0.f, 0.f, 5.f)); + EXPECT_NEAR(angle.x, 90.f, 0.01f); // Approximate values, you can fine-tune the expected values + EXPECT_NEAR(angle.y, 0.f, 0.01f); +} + +TEST_F(UnitTestVector3, ForwardVector) +{ + Vector3 forward = Vector3::ForwardVector(0.0f, 0.0f); + EXPECT_FLOAT_EQ(forward.x, 1.0f); + EXPECT_FLOAT_EQ(forward.y, 0.0f); + EXPECT_FLOAT_EQ(forward.z, 0.0f); +} + +TEST_F(UnitTestVector3, RightVector) +{ + Vector3 right = Vector3::RightVector(0.0f, 0.0f, 0.0f); + EXPECT_FLOAT_EQ(right.x, 0.0f); + EXPECT_FLOAT_EQ(right.y, -1.0f); + EXPECT_FLOAT_EQ(right.z, 0.0f); +} + +TEST_F(UnitTestVector3, UpVector) +{ + Vector3 up = Vector3::UpVector(0.f, 0.0f, 0.0f); + EXPECT_FLOAT_EQ(up.x, 0.0f); + EXPECT_FLOAT_EQ(up.y, 0.0f); + EXPECT_FLOAT_EQ(up.z, 1.0f); +} + +TEST_F(UnitTestVector3, Normalized) +{ + Vector3 v3 = v1.Normalized(); + EXPECT_NEAR(v3.x, 0.26726f, 0.0001f); + EXPECT_NEAR(v3.y, 0.53452f, 0.0001f); + EXPECT_NEAR(v3.z, 0.80178f, 0.0001f); +} \ No newline at end of file