Merge pull request #75 from orange-cpp/bugfix/fix_look_at

Bugfix/fix look at

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "extlibs/googletest"]
 	path = extlibs/googletest
-	url = https://github.com/google/googletest.git
+	url = https://github.com/google/googletest.git
+[submodule "extlibs/benchmark"]
+	path = extlibs/benchmark
+	url = https://github.com/google/benchmark.git

.idea/vcs.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="VcsDirectoryMappings">
     <mapping directory="" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/extlibs/benchmark" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/extlibs/googletest" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$/extlibs/vcpkg" vcs="Git" />
   </component>
 </project>

CMakeLists.txt

@@ -6,6 +6,7 @@ include(CMakePackageConfigHelpers)
 
 
 option(OMATH_BUILD_TESTS "Build unit tests" ${PROJECT_IS_TOP_LEVEL})
+option(OMATH_BUILD_BENCHMARK "Build benchmarks" ${PROJECT_IS_TOP_LEVEL})
 option(OMATH_THREAT_WARNING_AS_ERROR "Set highest level of warnings and force compiler to treat them as errors" ON)
 option(OMATH_BUILD_AS_SHARED_LIBRARY "Build Omath as .so or .dll" OFF)
 option(OMATH_USE_AVX2 "Omath will use AVX2 to boost performance" ON)
@@ -13,12 +14,13 @@ option(OMATH_IMGUI_INTEGRATION "Omath will define method to convert omath types
 option(OMATH_BUILD_EXAMPLES "Build example projects with you can learn & play" OFF)
 option(OMATH_STATIC_MSVC_RUNTIME_LIBRARY "Force Omath to link static runtime" OFF)
 option(OMATH_SUPRESS_SAFETY_CHECKS "Supress some safety checks in release build to improve general performance" ON)
-option(OMATH_USE_UNITY_BUILD "Will enable unity build to speed up compilation" ON)
+option(OMATH_USE_UNITY_BUILD "Will enable unity build to speed up compilation" OFF)
 option(OMATH_ENABLE_LEGACY "Will enable legacy classes that MUST be used ONLY for backward compatibility" OFF)
 
-message(STATUS "[${PROJECT_NAME}]: Building on ${CMAKE_HOST_SYSTEM_NAME}")
+message(STATUS "[${PROJECT_NAME}]: Building on ${CMAKE_HOST_SYSTEM_NAME}, compiler ${CMAKE_CXX_COMPILER_ID}")
 message(STATUS "[${PROJECT_NAME}]: Warnings as errors ${OMATH_THREAT_WARNING_AS_ERROR}")
 message(STATUS "[${PROJECT_NAME}]: Build unit tests ${OMATH_BUILD_TESTS}")
+message(STATUS "[${PROJECT_NAME}]: Build benchmark ${OMATH_BUILD_BENCHMARK}")
 message(STATUS "[${PROJECT_NAME}]: As dynamic library ${OMATH_BUILD_AS_SHARED_LIBRARY}")
 message(STATUS "[${PROJECT_NAME}]: Static C++ runtime ${OMATH_STATIC_MSVC_RUNTIME_LIBRARY}")
 message(STATUS "[${PROJECT_NAME}]: CMake unity build ${OMATH_USE_UNITY_BUILD}")
@@ -90,16 +92,23 @@ if (OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
     )
 endif ()
 
-if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    target_compile_options(${PROJECT_NAME} PRIVATE -mavx2 -mfma)
+if (OMATH_USE_AVX2 AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    target_compile_options(${PROJECT_NAME} PUBLIC -mavx2 -mavx -mfma)
 endif ()
 
 target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_23)
 
+if (OMATH_BUILD_TESTS OR OMATH_BUILD_BENCHMARK)
+    add_subdirectory(extlibs)
+endif ()
 
 if (OMATH_BUILD_TESTS)
-    add_subdirectory(extlibs)
     add_subdirectory(tests)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_BUILD_TESTS)
+endif ()
+
+if (OMATH_BUILD_BENCHMARK)
+    add_subdirectory(benchmark)
 endif ()
 
 if (OMATH_BUILD_EXAMPLES)

CREDITS.md

@@ -2,10 +2,12 @@
 
 Thanks to everyone who made this possible, including:
 
-- Saikari aka luadebug for VCPKG port.
+- Saikari aka luadebug for VCPKG port and awesome new initial logo design.
+- AmbushedRaccoon for telegram post about omath to boost repository activity.
+- Billy O'Neal aka BillyONeal for fixing compilation issues due to C math library compatibility.
 
 And a big hand to everyone else who has contributed over the past!
 
 THANKS! <3
 
-    -- Orange++ <orange-cpp@yandex.ru>
+    -- Orange++ <orange_github@proton.me>

LICENSE

@@ -1,4 +1,4 @@
-Copyright (C) 2024-2025 Orange++ <orange-cpp@yandex.ru>
+Copyright (C) 2024-2025 Orange++ <orange_github@proton.me>
 
 This software is provided 'as-is', without any express or implied
 warranty.  In no event will the authors be held liable for any damages
@@ -14,4 +14,15 @@ freely, subject to the following restrictions:
    appreciated but is not required.
 2. Altered source versions must be plainly marked as such, and must not be
    misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
+3. This notice may not be removed or altered from any source distribution.
+4. If you are an employee, contractor, volunteer, representative, 
+   or have any other affiliation (past, present, or future)
+   with any of the following entities:
+     * "Yandex" LLC
+     * "Rutube" LLC
+   Or if you represent or are associated with any legal, organizational, or 
+   professional entity providing services to or on behalf of the aforementioned entities:
+   You are expressly forbidden from accessing, using, modifying, distributing, or
+   interacting with the Software  and its source code in any form. You must immediately 
+   delete or destroy any physical or digital copies of the Software  and/or
+   its source code, including any derivative works, tools, or information obtained from the Software.

README.md

@@ -1,8 +1,8 @@
 <div align = center>
 
-![banner](https://github.com/orange-cpp/omath/blob/main/.github/images/banner.png?raw=true)
+![banner](.github/images/logos/omath_logo_macro.png)
 
-![GitHub License](https://img.shields.io/github/license/orange-cpp/omath)
+![Static Badge](https://img.shields.io/badge/license-libomath-orange)
 ![GitHub contributors](https://img.shields.io/github/contributors/orange-cpp/omath)
 ![GitHub top language](https://img.shields.io/github/languages/top/orange-cpp/omath)
 [![CodeFactor](https://www.codefactor.io/repository/github/orange-cpp/omath/badge)](https://www.codefactor.io/repository/github/orange-cpp/omath)
@@ -12,9 +12,25 @@
 [![discord badge](https://dcbadge.limes.pink/api/server/https://discord.gg/eDgdaWbqwZ?style=flat)](https://discord.gg/eDgdaWbqwZ)
 [![telegram badge](https://img.shields.io/badge/Telegram-2CA5E0?style=flat-squeare&logo=telegram&logoColor=white)](https://t.me/orangennotes)
 
+OMath is a 100% independent, constexpr template blazingly fast math library that doesn't have legacy C++ code.
+
+It provides the latest features, is highly customizable, has all for cheat development, DirectX/OpenGL/Vulkan support, premade support for different game engines, much more constexpr stuff than in other libraries and more...
+<br>
+<br>
+
+---
+
+**[<kbd> <br> Install <br> </kbd>][INSTALL]** 
+**[<kbd> <br> Examples <br> </kbd>][EXAMPLES]** 
+**[<kbd> <br> Contribute <br> </kbd>][CONTRIBUTING]** 
+**[<kbd> <br> Donate <br> </kbd>][SPONSOR]** 
+
+---
+
+<br>
+
 </div>
 
-Oranges's Math Library (omath) is a comprehensive, open-source library aimed at providing efficient, reliable, and versatile mathematical functions and algorithms. Developed primarily in C++, this library is designed to cater to a wide range of mathematical operations essential in scientific computing, engineering, and academic research.
 
 <div align = center>
  <a href="https://www.star-history.com/#orange-cpp/omath&Date">
@@ -36,6 +52,29 @@ Oranges's Math Library (omath) is a comprehensive, open-source library aimed at
 - **No Additional Dependencies**: No additional dependencies need to use OMath except unit test execution
 - **Ready for meta-programming**: Omath use templates for common types like Vectors, Matrixes etc, to handle all types!
 
+# Gallery
+
+<br>
+
+[![Youtube Video](.github/images/yt_previews/img.png)](https://youtu.be/lM_NJ1yCunw?si=-Qf5yzDcWbaxAXGQ)
+
+<br>
+
+![APEX Preview]
+
+<br>
+
+![BO2 Preview]
+
+<br>
+
+![CS2 Preview]
+
+<br>
+<br>
+
+
+
 ## Supported Render Pipelines
 | ENGINE   | SUPPORT |
 |----------|---------|
@@ -53,9 +92,6 @@ Oranges's Math Library (omath) is a comprehensive, open-source library aimed at
 | Linux          | ✅YES    |
 | Darwin (MacOS) | ✅YES    |
 
-## ⏬ Installation
-Please read our [installation guide](https://github.com/orange-cpp/omath/blob/main/INSTALL.md). If this link doesn't work check out INSTALL.md file.
-
 ## ❔ Usage
 ESP example
 ```c++
@@ -77,26 +113,17 @@ for (auto ent: apex_sdk::EntityList::GetAllEntities())
     // esp rendering...
 }
 ```
-## Showcase
-<details>
-  <summary>OMATH for making cheats (click to open)</summary>
-
-With `omath/projection` module you can achieve simple ESP hack for powered by Source/Unreal/Unity engine games, like [Apex Legends](https://store.steampowered.com/app/1172470/Apex_Legends/).
-
-![banner](https://i.imgur.com/lcJrfcZ.png)
-Or for InfinityWard Engine based games. Like Call of Duty Black Ops 2!
-![banner](https://i.imgur.com/F8dmdoo.png)
-Or create simple trigger bot with embeded traceline from omath::collision::LineTrace
-![banner](https://i.imgur.com/fxMjRKo.jpeg)
-Or even advanced projectile aimbot
-[Watch Video](https://youtu.be/lM_NJ1yCunw?si=5E87OrQMeypxSJ3E)
-</details>
-
-## 🫵🏻 Contributing
-Contributions to `omath` are welcome! Please read `CONTRIBUTING.md` for details on our code of conduct and the process for submitting pull requests.
-
-## 📜 License
-This project is licensed under the ZLIB - see the `LICENSE` file for details.
 
 ## 💘 Acknowledgments
 -  [All contributors](https://github.com/orange-cpp/omath/graphs/contributors)
+
+<!----------------------------------{ Images }--------------------------------->
+[APEX Preview]: .github/images/showcase/apex.png
+[BO2 Preview]: .github/images/showcase/cod_bo2.png
+[CS2 Preview]: .github/images/showcase/cs2.jpeg
+
+<!----------------------------------{ Buttons }--------------------------------->
+[INSTALL]: INSTALL.md
+[CONTRIBUTING]: CONTRIBUTING.md
+[EXAMPLES]: examples
+[SPONSOR]: https://boosty.to/orangecpp/purchase/3568644?ssource=DIRECT&share=subscription_link

SECURITY.md

@@ -2,4 +2,4 @@
 
 ## Reporting a Vulnerability
 
-Please report security issues to `orange-cpp@yandex.ru`
+Please report security issues to `orange_github@proton.me`

benchmark/CMakeLists.txt

@@ -0,0 +1,15 @@
+project(omath_benchmark)
+
+
+file(GLOB_RECURSE OMATH_BENCHMARK_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
+add_executable(${PROJECT_NAME} ${OMATH_BENCHMARK_SOURCES})
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+        CXX_STANDARD 23
+        CXX_STANDARD_REQUIRED ON)
+
+
+target_link_libraries(${PROJECT_NAME} PRIVATE benchmark::benchmark omath)

benchmark/benchmark_mat.cpp

@@ -0,0 +1,66 @@
+//
+// Created by Vlad on 9/17/2025.
+//
+#include <benchmark/benchmark.h>
+
+#include <omath/omath.hpp>
+#include <chrono>
+using namespace omath;
+
+
+void mat_float_multiplication_col_major(benchmark::State& state)
+{
+    using MatType = Mat<128, 128, float, MatStoreType::COLUMN_MAJOR>;
+    MatType a;
+    MatType b;
+    a.set(3.f);
+    b.set(7.f);
+
+
+    for (auto _ : state)
+        std::ignore = a * b;
+}
+void mat_float_multiplication_row_major(benchmark::State& state)
+{
+    using MatType = Mat<128, 128, float, MatStoreType::ROW_MAJOR>;
+    MatType a;
+    MatType b;
+    a.set(3.f);
+    b.set(7.f);
+
+
+    for (auto _ : state)
+        std::ignore = a * b;
+}
+
+void mat_double_multiplication_row_major(benchmark::State& state)
+{
+    using MatType = Mat<128, 128, double, MatStoreType::ROW_MAJOR>;
+    MatType a;
+    MatType b;
+    a.set(3.f);
+    b.set(7.f);
+
+
+    for (auto _ : state)
+        std::ignore = a * b;
+}
+
+void mat_double_multiplication_col_major(benchmark::State& state)
+{
+    using MatType = Mat<128, 128, double, MatStoreType::COLUMN_MAJOR>;
+    MatType a;
+    MatType b;
+    a.set(3.f);
+    b.set(7.f);
+
+
+    for (auto _ : state)
+        std::ignore = a * b;
+}
+
+BENCHMARK(mat_float_multiplication_col_major)->Iterations(5000);
+BENCHMARK(mat_float_multiplication_row_major)->Iterations(5000);
+
+BENCHMARK(mat_double_multiplication_col_major)->Iterations(5000);
+BENCHMARK(mat_double_multiplication_row_major)->Iterations(5000);

benchmark/benchmark_projectile_pred.cpp

@@ -0,0 +1,3 @@
+//
+// Created by Vlad on 9/18/2025.
+//

benchmark/main.cpp

@@ -0,0 +1,5 @@
+//
+// Created by Vlad on 9/17/2025.
+//
+#include <benchmark/benchmark.h>
+BENCHMARK_MAIN();

extlibs/CMakeLists.txt

@@ -1 +1,2 @@
-add_subdirectory(googletest)
+add_subdirectory(googletest)
+add_subdirectory(benchmark)

include/omath/angle.hpp

@@ -5,8 +5,8 @@
 #pragma once
 #include "omath/angles.hpp"
 #include <algorithm>
-#include <utility>
 #include <format>
+#include <utility>
 
 namespace omath
 {
@@ -123,13 +123,13 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Angle& operator+(const Angle& other) noexcept
+        constexpr Angle operator+(const Angle& other) noexcept
         {
             if constexpr (flags == AngleFlags::Normalized)
-                return {angles::wrap_angle(m_angle + other.m_angle, min, max)};
+                return Angle{angles::wrap_angle(m_angle + other.m_angle, min, max)};
 
             else if constexpr (flags == AngleFlags::Clamped)
-                return {std::clamp(m_angle + other.m_angle, min, max)};
+                return Angle{std::clamp(m_angle + other.m_angle, min, max)};
 
             else
                 static_assert(false);
@@ -138,7 +138,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Angle& operator-(const Angle& other) noexcept
+        constexpr Angle operator-(const Angle& other) noexcept
         {
             return operator+(-other);
         }
@@ -150,17 +150,40 @@ namespace omath
         }
     };
 } // namespace omath
-template<class Type, Type min, Type max, omath::AngleFlags flags>
-struct std::formatter<omath::Angle<Type, min, max, flags>> // NOLINT(*-dcl58-cpp)
+
+template<class T, T MinV, T MaxV, omath::AngleFlags F>
+struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char> // NOLINT(*-dcl58-cpp)
 {
-    [[nodiscard]]
+    using AngleT = omath::Angle<T, MinV, MaxV, F>;
+
     static constexpr auto parse(std::format_parse_context& ctx)
     {
         return ctx.begin();
     }
-    [[nodiscard]]
-    static auto format(const omath::Angle<Type, min, max, flags>& deg, std::format_context& ctx)
+
+    template<class FormatContext>
+    auto format(const AngleT& a, FormatContext& ctx) const
     {
-        return std::format_to(ctx.out(), "{}deg", deg.as_degrees());
+        static_assert(std::is_same_v<typename FormatContext::char_type, char>);
+        return std::format_to(ctx.out(), "{}deg", a.as_degrees());
     }
-};
+};
+
+// wchar_t formatter
+template<class T, T MinV, T MaxV, omath::AngleFlags F>
+struct std::formatter<omath::Angle<T, MinV, MaxV, F>, wchar_t> // NOLINT(*-dcl58-cpp)
+{
+    using AngleT = omath::Angle<T, MinV, MaxV, F>;
+
+    static constexpr auto parse(std::wformat_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<class FormatContext>
+    auto format(const AngleT& a, FormatContext& ctx) const
+    {
+        static_assert(std::is_same_v<typename FormatContext::char_type, wchar_t>);
+        return std::format_to(ctx.out(), L"{}deg", a.as_degrees());
+    }
+};

include/omath/color.hpp

@@ -95,7 +95,7 @@ namespace omath
                 hsv_data.hue = 0.f;
 
             else if (max == red)
-                hsv_data.hue = 60.f * (std::fmodf(((green - blue) / delta), 6.f));
+                hsv_data.hue = 60.f * (std::fmod(static_cast<float>((green - blue) / delta), 6.f));
             else if (max == green)
                 hsv_data.hue = 60.f * (((blue - red) / delta) + 2.f);
             else if (max == blue)

include/omath/linear_algebra/mat.hpp

@@ -11,14 +11,12 @@
 #include <stdexcept>
 #include <utility>
 
-#ifdef near
+#ifdef OMATH_USE_AVX2
+#include <immintrin.h>
+#endif
+
 #undef near
-#endif
-
-#ifdef far
 #undef far
-#endif
-
 namespace omath
 {
     struct MatSize
@@ -88,7 +86,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Type& operator[](const size_t row, const size_t col) const
+        constexpr const Type& operator[](const size_t row, const size_t col) const
         {
             return at(row, col);
         }
@@ -162,17 +160,19 @@ namespace omath
         constexpr Mat<Rows, OtherColumns, Type, StoreType>
         operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
         {
-            Mat<Rows, OtherColumns, Type, StoreType> result;
-
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < OtherColumns; ++j)
-                {
-                    Type sum = 0;
-                    for (size_t k = 0; k < Columns; ++k)
-                        sum += at(i, k) * other.at(k, j);
-                    result.at(i, j) = sum;
-                }
-            return result;
+#ifdef OMATH_USE_AVX2
+            if constexpr (StoreType == MatStoreType::ROW_MAJOR)
+                return avx_multiply_row_major(other);
+            else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
+                return avx_multiply_col_major(other);
+#else
+            if constexpr (StoreType == MatStoreType::ROW_MAJOR)
+                return cache_friendly_multiply_row_major(other);
+            else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
+                return cache_friendly_multiply_col_major(other);
+#endif
+            else
+                std::unreachable();
         }
 
         constexpr Mat& operator*=(const Type& f) noexcept
@@ -374,6 +374,176 @@ namespace omath
 
     private:
         std::array<Type, Rows * Columns> m_data;
+
+        template<size_t OtherColumns> [[nodiscard]]
+        constexpr Mat<Rows, OtherColumns, Type, MatStoreType::ROW_MAJOR>
+        cache_friendly_multiply_row_major(const Mat<Columns, OtherColumns, Type, MatStoreType::ROW_MAJOR>& other) const
+        {
+            Mat<Rows, OtherColumns, Type, MatStoreType::ROW_MAJOR> result;
+            for (std::size_t row_index = 0; row_index < Rows; ++row_index)
+                for (std::size_t column_index = 0; column_index < Columns; ++column_index)
+                {
+                    const Type& current_number = at(row_index, column_index);
+                    for (std::size_t other_column = 0; other_column < OtherColumns; ++other_column)
+                        result.at(row_index, other_column) += current_number * other.at(column_index, other_column);
+                }
+            return result;
+        }
+
+        template<size_t OtherColumns> [[nodiscard]]
+        constexpr Mat<Rows, OtherColumns, Type, MatStoreType::COLUMN_MAJOR> cache_friendly_multiply_col_major(
+                const Mat<Columns, OtherColumns, Type, MatStoreType::COLUMN_MAJOR>& other) const
+        {
+            Mat<Rows, OtherColumns, Type, MatStoreType::COLUMN_MAJOR> result;
+            for (std::size_t other_column = 0; other_column < OtherColumns; ++other_column)
+                for (std::size_t column_index = 0; column_index < Columns; ++column_index)
+                {
+                    const Type& current_number = other.at(column_index, other_column);
+                    for (std::size_t row_index = 0; row_index < Rows; ++row_index)
+                        result.at(row_index, other_column) += at(row_index, column_index) * current_number;
+                }
+            return result;
+        }
+#ifdef OMATH_USE_AVX2
+        template<size_t OtherColumns> [[nodiscard]]
+        constexpr Mat<Rows, OtherColumns, Type, MatStoreType::COLUMN_MAJOR>
+        avx_multiply_col_major(const Mat<Columns, OtherColumns, Type, MatStoreType::COLUMN_MAJOR>& other) const
+        {
+            Mat<Rows, OtherColumns, Type, MatStoreType::COLUMN_MAJOR> result;
+
+            const Type* this_mat_data = this->raw_array().data();
+            const Type* other_mat_data = other.raw_array().data();
+            Type* result_mat_data = result.raw_array().data();
+
+            if constexpr (std::is_same_v<Type, float>)
+            {
+                // ReSharper disable once CppTooWideScopeInitStatement
+                constexpr std::size_t vector_size = 8;
+                for (std::size_t j = 0; j < OtherColumns; ++j)
+                {
+                    auto* c_col = reinterpret_cast<float*>(result_mat_data + j * Rows);
+                    for (std::size_t k = 0; k < Columns; ++k)
+                    {
+                        const float bkj = reinterpret_cast<const float*>(other_mat_data)[k + j * Columns];
+                        __m256 bkjv = _mm256_set1_ps(bkj);
+
+                        const auto* a_col_k = reinterpret_cast<const float*>(this_mat_data + k * Rows);
+
+                        std::size_t i = 0;
+                        for (; i + vector_size <= Rows; i += vector_size)
+                        {
+                            __m256 cvec = _mm256_loadu_ps(c_col + i);
+                            __m256 avec = _mm256_loadu_ps(a_col_k + i);
+                            cvec = _mm256_fmadd_ps(avec, bkjv, cvec);
+                            _mm256_storeu_ps(c_col + i, cvec);
+                        }
+                        for (; i < Rows; ++i)
+                            c_col[i] += a_col_k[i] * bkj;
+                    }
+                }
+            }
+            else if (std::is_same_v<Type, double>)
+            { // double
+                // ReSharper disable once CppTooWideScopeInitStatement
+                constexpr std::size_t vector_size = 4;
+                for (std::size_t j = 0; j < OtherColumns; ++j)
+                {
+                    auto* c_col = reinterpret_cast<double*>(result_mat_data + j * Rows);
+                    for (std::size_t k = 0; k < Columns; ++k)
+                    {
+                        const double bkj = reinterpret_cast<const double*>(other_mat_data)[k + j * Columns];
+                        __m256d bkjv = _mm256_set1_pd(bkj);
+
+                        const auto* a_col_k = reinterpret_cast<const double*>(this_mat_data + k * Rows);
+
+                        std::size_t i = 0;
+                        for (; i + vector_size <= Rows; i += vector_size)
+                        {
+                            __m256d cvec = _mm256_loadu_pd(c_col + i);
+                            __m256d avec = _mm256_loadu_pd(a_col_k + i);
+                            cvec = _mm256_fmadd_pd(avec, bkjv, cvec);
+                            _mm256_storeu_pd(c_col + i, cvec);
+                        }
+                        for (; i < Rows; ++i)
+                            c_col[i] += a_col_k[i] * bkj;
+                    }
+                }
+            }
+            else
+                std::unreachable();
+
+            return result;
+        }
+
+        template<size_t OtherColumns> [[nodiscard]]
+        constexpr Mat<Rows, OtherColumns, Type, MatStoreType::ROW_MAJOR>
+        avx_multiply_row_major(const Mat<Columns, OtherColumns, Type, MatStoreType::ROW_MAJOR>& other) const
+        {
+            Mat<Rows, OtherColumns, Type, MatStoreType::ROW_MAJOR> result;
+
+            const Type* this_mat_data = this->raw_array().data();
+            const Type* other_mat_data = other.raw_array().data();
+            Type* result_mat_data = result.raw_array().data();
+
+            if constexpr (std::is_same_v<Type, float>)
+            {
+                // ReSharper disable once CppTooWideScopeInitStatement
+                constexpr std::size_t vector_size = 8;
+                for (std::size_t i = 0; i < Rows; ++i)
+                {
+                    Type* c_row = result_mat_data + i * OtherColumns;
+                    for (std::size_t k = 0; k < Columns; ++k)
+                    {
+                        const auto aik = static_cast<float>(this_mat_data[i * Columns + k]);
+                        __m256 aikv = _mm256_set1_ps(aik);
+                        const auto* b_row = reinterpret_cast<const float*>(other_mat_data + k * OtherColumns);
+
+                        std::size_t j = 0;
+                        for (; j + vector_size <= OtherColumns; j += vector_size)
+                        {
+                            __m256 cvec = _mm256_loadu_ps(c_row + j);
+                            __m256 bvec = _mm256_loadu_ps(b_row + j);
+                            cvec = _mm256_fmadd_ps(bvec, aikv, cvec);
+
+                            _mm256_storeu_ps(c_row + j, cvec);
+                        }
+                        for (; j < OtherColumns; ++j)
+                            c_row[j] += aik * b_row[j];
+                    }
+                }
+            }
+            else if (std::is_same_v<Type, double>)
+            { // double
+                // ReSharper disable once CppTooWideScopeInitStatement
+                constexpr std::size_t vector_size = 4;
+                for (std::size_t i = 0; i < Rows; ++i)
+                {
+                    Type* c_row = result_mat_data + i * OtherColumns;
+                    for (std::size_t k = 0; k < Columns; ++k)
+                    {
+                        const auto aik = static_cast<double>(this_mat_data[i * Columns + k]);
+                        __m256d aikv = _mm256_set1_pd(aik);
+                        const auto* b_row = reinterpret_cast<const double*>(other_mat_data + k * OtherColumns);
+
+                        std::size_t j = 0;
+                        for (; j + vector_size <= OtherColumns; j += vector_size)
+                        {
+                            __m256d cvec = _mm256_loadu_pd(c_row + j);
+                            __m256d bvec = _mm256_loadu_pd(b_row + j);
+                            cvec = _mm256_fmadd_pd(bvec, aikv, cvec);
+
+                            _mm256_storeu_pd(c_row + j, cvec);
+                        }
+                        for (; j < OtherColumns; ++j)
+                            c_row[j] += aik * b_row[j];
+                    }
+                }
+            }
+            else
+                std::unreachable();
+            return result;
+        }
+#endif
     };
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard]]
@@ -507,6 +677,23 @@ namespace omath
                 { 0.f,      0.f,       0.f,                                  1.f                             }
         };
     }
+    template<class T = float, MatStoreType St = MatStoreType::COLUMN_MAJOR>
+   Mat<4, 4, T, St> mat_look_at_left_handed(const Vector3<T>& eye, const Vector3<T>& center, const Vector3<T>& up)
+    {
+        const Vector3<T> f = (center - eye).normalized();
+        const Vector3<T> s = f.cross(up).normalized();
+        const Vector3<T> u = s.cross(f);
+        return mat_camera_view<T, St>(f, s, u, eye);
+    }
+
+    template<class T = float, MatStoreType St = MatStoreType::COLUMN_MAJOR>
+    Mat<4, 4, T, St>mat_look_at_right_handed(const Vector3<T>& eye, const Vector3<T>& center, const Vector3<T>& up)
+    {
+        const Vector3<T> f = (center - eye).normalized();
+        const Vector3<T> s = f.cross(up).normalized();
+        const Vector3<T> u = s.cross(f);
+        return mat_camera_view<T, St>(-f, s, u, eye);
+    }
 
 } // namespace omath
 

include/omath/linear_algebra/matrix.hpp

@@ -1,127 +0,0 @@
-#pragma once
-
-/*
-THIS CODE IS DEPRECATED NEVER EVER USE Matrix CLASS
-AND VERY SLOW USE Mat INSTEAD!!!!!!!!!!!
-⠛⠛⣿⣿⣿⣿⣿⡷⢶⣦⣶⣶⣤⣤⣤⣀⠀⠀⠀
-⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡀⠀
-⠀⠀⠀⠉⠉⠉⠙⠻⣿⣿⠿⠿⠛⠛⠛⠻⣿⣿⣇⠀
-⠀⠀⢤⣀⣀⣀⠀⠀⢸⣷⡄⠀⣁⣀⣤⣴⣿⣿⣿⣆
-⠀⠀⠀⠀⠹⠏⠀⠀⠀⣿⣧⠀⠹⣿⣿⣿⣿⣿⡿⣿
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠛⠿⠇⢀⣼⣿⣿⠛⢯⡿⡟
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠦⠴⢿⢿⣿⡿⠷⠀⣿⠀
-⠀⠀⠀⠀⠀⠀⠀⠙⣷⣶⣶⣤⣤⣤⣤⣤⣶⣦⠃⠀
-⠀⠀⠀⠀⠀⠀⠀⢐⣿⣾⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠈⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠻⢿⣿⣿⣿⣿⠟⠁
-*/
-
-#ifdef OMATH_ENABLE_LEGACY
-#include "omath/vector3.hpp"
-#include <initializer_list>
-#include <memory>
-#include <string>
-
-namespace omath
-{
-
-    class Matrix final
-    {
-    public:
-        Matrix();
-        Matrix(size_t rows, size_t columns);
-
-        Matrix(const std::initializer_list<std::initializer_list<float>>& rows);
-
-        [[nodiscard]]
-        static Matrix to_screen_matrix(float screen_width, float screen_height);
-
-        [[nodiscard]]
-        static Matrix translation_matrix(const Vector3<float>& diff);
-
-        [[nodiscard]]
-        static Matrix orientation_matrix(const Vector3<float>& forward, const Vector3<float>& right,
-                                         const Vector3<float>& up);
-
-        [[nodiscard]]
-        static Matrix projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
-
-        Matrix(const Matrix& other);
-
-        Matrix(size_t rows, size_t columns, const float* raw_data);
-
-        Matrix(Matrix&& other) noexcept;
-
-        [[nodiscard]]
-        size_t row_count() const noexcept;
-
-        [[nodiscard]]
-        float& operator[](size_t row, size_t column);
-
-        [[nodiscard]]
-        size_t columns_count() const noexcept;
-
-        [[nodiscard]]
-        std::pair<size_t, size_t> size() const noexcept;
-
-        [[nodiscard]]
-        float& at(size_t row, size_t col);
-
-        [[nodiscard]]
-        float sum();
-
-        void set_data_from_raw(const float* raw_matrix);
-
-        [[nodiscard]]
-        Matrix transpose() const;
-
-        void set(float val);
-
-        [[nodiscard]]
-        const float& at(size_t row, size_t col) const;
-
-        Matrix operator*(const Matrix& other) const;
-
-        Matrix& operator*=(const Matrix& other);
-
-        Matrix operator*(float f) const;
-
-        Matrix& operator*=(float f);
-
-        Matrix& operator/=(float f);
-
-        void clear();
-
-        [[nodiscard]]
-        Matrix strip(size_t row, size_t column) const;
-
-        [[nodiscard]]
-        float minor(size_t i, size_t j) const;
-
-        [[nodiscard]]
-        float alg_complement(size_t i, size_t j) const;
-
-        [[nodiscard]]
-        float determinant() const;
-
-        [[nodiscard]]
-        const float* raw() const;
-
-        Matrix& operator=(const Matrix& other);
-
-        Matrix& operator=(Matrix&& other) noexcept;
-
-        Matrix operator/(float f) const;
-
-        [[nodiscard]]
-        std::string to_string() const;
-
-        ~Matrix();
-
-    private:
-        size_t m_rows;
-        size_t m_columns;
-        std::unique_ptr<float[]> m_data;
-    };
-} // namespace omath
-#endif

include/omath/omath.hpp

@@ -15,7 +15,6 @@
 #include "omath/linear_algebra/vector3.hpp"
 
 // Matrix classes
-#include "linear_algebra/matrix.hpp"
 #include "omath/linear_algebra/mat.hpp"
 
 // Color functionality
@@ -81,4 +80,4 @@
 #include "omath/engines/unreal_engine/formulas.hpp"
 #include "omath/engines/unreal_engine/camera.hpp"
 #include "omath/engines/unreal_engine/traits/camera_trait.hpp"
-#include "omath/engines/unreal_engine/traits/pred_engine_trait.hpp"
+#include "omath/engines/unreal_engine/traits/pred_engine_trait.hpp"

include/omath/projection/camera.hpp

@@ -4,13 +4,18 @@
 
 #pragma once
 
-#include "omath/projection/error_codes.hpp"
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/vector3.hpp"
+#include "omath/projection/error_codes.hpp"
 #include <expected>
 #include <omath/angle.hpp>
 #include <type_traits>
 
+#ifdef OMATH_BUILD_TESTS
+// ReSharper disable once CppInconsistentNaming
+class UnitTestProjection_Projection_Test;
+#endif
+
 namespace omath::projection
 {
     class ViewPort final
@@ -45,6 +50,9 @@ namespace omath::projection
     requires CameraEngineConcept<TraitClass, Mat4X4Type, ViewAnglesType>
     class Camera final
     {
+#ifdef OMATH_BUILD_TESTS
+        friend UnitTestProjection_Projection_Test;
+#endif
     public:
         ~Camera() = default;
         Camera(const Vector3<float>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
@@ -54,12 +62,13 @@ namespace omath::projection
         {
         }
 
-    protected:
         void look_at(const Vector3<float>& target)
         {
             m_view_angles = TraitClass::calc_look_at_angle(m_origin, target);
+            m_view_projection_matrix = std::nullopt;
         }
 
+    protected:
         [[nodiscard]] Mat4X4Type calc_view_projection_matrix() const noexcept
         {
             return TraitClass::calc_projection_matrix(m_field_of_view, m_view_port, m_near_plane_distance,
@@ -164,6 +173,38 @@ namespace omath::projection
 
             return Vector3<float>{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)};
         }
+        [[nodiscard]]
+        std::expected<Vector3<float>, Error> view_port_to_screen(const Vector3<float>& ndc) const noexcept
+        {
+            const auto inv_view_proj = get_view_projection_matrix().inverted();
+
+            if (!inv_view_proj)
+                return std::unexpected(Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO);
+
+            auto inverted_projection =
+                    inv_view_proj.value() * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(ndc);
+
+            if (!inverted_projection.at(3, 0))
+                return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
+
+            inverted_projection /= inverted_projection.at(3, 0);
+
+            return Vector3<float>{inverted_projection.at(0, 0), inverted_projection.at(1, 0),
+                                  inverted_projection.at(2, 0)};
+        }
+
+        [[nodiscard]]
+        std::expected<Vector3<float>, Error> screen_to_world(const Vector3<float>& screen_pos) const noexcept
+        {
+            return view_port_to_screen(screen_to_ndc(screen_pos));
+        }
+
+        [[nodiscard]]
+        std::expected<Vector3<float>, Error> screen_to_world(const Vector2<float>& screen_pos) const noexcept
+        {
+            const auto& [x, y] = screen_pos;
+            return screen_to_world({x, y, 1.f});
+        }
 
     protected:
         ViewPort m_view_port{};
@@ -186,19 +227,25 @@ namespace omath::projection
 
         [[nodiscard]] Vector3<float> ndc_to_screen_position(const Vector3<float>& ndc) const noexcept
         {
-/*
-                    ^
-                    |        y
-                1   |
-                    |
-                    |
-        -1 ---------0--------- 1  --> x
-                    |
-                    |
-               -1   |
-                    v
-*/
+            /*
+                                ^
+                                |        y
+                            1   |
+                                |
+                                |
+                    -1 ---------0--------- 1  --> x
+                                |
+                                |
+                           -1   |
+                                v
+            */
             return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (1.f - ndc.y) / 2.f * m_view_port.m_height, ndc.z};
         }
+
+        [[nodiscard]] Vector3<float> screen_to_ndc(const Vector3<float>& screen_pos) const noexcept
+        {
+            return {screen_pos.x / m_view_port.m_width * 2.f - 1.f, 1.f - screen_pos.y / m_view_port.m_height * 2.f,
+                    screen_pos.z};
+        }
     };
 } // namespace omath::projection

include/omath/projection/error_codes.hpp

@@ -10,5 +10,6 @@ namespace omath::projection
     enum class Error : uint16_t
     {
         WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS,
+        INV_VIEW_PROJ_MAT_DET_EQ_ZERO,
     };
 }

source/collision/line_tracer.cpp

@@ -50,12 +50,10 @@ namespace omath::collision
 
         const auto t_hit = side_b.dot(q) * inv_det;
 
-        if (ray.infinite_length)
-        {
-            if (t_hit <= k_epsilon)
-                return ray.end;
-        }
-        else if (t_hit <= k_epsilon || t_hit > 1.0f - k_epsilon)
+        if (ray.infinite_length && t_hit <= k_epsilon)
+            return ray.end;
+
+        if (t_hit <= k_epsilon || t_hit > 1.0f - k_epsilon)
             return ray.end;
 
         return ray.start + ray_dir * t_hit;

source/engines/iw_engine/traits/camera_trait.cpp

@@ -8,11 +8,10 @@ namespace omath::iw_engine
 
     ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
     {
-        const auto distance = cam_origin.distance_to(look_at);
-        const auto delta = cam_origin - look_at;
+        const auto direction = (look_at - cam_origin).normalized();
 
-        return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
-                YawAngle::from_radians(std::atan2(delta.y, delta.x)), RollAngle::from_radians(0.f)};
+        return {PitchAngle::from_radians(-std::asin(direction.z)),
+                YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
     }
     Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {

source/engines/opengl_engine/formulas.cpp

@@ -28,14 +28,13 @@ namespace omath::opengl_engine
     }
     Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {
-        return mat_camera_view<float, MatStoreType::COLUMN_MAJOR>(-forward_vector(angles), right_vector(angles),
-                                                                  up_vector(angles), cam_origin);
+        return mat_look_at_right_handed(cam_origin, cam_origin+forward_vector(angles), up_vector(angles));
     }
     Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
     {
-        return mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch)
-               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw)
-               * mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
+        return mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll)
+               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(angles.yaw)
+               * mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(angles.pitch);
     }
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
                                               const float far) noexcept

source/engines/opengl_engine/traits/camera_trait.cpp

@@ -9,11 +9,10 @@ namespace omath::opengl_engine
 
     ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
     {
-        const auto distance = cam_origin.distance_to(look_at);
-        const auto delta = cam_origin - look_at;
+        const auto direction = (look_at - cam_origin).normalized();
 
-        return {PitchAngle::from_radians(-std::asin(delta.y / distance)),
-                YawAngle::from_radians(std::atan2(delta.z, delta.x)), RollAngle::from_radians(0.f)};
+        return {PitchAngle::from_radians(std::asin(direction.y)),
+                YawAngle::from_radians(-std::atan2(direction.x, -direction.z)), RollAngle::from_radians(0.f)};
     }
     Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {

source/engines/source_engine/traits/camera_trait.cpp

@@ -8,11 +8,11 @@ namespace omath::source_engine
 
     ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
     {
-        const auto distance = cam_origin.distance_to(look_at);
-        const auto delta = cam_origin - look_at;
+        const auto direction = (look_at - cam_origin).normalized();
 
-        return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
-                YawAngle::from_radians(std::atan2(delta.y, delta.x)), RollAngle::from_radians(0.f)};
+
+        return {PitchAngle::from_radians(-std::asin(direction.z)),
+                YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
     }
     Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {

source/engines/unity_engine/formulas.cpp

@@ -30,9 +30,9 @@ namespace omath::unity_engine
     }
     Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
     {
-        return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch)
+        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll)
                * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
-               * mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll);
+               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
     }
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
                                               const float far) noexcept

source/engines/unity_engine/traits/camera_trait.cpp

@@ -9,10 +9,10 @@ namespace omath::unity_engine
     ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
     {
         const auto distance = cam_origin.distance_to(look_at);
-        const auto delta = cam_origin - look_at;
+        const auto delta = look_at - cam_origin;
 
         return {PitchAngle::from_radians(-std::asin(delta.y / distance)),
-                YawAngle::from_radians(std::atan2(delta.z, delta.x)), RollAngle::from_radians(0.f)};
+                YawAngle::from_radians(std::atan2(delta.x, delta.z)), RollAngle::from_radians(0.f)};
     }
     Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {

source/engines/unreal_engine/formulas.cpp

@@ -31,8 +31,8 @@ namespace omath::unreal_engine
     Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
     {
         return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.roll)
-               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.pitch)
-               * mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.yaw);
+               * mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.pitch);
     }
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
                                               const float far) noexcept

source/engines/unreal_engine/traits/camera_trait.cpp

@@ -8,11 +8,10 @@ namespace omath::unreal_engine
 
     ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
     {
-        const auto distance = cam_origin.distance_to(look_at);
-        const auto delta = cam_origin - look_at;
+        const auto direction = (look_at - cam_origin).normalized();
 
-        return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
-                YawAngle::from_radians(std::atan2(delta.x, delta.y)), RollAngle::from_radians(0.f)};
+        return {PitchAngle::from_radians(-std::asin(direction.z)),
+                YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
     }
     Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {

source/matrix.cpp

@@ -1,364 +0,0 @@
-#ifdef OMATH_ENABLE_LEGACY
-
-#include "omath/matrix.hpp"
-#include "omath/angles.hpp"
-#include "omath/vector3.hpp"
-#include <complex>
-#include <format>
-#include <stdexcept>
-#include <utility>
-
-namespace omath
-{
-    Matrix::Matrix(const size_t rows, const size_t columns)
-    {
-        if (rows == 0 and columns == 0)
-            throw std::runtime_error("Matrix cannot be 0x0");
-
-        m_rows = rows;
-        m_columns = columns;
-
-        m_data = std::make_unique<float[]>(m_rows * m_columns);
-
-        set(0.f);
-    }
-
-    Matrix::Matrix(const std::initializer_list<std::initializer_list<float>>& rows)
-    {
-        m_rows = rows.size();
-        m_columns = rows.begin()->size();
-
-        for (const auto& row: rows)
-            if (row.size() != m_columns)
-                throw std::invalid_argument("All rows must have the same number of columns.");
-
-        m_data = std::make_unique<float[]>(m_rows * m_columns);
-
-        size_t i = 0;
-        for (const auto& row: rows)
-        {
-            size_t j = 0;
-            for (const auto& value: row)
-                at(i, j++) = value;
-            ++i;
-        }
-    }
-
-    Matrix::Matrix(const Matrix& other)
-    {
-        m_rows = other.m_rows;
-        m_columns = other.m_columns;
-
-        m_data = std::make_unique<float[]>(m_rows * m_columns);
-
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                at(i, j) = other.at(i, j);
-    }
-
-    Matrix::Matrix(const size_t rows, const size_t columns, const float* raw_data)
-    {
-        m_rows = rows;
-        m_columns = columns;
-
-        m_data = std::make_unique<float[]>(m_rows * m_columns);
-
-        for (size_t i = 0; i < rows * columns; ++i)
-            at(i / rows, i % columns) = raw_data[i];
-    }
-
-    size_t Matrix::row_count() const noexcept
-    {
-        return m_rows;
-    }
-
-    float& Matrix::operator[](const size_t row, const size_t column)
-    {
-        return at(row, column);
-    }
-
-    Matrix::Matrix(Matrix&& other) noexcept
-    {
-        m_rows = other.m_rows;
-        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::columns_count() const noexcept
-    {
-        return m_columns;
-    }
-
-    std::pair<size_t, size_t> Matrix::size() const noexcept
-    {
-        return {row_count(), columns_count()};
-    }
-
-    float& Matrix::at(const size_t row, const size_t col)
-    {
-        return const_cast<float&>(std::as_const(*this).at(row, col));
-    }
-
-    float Matrix::sum()
-    {
-        float sum = 0;
-
-        for (size_t i = 0; i < row_count(); i++)
-            for (size_t j = 0; j < columns_count(); j++)
-                sum += at(i, j);
-
-        return sum;
-    }
-
-    const float& Matrix::at(const size_t row, const size_t col) const
-    {
-        return m_data[row * m_columns + col];
-    }
-
-    Matrix Matrix::operator*(const Matrix& other) const
-    {
-        if (m_columns != other.m_rows)
-            throw std::runtime_error("n != m");
-
-        auto out_mat = Matrix(m_rows, other.m_columns);
-
-        for (size_t d = 0; d < m_rows; ++d)
-            for (size_t i = 0; i < other.m_columns; ++i)
-                for (size_t j = 0; j < other.m_rows; ++j)
-                    out_mat.at(d, i) += at(d, j) * other.at(j, i);
-
-        return out_mat;
-    }
-
-    Matrix& Matrix::operator*=(const Matrix& other)
-    {
-        *this = *this * other;
-        return *this;
-    }
-
-    Matrix Matrix::operator*(const float f) const
-    {
-        auto out = *this;
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                out.at(i, j) *= f;
-
-        return out;
-    }
-
-    Matrix& Matrix::operator*=(const float f)
-    {
-        for (size_t i = 0; i < row_count(); i++)
-            for (size_t j = 0; j < columns_count(); j++)
-                at(i, j) *= f;
-        return *this;
-    }
-
-    void Matrix::clear()
-    {
-        set(0.f);
-    }
-
-    Matrix& Matrix::operator=(const Matrix& other)
-    {
-        if (this == &other)
-            return *this;
-
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                at(i, j) = other.at(i, j);
-
-        return *this;
-    }
-
-    Matrix& Matrix::operator=(Matrix&& other) noexcept
-    {
-        if (this == &other)
-            return *this;
-
-        m_rows = other.m_rows;
-        m_columns = other.m_columns;
-        m_data = std::move(other.m_data);
-
-        other.m_rows = 0;
-        other.m_columns = 0;
-
-        return *this;
-    }
-
-    Matrix& Matrix::operator/=(const float f)
-    {
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                at(i, j) /= f;
-
-        return *this;
-    }
-
-    Matrix Matrix::operator/(const float f) const
-    {
-        auto out = *this;
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                out.at(i, j) /= f;
-
-        return out;
-    }
-
-    std::string Matrix::to_string() const
-    {
-        std::string str;
-
-        for (size_t i = 0; i < m_rows; i++)
-        {
-            for (size_t j = 0; j < m_columns; ++j)
-            {
-                str += std::format("{:.1f}", at(i, j));
-
-                if (j == m_columns - 1)
-                    str += '\n';
-                else
-                    str += ' ';
-            }
-        }
-        return str;
-    }
-
-    float Matrix::determinant() const // NOLINT(*-no-recursion)
-    {
-        if (m_rows + m_columns == 2)
-            return at(0, 0);
-
-        if (m_rows == 2 and m_columns == 2)
-            return at(0, 0) * at(1, 1) - at(0, 1) * at(1, 0);
-
-        float det = 0;
-        for (size_t i = 0; i < m_columns; i++)
-            det += alg_complement(0, i) * at(0, i);
-
-        return det;
-    }
-
-    float Matrix::alg_complement(const size_t i, const size_t j) const // NOLINT(*-no-recursion)
-    {
-        const auto tmp = minor(i, j);
-        return ((i + j + 2) % 2 == 0) ? tmp : -tmp;
-    }
-
-    Matrix Matrix::transpose() const
-    {
-        Matrix transposed = {m_columns, m_rows};
-
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                transposed.at(j, i) = at(i, j);
-
-        return transposed;
-    }
-
-    Matrix::~Matrix() = default;
-
-    void Matrix::set(const float val)
-    {
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                at(i, j) = val;
-    }
-
-    Matrix Matrix::strip(const size_t row, const size_t column) const
-    {
-        Matrix stripped = {m_rows - 1, m_columns - 1};
-        size_t strip_row_index = 0;
-
-        for (size_t i = 0; i < m_rows; i++)
-        {
-            if (i == row)
-                continue;
-
-            size_t strip_column_index = 0;
-            for (size_t j = 0; j < m_columns; ++j)
-            {
-                if (j == column)
-                    continue;
-
-                stripped.at(strip_row_index, strip_column_index) = at(i, j);
-                strip_column_index++;
-            }
-
-            strip_row_index++;
-        }
-
-        return stripped;
-    }
-
-    float Matrix::minor(const size_t i, const size_t j) const // NOLINT(*-no-recursion)
-    {
-        return strip(i, j).determinant();
-    }
-
-    Matrix Matrix::to_screen_matrix(const float screen_width, const float screen_height)
-    {
-        return {
-                {screen_width / 2.f, 0.f, 0.f, 0.f},
-                {0.f, -screen_height / 2.f, 0.f, 0.f},
-                {0.f, 0.f, 1.f, 0.f},
-                {screen_width / 2.f, screen_height / 2.f, 0.f, 1.f},
-        };
-    }
-
-    Matrix Matrix::translation_matrix(const Vector3<float>& diff)
-    {
-        return {
-                {1.f, 0.f, 0.f, 0.f},
-                {0.f, 1.f, 0.f, 0.f},
-                {0.f, 0.f, 1.f, 0.f},
-                {diff.x, diff.y, diff.z, 1.f},
-        };
-    }
-
-    Matrix Matrix::orientation_matrix(const Vector3<float>& forward, const Vector3<float>& right,
-                                      const Vector3<float>& up)
-    {
-        return {
-                {right.x, up.x, forward.x, 0.f},
-                {right.y, up.y, forward.y, 0.f},
-                {right.z, up.z, forward.z, 0.f},
-                {0.f, 0.f, 0.f, 1.f},
-        };
-    }
-
-    Matrix Matrix::projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                     const float far)
-    {
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
-
-        return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
-                {0.f, 1.f / fov_half_tan, 0.f, 0.f},
-                {0.f, 0.f, (far + near) / (far - near), 2.f * near * far / (far - near)},
-                {0.f, 0.f, -1.f, 0.f}};
-    }
-
-    const float* Matrix::raw() const
-    {
-        return m_data.get();
-    }
-
-    void Matrix::set_data_from_raw(const float* raw_matrix)
-    {
-        for (size_t i = 0; i < m_columns * m_rows; ++i)
-            at(i / m_rows, i % m_columns) = raw_matrix[i];
-    }
-
-    Matrix::Matrix()
-    {
-        m_columns = 0;
-        m_rows = 0;
-        m_data = nullptr;
-    }
-} // namespace omath
-#endif

tests/CMakeLists.txt

@@ -11,8 +11,6 @@ set_target_properties(unit_tests PROPERTIES
         ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
         RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
-        UNITY_BUILD ON
-        UNITY_BUILD_BATCH_SIZE 20
         CXX_STANDARD 23
         CXX_STANDARD_REQUIRED ON)
 

tests/engines/unit_test_iw_engine.cpp

@@ -5,7 +5,7 @@
 #include <omath/engines/iw_engine/camera.hpp>
 #include <omath/engines/iw_engine/constants.hpp>
 #include <omath/engines/iw_engine/formulas.hpp>
-
+#include <random>
 
 TEST(unit_test_iw_engine, ForwardVector)
 {
@@ -68,7 +68,6 @@ TEST(unit_test_iw_engine, ProjectTargetMovedFromCamera)
     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.world_to_screen({distance, 0, 0});
@@ -102,4 +101,126 @@ TEST(unit_test_iw_engine, CameraSetAndGetOrigin)
     cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
     EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
+}
+
+TEST(unit_test_iw_engine, loook_at_random_all_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), dist(gen), dist(gen)};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.001f || std::abs(projected_pos->y - 0.f) >= 0.001f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_iw_engine, loook_at_random_x_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.f);
+
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::iw_engine::Camera({dist(gen), dist(gen), dist(gen)}, {}, {1920.f, 1080.f}, fov, 0.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), 0.f, 0.f};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_iw_engine, loook_at_random_y_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, dist(gen), 0.f};
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_iw_engine, loook_at_random_z_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, 0.f, dist(gen)};
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.025f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
 }

tests/engines/unit_test_open_gl.cpp

@@ -5,7 +5,7 @@
 #include <omath/engines/opengl_engine/camera.hpp>
 #include <omath/engines/opengl_engine/constants.hpp>
 #include <omath/engines/opengl_engine/formulas.hpp>
-
+#include <random>
 
 TEST(unit_test_opengl, ForwardVector)
 {
@@ -29,7 +29,7 @@ TEST(unit_test_opengl, ForwardVectorRotationYaw)
 {
     omath::opengl_engine::ViewAngles angles;
 
-    angles.yaw = omath::opengl_engine::YawAngle::from_degrees(90.f);
+    angles.yaw = omath::opengl_engine::YawAngle::from_degrees(-90.f);
 
     const auto forward = omath::opengl_engine::forward_vector(angles);
     EXPECT_NEAR(forward.x, omath::opengl_engine::k_abs_right.x, 0.00001f);
@@ -37,13 +37,11 @@ TEST(unit_test_opengl, ForwardVectorRotationYaw)
     EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_right.z, 0.00001f);
 }
 
-
-
 TEST(unit_test_opengl, ForwardVectorRotationPitch)
 {
     omath::opengl_engine::ViewAngles angles;
 
-    angles.pitch = omath::opengl_engine::PitchAngle::from_degrees(-90.f);
+    angles.pitch = omath::opengl_engine::PitchAngle::from_degrees(90.f);
 
     const auto forward = omath::opengl_engine::forward_vector(angles);
     EXPECT_NEAR(forward.x, omath::opengl_engine::k_abs_up.x, 0.00001f);
@@ -68,7 +66,6 @@ TEST(unit_test_opengl, ProjectTargetMovedFromCamera)
     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.world_to_screen({0, 0, distance});
@@ -102,4 +99,123 @@ TEST(unit_test_opengl, CameraSetAndGetOrigin)
     cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
     EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
+}
+TEST(unit_test_opengl_engine, loook_at_random_all_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), dist(gen), dist(gen)};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.0001f || std::abs(projected_pos->y - 0.f) >= 0.0001f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_opengl_engine, loook_at_random_x_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), 0.f, 0.f};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_opengl_engine, loook_at_random_y_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, dist(gen), 0.f};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_opengl_engine, loook_at_random_z_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, 0.f, dist(gen)};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
 }

tests/engines/unit_test_source_engine.cpp

@@ -5,7 +5,7 @@
 #include <omath/engines/source_engine/camera.hpp>
 #include <omath/engines/source_engine/constants.hpp>
 #include <omath/engines/source_engine/formulas.hpp>
-
+#include <random>
 
 TEST(unit_test_source_engine, ForwardVector)
 {
@@ -68,7 +68,6 @@ TEST(unit_test_source_engine, ProjectTargetMovedFromCamera)
     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.world_to_screen({distance, 0, 0});
@@ -122,4 +121,125 @@ TEST(unit_test_source_engine, CameraSetAndGetOrigin)
     cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
     EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
+}
+
+TEST(unit_test_source_engine, loook_at_random_all_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), dist(gen), dist(gen)};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.0001f || std::abs(projected_pos->y - 0.f) >= 0.0001f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_source_engine, loook_at_random_x_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), 0.f, 0.f};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_source_engine, loook_at_random_y_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, dist(gen), 0.f};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_source_engine, loook_at_random_z_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, 0.f, dist(gen)};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.025f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
 }

tests/engines/unit_test_unity_engine.cpp

@@ -6,6 +6,7 @@
 #include <omath/engines/unity_engine/constants.hpp>
 #include <omath/engines/unity_engine/formulas.hpp>
 #include <print>
+#include <random>
 
 TEST(unit_test_unity_engine, ForwardVector)
 {
@@ -68,7 +69,6 @@ TEST(unit_test_unity_engine, ProjectTargetMovedFromCamera)
     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.world_to_screen({0, 0, distance});
@@ -112,4 +112,125 @@ TEST(unit_test_unity_engine, CameraSetAndGetOrigin)
     cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
     EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
+}
+TEST(unit_test_unity_engine, loook_at_random_all_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), dist(gen), dist(gen)};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.0001f || std::abs(projected_pos->y - 0.f) >= 0.0001f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_unity_engine, loook_at_random_x_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), 0.f, 0.f};
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.001f || std::abs(projected_pos->y - 0.f) >= 0.001f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_unity_engine, loook_at_random_y_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, dist(gen), 0.f};
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_unity_engine, loook_at_random_z_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.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.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, 0.f, dist(gen)};
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
 }

tests/engines/unit_test_unreal_engine.cpp

@@ -6,6 +6,7 @@
 #include <omath/engines/unreal_engine/constants.hpp>
 #include <omath/engines/unreal_engine/formulas.hpp>
 #include <print>
+#include <random>
 
 TEST(unit_test_unreal_engine, ForwardVector)
 {
@@ -68,7 +69,6 @@ TEST(unit_test_unreal_engine, ProjectTargetMovedFromCamera)
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
     const auto cam = omath::unreal_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.world_to_screen({distance, 0, 0});
@@ -102,4 +102,128 @@ TEST(unit_test_unreal_engine, CameraSetAndGetOrigin)
     cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
     EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
+}
+
+TEST(unit_test_unreal_engine, loook_at_random_all_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.f);
+
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::unreal_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.001f, 10000.f);
+
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 100; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), dist(gen), dist(gen)};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.0001f || std::abs(projected_pos->y - 0.f) >= 0.0001f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_unreal_engine, loook_at_random_x_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.f);
+
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::unreal_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), dist(gen), dist(gen)};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_unreal_engine, loook_at_random_y_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.f);
+
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::unreal_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, dist(gen), 0.f};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_unreal_engine, loook_at_random_z_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.f);
+
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::unreal_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, 0.f, dist(gen)};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
 }

tests/general/unit_test_angle.cpp

@@ -1,3 +1,192 @@
 //
 // Created by Orange on 11/30/2024.
 //
+
+#include <cmath>
+#include <gtest/gtest.h>
+#include <numbers>
+#include <omath/angle.hpp>
+
+using namespace omath;
+
+namespace
+{
+
+    // Handy aliases (defaults: Type=float, [0,360], Normalized)
+    using Deg = Angle<float, float(0), float(360), AngleFlags::Normalized>;
+    using Pitch = Angle<float, float(-90), float(90), AngleFlags::Clamped>;
+    using Turn = Angle<float, float(-180), float(180), AngleFlags::Normalized>;
+
+    constexpr float kEps = 1e-5f;
+
+} // namespace
+
+// ---------- Construction / factories ----------
+
+TEST(UnitTestAngle, DefaultConstructor_IsZeroDegrees)
+{
+    Deg a; // default ctor
+    EXPECT_FLOAT_EQ(*a, 0.0f);
+    EXPECT_FLOAT_EQ(a.as_degrees(), 0.0f);
+}
+
+TEST(UnitTestAngle, FromDegrees_Normalized_WrapsAboveMax)
+{
+    const Deg a = Deg::from_degrees(370.0f);
+    EXPECT_FLOAT_EQ(a.as_degrees(), 10.0f);
+}
+
+TEST(UnitTestAngle, FromDegrees_Normalized_WrapsBelowMin)
+{
+    const Deg a = Deg::from_degrees(-10.0f);
+    EXPECT_FLOAT_EQ(a.as_degrees(), 350.0f);
+}
+
+TEST(UnitTestAngle, FromDegrees_Clamped_ClampsToRange)
+{
+    const Pitch hi = Pitch::from_degrees(100.0f);
+    const Pitch lo = Pitch::from_degrees(-120.0f);
+
+    EXPECT_FLOAT_EQ(hi.as_degrees(), 90.0f);
+    EXPECT_FLOAT_EQ(lo.as_degrees(), -90.0f);
+}
+
+TEST(UnitTestAngle, FromRadians_And_AsRadians)
+{
+    const Deg a = Deg::from_radians(std::numbers::pi_v<float>);
+    EXPECT_FLOAT_EQ(a.as_degrees(), 180.0f);
+
+    const Deg b = Deg::from_degrees(180.0f);
+    EXPECT_NEAR(b.as_radians(), std::numbers::pi_v<float>, 1e-6f);
+}
+
+// ---------- Unary minus & deref ----------
+
+TEST(UnitTestAngle, UnaryMinus_Normalized)
+{
+    const Deg a = Deg::from_degrees(30.0f);
+    const Deg b = -a; // wraps to 330 in [0,360)
+    EXPECT_FLOAT_EQ(b.as_degrees(), 330.0f);
+}
+
+TEST(UnitTestAngle, DereferenceReturnsDegrees)
+{
+    const Deg a = Deg::from_degrees(42.0f);
+    EXPECT_FLOAT_EQ(*a, 42.0f);
+}
+
+// ---------- Trigonometric helpers ----------
+
+TEST(UnitTestAngle, SinCosTanCot_BasicCases)
+{
+    const Deg a0 = Deg::from_degrees(0.0f);
+    EXPECT_NEAR(a0.sin(), 0.0f, kEps);
+    EXPECT_NEAR(a0.cos(), 1.0f, kEps);
+    // cot(0) -> cos/sin -> div by 0: allow inf or nan
+    const float cot0 = a0.cot();
+    EXPECT_TRUE(std::isinf(cot0) || std::isnan(cot0));
+
+    const Deg a45 = Deg::from_degrees(45.0f);
+    EXPECT_NEAR(a45.tan(), 1.0f, 1e-4f);
+    EXPECT_NEAR(a45.cot(), 1.0f, 1e-4f);
+
+    const Deg a90 = Deg::from_degrees(90.0f);
+    EXPECT_NEAR(a90.sin(), 1.0f, 1e-4f);
+    EXPECT_NEAR(a90.cos(), 0.0f, 1e-4f);
+}
+
+TEST(UnitTestAngle, Atan_IsAtanOfRadians)
+{
+    // atan(as_radians). For 0° -> atan(0)=0.
+    const Deg a0 = Deg::from_degrees(0.0f);
+    EXPECT_NEAR(a0.atan(), 0.0f, kEps);
+
+    const Deg a45 = Deg::from_degrees(45.0f);
+    // atan(pi/4) ≈ 0.665773...
+    EXPECT_NEAR(a45.atan(), 0.66577375f, 1e-6f);
+}
+
+// ---------- Compound arithmetic ----------
+
+TEST(UnitTestAngle, PlusEquals_Normalized_Wraps)
+{
+    Deg a = Deg::from_degrees(350.0f);
+    a += Deg::from_degrees(20.0f); // 370 -> 10
+    EXPECT_FLOAT_EQ(a.as_degrees(), 10.0f);
+}
+
+TEST(UnitTestAngle, MinusEquals_Normalized_Wraps)
+{
+    Deg a = Deg::from_degrees(10.0f);
+    a -= Deg::from_degrees(30.0f); // -20 -> 340
+    EXPECT_FLOAT_EQ(a.as_degrees(), 340.0f);
+}
+
+TEST(UnitTestAngle, PlusEquals_Clamped_Clamps)
+{
+    Pitch p = Pitch::from_degrees(80.0f);
+    p += Pitch::from_degrees(30.0f); // 110 -> clamp to 90
+    EXPECT_FLOAT_EQ(p.as_degrees(), 90.0f);
+}
+
+TEST(UnitTestAngle, MinusEquals_Clamped_Clamps)
+{
+    Pitch p = Pitch::from_degrees(-70.0f);
+    p -= Pitch::from_degrees(40.0f); // -110 -> clamp to -90
+    EXPECT_FLOAT_EQ(p.as_degrees(), -90.0f);
+}
+
+// ---------- Alternative ranges ----------
+
+TEST(UnitTestAngle, NormalizedRange_Neg180To180)
+{
+    const Turn a = Turn::from_degrees(190.0f); // -> -170
+    const Turn b = Turn::from_degrees(-190.0f); // -> 170
+
+    EXPECT_FLOAT_EQ(a.as_degrees(), -170.0f);
+    EXPECT_FLOAT_EQ(b.as_degrees(), 170.0f);
+}
+
+// ---------- Comparisons (via <=>) ----------
+
+TEST(UnitTestAngle, Comparisons_WorkWithPartialOrdering)
+{
+    const Deg a = Deg::from_degrees(10.0f);
+    const Deg b = Deg::from_degrees(20.0f);
+    const Deg c = Deg::from_degrees(10.0f);
+
+    EXPECT_TRUE(a < b);
+    EXPECT_TRUE(b > a);
+    EXPECT_TRUE(a <= c);
+    EXPECT_TRUE(c >= a);
+}
+
+// ---------- std::format formatter ----------
+
+TEST(UnitTestAngle, Formatter_PrintsDegreesWithSuffix)
+{
+    const Deg a = Deg::from_degrees(15.0f);
+    EXPECT_EQ(std::format("{}", a), "15deg");
+
+    const Deg b = Deg::from_degrees(10.5f);
+    EXPECT_EQ(std::format("{}", b), "10.5deg");
+
+    const Turn t = Turn::from_degrees(-170.0f);
+    EXPECT_EQ(std::format("{}", t), "-170deg");
+}
+
+TEST(UnitTestAngle, BinaryPlus_ReturnsWrappedSum)
+{
+    Angle<> a = Deg::from_degrees(350.0f);
+    const Deg b = Deg::from_degrees(20.0f);
+    const Deg c = a + b; // expect 10°
+    EXPECT_FLOAT_EQ(c.as_degrees(), 10.0f);
+}
+
+TEST(UnitTestAngle, BinaryMinus_ReturnsWrappedDiff)
+{
+    Angle<> a = Deg::from_degrees(10.0f);
+    const Deg b = Deg::from_degrees(30.0f);
+    const Deg c = a - b; // expect 340°
+    EXPECT_FLOAT_EQ(c.as_degrees(), 340.0f);
+}

tests/general/unit_test_matrix.cpp

@@ -1,184 +0,0 @@
-//
-// Created by vlad on 5/18/2024.
-//
-
-#ifdef OMATH_ENABLE_LEGACY
-
-#include <gtest/gtest.h>
-#include <omath/matrix.hpp>
-#include "omath/vector3.hpp"
-
-using namespace omath;
-
-
-class UnitTestMatrix : public ::testing::Test
-{
-protected:
-    Matrix m1;
-    Matrix m2;
-
-    void SetUp() override
-    {
-        m1 = Matrix(2, 2);
-        m2 = Matrix{{1.0f, 2.0f}, {3.0f, 4.0f}};
-    }
-};
-
-// Test constructors
-TEST_F(UnitTestMatrix, Constructor_Size)
-{
-    const Matrix m(3, 3);
-    EXPECT_EQ(m.row_count(), 3);
-    EXPECT_EQ(m.columns_count(), 3);
-}
-
-TEST_F(UnitTestMatrix, Operator_SquareBrackets)
-{
-    EXPECT_EQ((m2[0, 0]), 1.0f);
-    EXPECT_EQ((m2[0, 1]), 2.0f);
-    EXPECT_EQ((m2[1, 0]), 3.0f);
-    EXPECT_EQ((m2[1, 1]), 4.0f);
-}
-
-
-TEST_F(UnitTestMatrix, Constructor_InitializerList)
-{
-    Matrix m{{1.0f, 2.0f}, {3.0f, 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.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.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.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);
-}
-
-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)
-{
-    const float det = m2.determinant();
-    EXPECT_FLOAT_EQ(det, -2.0f);
-}
-
-TEST_F(UnitTestMatrix, Minor)
-{
-    const float minor = m2.minor(0, 0);
-    EXPECT_FLOAT_EQ(minor, 4.0f);
-}
-
-TEST_F(UnitTestMatrix, AlgComplement)
-{
-    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.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::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);
-}
-
-TEST_F(UnitTestMatrix, 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);
-}
-
-TEST_F(UnitTestMatrix, ToString)
-{
-    const std::string str = m2.to_string();
-    EXPECT_FALSE(str.empty());
-}
-
-// Test assignment operators
-TEST_F(UnitTestMatrix, AssignmentOperator_Copy)
-{
-    Matrix m3(2, 2);
-    m3 = m2;
-    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.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);
-}
-#endif

tests/general/unit_test_projection.cpp

@@ -13,8 +13,12 @@ TEST(UnitTestProjection, Projection)
     const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
                                                   0.01f, 1000.f);
 
-    const auto projected = cam.world_to_screen({1000, 0, 50});
+    const auto projected = cam.world_to_screen({1000.f, 0, 50.f});
+    const auto result = cam.screen_to_world(projected.value());
+    const auto result2 = cam.world_to_screen(result.value());
 
+    EXPECT_EQ(static_cast<omath::Vector2<float>>(projected.value()),
+              static_cast<omath::Vector2<float>>(result2.value()));
     EXPECT_NEAR(projected->x, 960.f, 0.001f);
     EXPECT_NEAR(projected->y, 504.f, 0.001f);
     EXPECT_NEAR(projected->z, 1.f, 0.001f);