Merge pull request #77 from orange-cpp/feature/formating_improvement

Feature/formating improvement
added plane header
2026-06-09 08:44:35 +00:00 · 2025-09-25 22:03:47 +03:00 · 2025-09-25 21:59:59 +03:00 · 2025-09-25 21:57:05 +03:00 · 2025-09-25 21:55:56 +03:00 · 2025-09-25 21:43:33 +03:00
56 changed files with 1508 additions and 848 deletions
@@ -35,11 +35,11 @@ jobs:
      - name: Configure (cmake --preset)
        shell: bash
-        run: cmake --preset linux-release -DOMATH_BUILD_TESTS=ON
+        run: cmake --preset linux-release -DOMATH_BUILD_TESTS=ON -DOMATH_BUILD_BENCHMARK=OFF
      - name: Build
        shell: bash
-        run: cmake --build cmake-build/build/linux-release --target all
+        run: cmake --build cmake-build/build/linux-release --target unit_tests omath
      - name: Run unit_tests
        shell: bash
@@ -68,11 +68,11 @@ jobs:
      - name: Configure (cmake --preset)
        shell: bash
-        run: cmake --preset windows-release -DOMATH_BUILD_TESTS=ON
+        run: cmake --preset windows-release -DOMATH_BUILD_TESTS=ON -DOMATH_BUILD_BENCHMARK=OFF
      - name: Build
        shell: bash
-        run: cmake --build cmake-build/build/windows-release --target all
+        run: cmake --build cmake-build/build/windows-release --target unit_tests omath
      - name: Run unit_tests.exe
        shell: bash
@@ -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
@@ -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>
@@ -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}")
@@ -37,6 +39,7 @@ else ()
    add_library(${PROJECT_NAME} STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
 endif ()
 add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
 target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_VERSION="${PROJECT_VERSION}")
@@ -90,16 +93,22 @@ if (OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
    )
 endif ()
-if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+if (OMATH_USE_AVX2 AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    target_compile_options(${PROJECT_NAME} PRIVATE -mavx2 -mfma)
+    target_compile_options(${PROJECT_NAME} PUBLIC -mavx2 -mavx -mfma)
 endif ()
 target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_23)
 add_subdirectory(extlibs)
 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)
@@ -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>
@@ -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.
@@ -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
@@ -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`
@@ -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)
@@ -0,0 +1,65 @@
 //
 // Created by Vlad on 9/17/2025.
 //
 #include <benchmark/benchmark.h>
 #include <omath/omath.hpp>
 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 ([[maybe_unused]] const 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 ([[maybe_unused]] const 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 ([[maybe_unused]] const 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 ([[maybe_unused]] const 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);
@@ -0,0 +1,23 @@
 //
 // Created by Vlad on 9/18/2025.
 //
 #include <benchmark/benchmark.h>
 #include <omath/omath.hpp>
 using namespace omath;
 using namespace omath::projectile_prediction;
 constexpr float simulation_time_step = 1.f / 1000.f;
 constexpr float hit_distance_tolerance = 5.f;
 void source_engine_projectile_prediction(benchmark::State& state)
 {
    constexpr Target target{.m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
    constexpr Projectile projectile = {.m_origin = {3, 2, 1}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
    for ([[maybe_unused]] const auto _: state)
        std::ignore = ProjPredEngineLegacy(400, simulation_time_step, 50, hit_distance_tolerance)
                              .maybe_calculate_aim_point(projectile, target);
 }
 BENCHMARK(source_engine_projectile_prediction)->Iterations(10'000);
@@ -0,0 +1,5 @@
 //
 // Created by Vlad on 9/17/2025.
 //
 #include <benchmark/benchmark.h>
 BENCHMARK_MAIN();
@@ -1 +1,9 @@
-add_subdirectory(googletest)
+
 if (OMATH_BUILD_TESTS)
    add_subdirectory(googletest)
 endif ()
 if (OMATH_BUILD_BENCHMARK)
    set(BENCHMARK_ENABLE_TESTING OFF)
    add_subdirectory(benchmark)
 endif ()
@@ -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,62 @@ 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();
    }
    template<class FormatContext>
    [[nodiscard]]
-    static auto format(const omath::Angle<Type, min, max, flags>& deg, std::format_context& ctx)
+    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>
    [[nodiscard]]
    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());
    }
 };
 // wchar_t formatter
 template<class T, T MinV, T MaxV, omath::AngleFlags F>
 struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char8_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>
    [[nodiscard]]
    auto format(const AngleT& a, FormatContext& ctx) const
    {
        static_assert(std::is_same_v<typename FormatContext::char_type, char8_t>);
        return std::format_to(ctx.out(), u8"{}deg", a.as_degrees());
    }
 };
@@ -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)
@@ -164,6 +164,26 @@ namespace omath
            return {to_im_vec4()};
        }
 #endif
        [[nodiscard]] std::string to_string() const noexcept
        {
            return std::format("[r:{}, g:{}, b:{}, a:{}]",
                            static_cast<int>(x * 255.f),
                            static_cast<int>(y * 255.f),
                            static_cast<int>(z * 255.f),
                            static_cast<int>(w * 255.f));
        }
        [[nodiscard]] std::wstring to_wstring() const noexcept
        {
            const auto ascii_string = to_string();
            return {ascii_string.cbegin(), ascii_string.cend()};
        }
        // ReSharper disable once CppInconsistentNaming
        [[nodiscard]] std::u8string to_u8string() const noexcept
        {
            const auto ascii_string = to_string();
            return {ascii_string.cbegin(), ascii_string.cend()};
        }
    };
 } // namespace omath
 template<>
@@ -174,13 +194,19 @@ struct std::formatter<omath::Color> // NOLINT(*-dcl58-cpp)
    {
        return ctx.begin();
    }
    template<class FormatContext>
    [[nodiscard]]
-    static auto format(const omath::Color& col, std::format_context& ctx)
+    static auto format(const omath::Color& col, FormatContext& ctx)
    {
-        return std::format_to(ctx.out(), "[r:{}, g:{}, b:{}, a:{}]",
+        if constexpr (std::is_same_v<typename FormatContext::char_type, char>)
-            static_cast<int>(col.x * 255.f),
+            return std::format_to(ctx.out(), "{}", col.to_string());
-            static_cast<int>(col.y * 255.f),
+        if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
-            static_cast<int>(col.z * 255.f),
+            return std::format_to(ctx.out(), L"{}", col.to_wstring());
-            static_cast<int>(col.w * 255.f));
+
        if constexpr (std::is_same_v<typename FormatContext::char_type, char8_t>)
            return std::format_to(ctx.out(), u8"{}", col.to_u8string());
        return std::unreachable();
    }
 };
@@ -62,17 +62,15 @@ namespace omath::opengl_engine
        [[nodiscard]]
        static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
        {
-            const auto distance = origin.distance_to(view_to);
+            const auto direction = (view_to - origin).normalized();
-            const auto delta = view_to - origin;
+            return angles::radians_to_degrees(std::asin(direction.y));
            return angles::radians_to_degrees(std::asin(delta.y / distance));
        }
        [[nodiscard]]
        static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
        {
-            const auto delta = view_to - origin;
+            const auto direction = (view_to - origin).normalized();
-            return angles::radians_to_degrees(std::atan2(delta.z, delta.x));
+            return angles::radians_to_degrees(-std::atan2(direction.x, -direction.z));
        };
    };
 } // namespace omath::opengl_engine
@@ -62,17 +62,15 @@ namespace omath::unity_engine
        [[nodiscard]]
        static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
        {
-            const auto distance = origin.distance_to(view_to);
+            const auto direction = (view_to - origin).normalized();
-            const auto delta = view_to - origin;
+            return angles::radians_to_degrees(std::asin(direction.y));
            return angles::radians_to_degrees(std::asin(delta.y / distance));
        }
        [[nodiscard]]
        static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
        {
-            const auto delta = view_to - origin;
+            const auto direction = (view_to - origin).normalized();
-            return angles::radians_to_degrees(std::atan2(delta.z, delta.x));
+            return angles::radians_to_degrees(std::atan2(direction.x, direction.z));
        };
    };
 } // namespace omath::unity_engine
@@ -62,17 +62,16 @@ namespace omath::unreal_engine
        [[nodiscard]]
        static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
        {
-            const auto distance = origin.distance_to(view_to);
+            const auto direction = (view_to - origin).normalized();
            const auto delta = view_to - origin;
-            return angles::radians_to_degrees(std::asin(delta.z / distance));
+            return angles::radians_to_degrees(std::asin(direction.z));
        }
        [[nodiscard]]
        static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
        {
-            const auto delta = view_to - origin;
+            const auto direction = (view_to - origin).normalized();
-            return angles::radians_to_degrees(std::atan2(delta.y, delta.x));
+            return angles::radians_to_degrees(std::atan2(direction.y, direction.x));
        };
    };
 } // namespace omath::unreal_engine
@@ -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;
+#ifdef OMATH_USE_AVX2
-
+            if constexpr (StoreType == MatStoreType::ROW_MAJOR)
-            for (size_t i = 0; i < Rows; ++i)
+                return avx_multiply_row_major(other);
-                for (size_t j = 0; j < OtherColumns; ++j)
+            else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
-                {
+                return avx_multiply_col_major(other);
-                    Type sum = 0;
+#else
-                    for (size_t k = 0; k < Columns; ++k)
+            if constexpr (StoreType == MatStoreType::ROW_MAJOR)
-                        sum += at(i, k) * other.at(k, j);
+                return cache_friendly_multiply_row_major(other);
-                    result.at(i, j) = sum;
+            else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
-                }
+                return cache_friendly_multiply_col_major(other);
-            return result;
+#endif
            else
                std::unreachable();
        }
        constexpr Mat& operator*=(const Type& f) noexcept
@@ -328,6 +328,21 @@ namespace omath
            return oss.str();
        }
        [[nodiscard]]
        std::wstring to_wstring() const noexcept
        {
            const auto ascii_string = to_string();
            return {ascii_string.cbegin(), ascii_string.cend()};
        }
        [[nodiscard]]
        // ReSharper disable once CppInconsistentNaming
        std::u8string to_u8string() const noexcept
        {
            const auto ascii_string = to_string();
            return {ascii_string.cbegin(), ascii_string.cend()};
        }
        [[nodiscard]]
        bool operator==(const Mat& mat) const
        {
@@ -374,6 +389,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];
                        const __m256 bkj_vec = _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);
                            const __m256 a_vec = _mm256_loadu_ps(a_col_k + i);
                            cvec = _mm256_fmadd_ps(a_vec, bkj_vec, 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];
                        const __m256d bkj_vec = _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);
                            const __m256d a_vec = _mm256_loadu_pd(a_col_k + i);
                            cvec = _mm256_fmadd_pd(a_vec, bkj_vec, 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]);
                        const __m256 aik_vec = _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);
                            const __m256 b_vec = _mm256_loadu_ps(b_row + j);
                            cvec = _mm256_fmadd_ps(b_vec, aik_vec, 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]);
                        const __m256d aik_vec = _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);
                            const __m256d b_vec = _mm256_loadu_pd(b_row + j);
                            cvec = _mm256_fmadd_pd(b_vec, aik_vec, 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 +692,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
@@ -519,9 +721,18 @@ struct std::formatter<omath::Mat<Rows, Columns, Type, StoreType>> // NOLINT(*-dc
    {
        return ctx.begin();
    }
    template<class FormatContext>
    [[nodiscard]]
-    static auto format(const MatType& mat, std::format_context& ctx)
+    static auto format(const MatType& mat, FormatContext& ctx)
    {
-        return std::format_to(ctx.out(), "{}", mat.to_string());
+        if constexpr (std::is_same_v<typename FormatContext::char_type, char>)
            return std::format_to(ctx.out(), "{}", mat.to_string());
        if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
            return std::format_to(ctx.out(), L"{}", mat.to_wstring());
        if constexpr (std::is_same_v<typename FormatContext::char_type, char8_t>)
            return std::format_to(ctx.out(), u8"{}", mat.to_u8string());
    }
 };
@@ -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
@@ -242,9 +242,18 @@ struct std::formatter<omath::Vector2<Type>> // NOLINT(*-dcl58-cpp)
    {
        return ctx.begin();
    }
    template<class FormatContext>
    [[nodiscard]]
-    static auto format(const omath::Vector2<Type>& vec, std::format_context& ctx)
+    static auto format(const omath::Vector2<Type>& vec, FormatContext& ctx)
    {
-        return std::format_to(ctx.out(), "[{}, {}]", vec.x, vec.y);
+        if constexpr (std::is_same_v<typename FormatContext::char_type, char>)
            return std::format_to(ctx.out(), "[{}, {}]", vec.x, vec.y);
        if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
            return std::format_to(ctx.out(), L"[{}, {}]", vec.x, vec.y);
        if constexpr (std::is_same_v<typename FormatContext::char_type, char8_t>)
            return std::format_to(ctx.out(), u8"[{}, {}]", vec.x, vec.y);
    }
 };
@@ -303,9 +303,18 @@ struct std::formatter<omath::Vector3<Type>> // NOLINT(*-dcl58-cpp)
    {
        return ctx.begin();
    }
    template<class FormatContext>
    [[nodiscard]]
-    static auto format(const omath::Vector3<Type>& vec, std::format_context& ctx)
+    static auto format(const omath::Vector3<Type>& vec, FormatContext& ctx)
    {
-        return std::format_to(ctx.out(), "[{}, {}, {}]", vec.x, vec.y, vec.z);
+        if constexpr (std::is_same_v<typename FormatContext::char_type, char>)
            return std::format_to(ctx.out(), "[{}, {}, {}]", vec.x, vec.y, vec.z);
        if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
            return std::format_to(ctx.out(), L"[{}, {}, {}]", vec.x, vec.y, vec.z);
        if constexpr (std::is_same_v<typename FormatContext::char_type, char8_t>)
            return std::format_to(ctx.out(), u8"[{}, {}, {}]", vec.x, vec.y, vec.z);
    }
 };
@@ -210,9 +210,17 @@ struct std::formatter<omath::Vector4<Type>> // NOLINT(*-dcl58-cpp)
    {
        return ctx.begin();
    }
    template<class FormatContext>
    [[nodiscard]]
-    static auto format(const omath::Vector4<Type>& vec, std::format_context& ctx)
+    static auto format(const omath::Vector4<Type>& vec, FormatContext& ctx)
    {
-        return std::format_to(ctx.out(), "[{}, {}, {}, {}]", vec.x, vec.y, vec.z, vec.w);
+        if constexpr (std::is_same_v<typename FormatContext::char_type, char>)
            return std::format_to(ctx.out(), "[{}, {}, {}, {}]", vec.x, vec.y, vec.z, vec.w);
        if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
            return std::format_to(ctx.out(), L"[{}, {}, {}, {}]", vec.x, vec.y, vec.z, vec.w);
        if constexpr (std::is_same_v<typename FormatContext::char_type, char8_t>)
            return std::format_to(ctx.out(), u8"[{}, {}, {}, {}]", vec.x, vec.y, vec.z, vec.w);
    }
 };
@@ -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
@@ -27,6 +26,7 @@
 // 3D primitives
 #include "omath/3d_primitives/box.hpp"
 #include "omath/3d_primitives/plane.hpp"
 // Collision detection
 #include "omath/collision/line_tracer.hpp"
@@ -81,4 +81,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"
@@ -4,8 +4,8 @@
 #pragma once
 #include "omath/linear_algebra/vector3.hpp"
 #include "omath/engines/source_engine/traits/pred_engine_trait.hpp"
 #include "omath/linear_algebra/vector3.hpp"
 #include "omath/projectile_prediction/proj_pred_engine.hpp"
 #include "omath/projectile_prediction/projectile.hpp"
 #include "omath/projectile_prediction/target.hpp"
@@ -20,7 +20,9 @@ namespace omath::projectile_prediction
                     Vector3<float> v3, // by-value for calc_viewpoint_from_angles
                     float pitch, float yaw, float time, float gravity, std::optional<float> maybe_pitch) {
                // Presence + return types
-                { T::predict_projectile_position(projectile, pitch, yaw, time, gravity) } -> std::same_as<Vector3<float>>;
+                {
                    T::predict_projectile_position(projectile, pitch, yaw, time, gravity)
                } -> std::same_as<Vector3<float>>;
                { T::predict_target_position(target, time, gravity) } -> std::same_as<Vector3<float>>;
                { T::calc_vector_2d_distance(vec_a) } -> std::same_as<float>;
                { T::get_vector_height_coordinate(vec_b) } -> std::same_as<float>;
@@ -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
+                                |        y
-                1   |
+                            1   |
-                    |
+                                |
-                    |
+                                |
-        -1 ---------0--------- 1  --> x
+                    -1 ---------0--------- 1  --> x
-                    |
+                                |
-                    |
+                                |
-               -1   |
+                           -1   |
-                    v
+                                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
@@ -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,
    };
 }
@@ -50,12 +50,10 @@ namespace omath::collision
        const auto t_hit = side_b.dot(q) * inv_det;
-        if (ray.infinite_length)
+        if (ray.infinite_length && t_hit <= k_epsilon)
-        {
+            return ray.end;
-            if (t_hit <= k_epsilon)
+
-                return ray.end;
+        if (t_hit <= k_epsilon || t_hit > 1.0f - k_epsilon)
        }
        else if (t_hit <= k_epsilon || t_hit > 1.0f - k_epsilon)
            return ray.end;
        return ray.start + ray_dir * t_hit;
@@ -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 direction = (look_at - cam_origin).normalized();
        const auto delta = cam_origin - look_at;
-        return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
+        return {PitchAngle::from_radians(-std::asin(direction.z)),
-                YawAngle::from_radians(std::atan2(delta.y, delta.x)), RollAngle::from_radians(0.f)};
+                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
    {
@@ -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),
+        return mat_look_at_right_handed(cam_origin, cam_origin+forward_vector(angles), up_vector(angles));
                                                                  up_vector(angles), cam_origin);
    }
    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
    {
-        return mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch)
+        return mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll)
-               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw)
+               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(angles.yaw)
-               * mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
+               * 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
@@ -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 direction = (look_at - cam_origin).normalized();
        const auto delta = cam_origin - look_at;
-        return {PitchAngle::from_radians(-std::asin(delta.y / distance)),
+        return {PitchAngle::from_radians(std::asin(direction.y)),
-                YawAngle::from_radians(std::atan2(delta.z, delta.x)), RollAngle::from_radians(0.f)};
+                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
    {
@@ -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 direction = (look_at - cam_origin).normalized();
        const auto delta = cam_origin - look_at;
-        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
    {
@@ -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
@@ -8,11 +8,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 direction = (look_at - cam_origin).normalized();
        const auto delta = cam_origin - look_at;
-        return {PitchAngle::from_radians(-std::asin(delta.y / distance)),
+        return {PitchAngle::from_radians(-std::asin(direction.y)),
-                YawAngle::from_radians(std::atan2(delta.z, delta.x)), RollAngle::from_radians(0.f)};
+                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
    {
@@ -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
@@ -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 direction = (look_at - cam_origin).normalized();
        const auto delta = cam_origin - look_at;
-        return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
+        return {PitchAngle::from_radians(-std::asin(direction.z)),
-                YawAngle::from_radians(std::atan2(delta.x, delta.y)), RollAngle::from_radians(0.f)};
+                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
    {
@@ -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
@@ -7,12 +7,10 @@ include(GoogleTest)
 file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
 add_executable(${PROJECT_NAME} ${UNIT_TESTS_SOURCES})
-set_target_properties(unit_tests PROPERTIES
+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}"
        UNITY_BUILD ON
        UNITY_BUILD_BATCH_SIZE 20
        CXX_STANDARD 23
        CXX_STANDARD_REQUIRED ON)
@@ -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);
 }
@@ -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);
 }
@@ -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);
 }
@@ -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);
 }
@@ -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);
 }
@@ -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);
 }
@@ -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
@@ -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);
Author	SHA1	Message	Date
orange	eb6f0302a9	Merge pull request #77 from orange-cpp/feature/formating_improvement Feature/formating improvement	2025-09-25 22:03:47 +03:00
orange	5ad1d763bb	added plane header	2025-09-25 21:59:59 +03:00
orange	cc68d4e2b7	fix	2025-09-25 21:57:05 +03:00
orange	899a9825a0	decomposed formatter	2025-09-25 21:55:56 +03:00
orange	800435b407	improvement	2025-09-25 21:43:33 +03:00
orange	0a72f8541a	improved encoding for formating	2025-09-25 21:06:46 +03:00
orange	a5ed088ce0	imprvoed code style	2025-09-25 19:33:06 +03:00
orange	1e0cec2762	Merge pull request #76 from orange-cpp/bugfix/projectile_pred projectile pred look at fix	2025-09-22 02:43:04 +03:00
orange	423dca43e4	fix	2025-09-22 02:41:12 +03:00
orange	7318644027	ooops	2025-09-22 02:39:50 +03:00
orange	0515018605	added targets specification to ci cd build	2025-09-22 02:38:25 +03:00
orange	152eafb78f	disable benchmark build for CI/CD	2025-09-22 02:34:52 +03:00
orange	f8beaa4bab	added source engine benchmark	2025-09-22 02:29:36 +03:00
orange	614e5ebb35	unreal engine fix	2025-09-22 02:12:20 +03:00
orange	36e4cef2f3	fix unity	2025-09-22 02:10:33 +03:00
orange	577afd4d4a	opengl fix	2025-09-22 02:08:58 +03:00
orange	aebb29d773	Merge pull request #75 from orange-cpp/bugfix/fix_look_at Bugfix/fix look at	2025-09-20 17:12:16 +03:00
orange	3c81aea2ca	unified look at for source iw_engine	2025-09-20 17:09:13 +03:00
orange	32d88f0881	improved tests	2025-09-20 17:00:49 +03:00
orange	15898e9b3d	improved opengl tests stability	2025-09-20 16:36:05 +03:00
orange	e37fefae23	improved test stability	2025-09-20 16:34:44 +03:00
orange	f8f3f2c45d	fixed test	2025-09-20 16:22:24 +03:00
orange	aee78d7671	added more iterations	2025-09-20 16:08:04 +03:00
orange	eb443d533c	style fix	2025-09-20 16:00:30 +03:00
orange	5466638330	fixed unreal	2025-09-20 15:59:43 +03:00
orange	19350b2618	fixed unity	2025-09-20 15:54:48 +03:00
orange	53b495a413	fixed opengl	2025-09-20 15:48:59 +03:00
orange	18a1349693	reverted	2025-09-20 15:46:21 +03:00
orange	584a66b20c	fix	2025-09-20 15:44:33 +03:00
orange	3e5fb1bdb5	fixed rotation matrix	2025-09-20 15:44:33 +03:00
orange	3fa85f4c4d	added new mat function more tests	2025-09-20 15:44:33 +03:00
orange	d3c90253f7	fixed test	2025-09-20 15:44:33 +03:00
orange	eeb4dccb12	fixed iw engine fixed source revert	2025-09-20 15:44:33 +03:00
orange	708c8c082b	Update README.md	2025-09-18 19:39:11 +03:00
orange	e9dbec778d	fixed warning	2025-09-18 19:06:56 +03:00
orange	99d77d7790	fix	2025-09-18 18:42:02 +03:00
orange	df5ca54b90	now its ref	2025-09-18 18:39:28 +03:00
orange	80bae265c0	improved naming	2025-09-18 18:38:07 +03:00
orange	4929c96e5b	Update CREDITS.md to include Billy O'Neal Added acknowledgment for Billy O'Neal's contributions.	2025-09-18 06:08:49 +03:00
orange	f66f028317	Merge pull request #74 from BillyONeal/fmodf Don't name std::fmodf.	2025-09-18 06:04:43 +03:00
orange	dc3f2980db	Removes FMA check for matrix multiplication Removes preprocessor check for FMA instructions in matrix multiplication functions. This simplifies the code and relies on the compiler's ability to optimize the code based on available hardware support. The assumption is that modern compilers will automatically utilize FMA instructions if available, and fall back to alternative implementations if not.	2025-09-18 06:02:37 +03:00
orange	4505aee3c2	Guards AVX2 usage with a preprocessor definition Ensures that AVX2 intrinsics are only included when the OMATH_USE_AVX2 preprocessor definition is set. This prevents compilation errors when AVX2 support is not available or explicitly disabled.	2025-09-18 05:22:22 +03:00
Billy Robert O'Neal III	ee8073ceb4	Don't name std::fmodf. The C standard library function fmodf is not guaranteed to be in namespace std, and in fact is not with a default Ubuntu 24.04 installation, leading to the following compile error: ```console Change Dir: '/vcpkg/buildtrees/vcpkg-ci-orange-math/x64-linux-dbg' Run Build Command(s): /vcpkg/downloads/tools/ninja/1.12.1-linux/ninja -v -v -j33 [1/2] /usr/bin/c++ -DOMATH_SUPRESS_SAFETY_CHECKS -DOMATH_VERSION=\"3.5.0\" -isystem /vcpkg/installed/x64-linux/include -fPIC -g -std=gnu++23 -MD -MT CMakeFiles/main.dir/main.cpp.o -MF CMakeFiles/main.dir/main.cpp.o.d -o CMakeFiles/main.dir/main.cpp.o -c /vcpkg/scripts/test_ports/vcpkg-ci-orange-math/project/main.cpp FAILED: CMakeFiles/main.dir/main.cpp.o /usr/bin/c++ -DOMATH_SUPRESS_SAFETY_CHECKS -DOMATH_VERSION=\"3.5.0\" -isystem /vcpkg/installed/x64-linux/include -fPIC -g -std=gnu++23 -MD -MT CMakeFiles/main.dir/main.cpp.o -MF CMakeFiles/main.dir/main.cpp.o.d -o CMakeFiles/main.dir/main.cpp.o -c /vcpkg/scripts/test_ports/vcpkg-ci-orange-math/project/main.cpp In file included from /vcpkg/installed/x64-linux/include/omath/omath.hpp:22, from /vcpkg/scripts/test_ports/vcpkg-ci-orange-math/project/main.cpp:1: /vcpkg/installed/x64-linux/include/omath/color.hpp: In member function ‘constexpr omath::Hsv omath::Color::to_hsv() const’: /vcpkg/installed/x64-linux/include/omath/color.hpp:98:45: error: ‘fmodf’ is not a member of ‘std’; did you mean ‘modf’? 98 \| hsv_data.hue = 60.f * (std::fmodf(((green - blue) / delta), 6.f)); \| ^~~~~ \| modf ninja: build stopped: subcommand failed. ``` Only the 'sufficient additional overloads' of `fmod` are guaranteed to be in `std`. Since this is clearly intended to call the (float, float) overload, explicitly cast `((green - blue) / delta)` (which is a `double`) to `float` and call the name in `std` as suggested by the diagnostic.	2025-09-17 19:15:10 -07:00
orange	800965a16c	Merge pull request #73 from orange-cpp/featore/performance_tests added performance folder	2025-09-17 20:53:11 +03:00
orange	3e560cbfa4	fix	2025-09-17 20:50:30 +03:00
orange	fbebed3d16	patch	2025-09-17 20:46:00 +03:00
orange	439da31334	improved bench	2025-09-17 20:40:03 +03:00
orange	f7cb5eef1f	fix	2025-09-17 20:25:22 +03:00
orange	f6254c6a8c	patch	2025-09-17 20:22:42 +03:00
orange	e0c5c1c56b	added benchmark submodule	2025-09-17 20:14:33 +03:00
orange	e090ac1d9a	added benchmark	2025-09-17 19:56:50 +03:00
orange	dc3606301d	added avx mutiplication	2025-09-17 19:47:29 +03:00
orange	eb0ca6627f	renamed folder	2025-09-17 18:07:28 +03:00
orange	e2be30f505	added performance folder	2025-09-17 17:47:55 +03:00
orange	a742d99205	Merge pull request #72 from orange-cpp/feature/mat_refactor Feature/mat refactor	2025-09-17 17:41:15 +03:00
orange	578a4e1d32	removed unused var	2025-09-17 17:38:17 +03:00
orange	13e0bb3262	added space	2025-09-17 17:33:05 +03:00
orange	619c15072c	decomposed mutiplication	2025-09-17 17:30:57 +03:00
orange	242fc45ffa	forgot std	2025-09-17 17:23:02 +03:00
orange	36628c0400	Merge pull request #71 from orange-cpp/feature/mat_perf_boost Improves matrix multiplication performance	2025-09-17 17:18:12 +03:00
orange	a630da39e3	Improves matrix multiplication performance Optimizes matrix multiplication by specializing the algorithm based on the matrix storage type (row-major or column-major). This change significantly improves performance by leveraging memory access patterns specific to each storage order.	2025-09-17 17:12:41 +03:00
orange	910100c6dd	Add acknowledgment for AmbushedRaccoon's contribution	2025-09-16 16:58:00 +03:00
orange	dbae07546f	Merge pull request #69 from luadebug/patch-1 Repair omath.hpp by removing unexisting header include	2025-09-15 15:01:04 +03:00
Saikari	d1d26352d6	Update omath.hpp	2025-09-15 13:13:55 +03:00
orange	4f0cfd4cef	Adds 2D screen to world conversion Adds an overload for screen_to_world that accepts a 2D screen position. Renames screen_to_dnc to screen_to_ndc for clarity.	2025-09-14 04:48:56 +03:00
orange	8c03a07600	patch	2025-09-14 04:43:25 +03:00
orange	498df95e3e	Enables formatting support for Angle objects Adds a partial specialization of `std::formatter` for `omath::Angle` to provide formatting support using `std::format`. This allows `Angle` objects to be easily formatted as strings, including degree symbol representation, using standard formatting techniques.	2025-09-14 04:43:01 +03:00
orange	7ad0e3f10b	Removes unnecessary div tag Removes an empty div tag, which streamlines the HTML structure and contributes to cleaner code.	2025-09-13 20:13:35 +03:00
orange	4372f429ae	Repositions YouTube preview link Moves the YouTube preview link to improve the README's visual flow.	2025-09-13 20:08:48 +03:00
orange	077653e5ce	Improves README readability Adds a newline to the README file for better visual separation between the contribute button and the horizontal rule.	2025-09-13 19:55:23 +03:00
orange	5ec26f9def	Improves button aesthetics on README Adds whitespace to the buttons displayed on the README to improve their appearance.	2025-09-13 19:53:09 +03:00
orange	f48232cc1d	Updates README with gallery, install and usage Enhances the README by adding a gallery showcasing OMath's capabilities, providing a clearer installation guide, and improving usage examples to facilitate easier adoption. Also restructures the navigation for better user experience.	2025-09-13 19:50:58 +03:00
orange	32b1b90414	Update README.md	2025-09-13 19:20:37 +03:00
orange	0b18129eac	Update README.md	2025-09-13 19:16:19 +03:00
orange	8983cfc6d9	Update README.md	2025-09-09 22:15:00 +03:00
orange	123184987f	Update README.md	2025-09-09 21:48:54 +03:00
orange	ac7aeee9be	Merge pull request #68 from orange-cpp/feature/screen_to_world Feature/screen to world	2025-09-09 02:58:32 +03:00
orange	1d8dba6487	Fixes float type conversion in world_to_screen Fixes a potential type conversion issue by explicitly casting the x-coordinate to float in the world_to_screen test. This prevents possible compiler warnings and ensures the intended behavior.	2025-09-09 02:13:45 +03:00
orange	18b0b210cf	Adds projection test for world-to-screen consistency Adds a test to verify the consistency of world-to-screen and screen-to-world projections. This ensures that projecting a point from world to screen and back results in the same point, thereby validating the correctness of the camera projection transformations.	2025-09-09 01:37:38 +03:00
orange	9e08f5bb5c	Adds screen to world space conversion Adds functionality to convert screen coordinates to world space, including handling for cases where the inverse view projection matrix is singular or when the world position is out of screen bounds. Also exposes Camera class to unit tests.	2025-09-09 01:31:23 +03:00
orange	a61d3f20b7	Simplifies raycast early exit condition Combines the infinite length raycast hit check into a single condition. This clarifies the logic and avoids redundant checks for early exit in the ray-triangle intersection test, improving performance.	2025-09-08 23:52:35 +03:00
orange	4340e83914	Merge pull request #67 from orange-cpp/feature/angle-improvement Implements angle class with normalization	2025-09-08 20:18:11 +03:00
orange	1efa28d676	Implements angle class with normalization Adds an angle class with support for different normalization and clamping strategies. Includes trigonometric functions and arithmetic operators. Introduces unit tests to verify correct functionality. Disables unity builds to address a compilation issue.	2025-09-08 20:15:59 +03:00
orange	f393d0c1c3	Merge pull request #66 from orange-cpp/feature/remove-legacy Removes deprecated Matrix class	2025-09-08 19:59:34 +03:00
orange	55c5bb92da	Removes deprecated Matrix class Removes the deprecated `Matrix` class and its associated source files and unit tests. This change is to ensure code cleanliness and prevent accidental usage of the slow and outdated `Matrix` class. The `Mat` class should be used instead.	2025-09-08 19:56:04 +03:00
orange	6f203e3a20	Update LICENSE	2025-09-08 15:52:01 +03:00
orange	038de53783	updated logo psd	2025-09-06 23:14:14 +03:00
orange	fde3e1dcb9	Update README.md	2025-09-04 23:49:07 +03:00
orange	6153478d6e	Update CREDITS.md	2025-09-04 20:36:12 +03:00
orange	4a6ddb230b	Update LICENSE	2025-09-04 20:35:25 +03:00
orange	bb61e2303e	Update SECURITY.md	2025-09-04 20:35:04 +03:00
orange	522597c196	Update LICENSE	2025-09-04 19:35:05 +03:00
orange	9709ba8f61	Update LICENSE	2025-09-04 19:33:59 +03:00
orange	5111695d84	updated logo	2025-09-03 22:18:54 +03:00
orange	50bfc3e943	removed unused defines	2025-09-03 12:52:00 +03:00
orange	15f2a3917f	fix	2025-09-03 12:50:31 +03:00
orange	dede0a145d	Merge pull request #62 from orange-cpp/feaure/added_logo Feaure/added logo	2025-09-01 17:04:50 +03:00
orange	4238c94fc0	Acknowledges logo design contribution Updates the credits to acknowledge the new initial logo design.	2025-09-01 17:04:29 +03:00
orange	6a6c265501	Adds an omath.psd file. Adds a binary file named omath.psd.	2025-09-01 17:03:31 +03:00
orange	d061f67d13	Updates README with local image links Updates the README to use local image links instead of Imgur links for the showcase section. This improves the project's resilience against external link rot and ensures the images remain accessible even if Imgur experiences issues.	2025-09-01 17:02:23 +03:00
orange	1546d8a90f	Replaces banner with logo Replaces the project banner in the README with a dedicated logo. This change simplifies the banner implementation and improves maintainability by using a local image file instead of referencing an external URL.	2025-09-01 16:56:43 +03:00
`@@ -2,4 +2,4 @@`

	`## Reporting a Vulnerability`	`## Reporting a Vulnerability`

	Please report security issues to `orange-cpp@yandex.ru`	Please report security issues to `orange_github@proton.me`