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.

.idea/vcs.xml

@@ -3,6 +3,5 @@
   <component name="VcsDirectoryMappings">
     <mapping directory="" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/extlibs/googletest" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$/extlibs/vcpkg" vcs="Git" />
   </component>
 </project>

CMakeLists.txt

@@ -13,7 +13,7 @@ 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}")
@@ -100,6 +100,7 @@ target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_23)
 if (OMATH_BUILD_TESTS)
     add_subdirectory(extlibs)
     add_subdirectory(tests)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_BUILD_TESTS)
 endif ()
 
 if (OMATH_BUILD_EXAMPLES)

CREDITS.md

@@ -2,10 +2,10 @@
 
 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.
 
 And a big hand to everyone else who has contributed over the past!
 
 THANKS! <3
 
-    -- Orange++ <orange-cpp@yandex.ru>
+    -- Orange++ <orange_github@proton.me>

LICENSE

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

README.md

@@ -1,8 +1,8 @@
 <div align = center>
 
-![banner](https://github.com/orange-cpp/omath/blob/main/.github/images/banner.png?raw=true)
+![banner](.github/images/logos/omath_logo_macro.png)
 
-![GitHub License](https://img.shields.io/github/license/orange-cpp/omath)
+![Static Badge](https://img.shields.io/badge/license-libomath-orange)
 ![GitHub contributors](https://img.shields.io/github/contributors/orange-cpp/omath)
 ![GitHub top language](https://img.shields.io/github/languages/top/orange-cpp/omath)
 [![CodeFactor](https://www.codefactor.io/repository/github/orange-cpp/omath/badge)](https://www.codefactor.io/repository/github/orange-cpp/omath)
@@ -12,9 +12,24 @@
 [![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]**
+
+---
+
+<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 +51,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 +91,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 +112,16 @@ 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

SECURITY.md

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

include/omath/angle.hpp

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

include/omath/linear_algebra/mat.hpp

@@ -11,13 +11,6 @@
 #include <stdexcept>
 #include <utility>
 
-#ifdef near
-#undef near
-#endif
-
-#ifdef far
-#undef far
-#endif
 
 namespace omath
 {
@@ -88,7 +81,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);
         }

include/omath/linear_algebra/matrix.hpp

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

include/omath/projection/camera.hpp

@@ -4,13 +4,18 @@
 
 #pragma once
 
-#include "omath/projection/error_codes.hpp"
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/vector3.hpp"
+#include "omath/projection/error_codes.hpp"
 #include <expected>
 #include <omath/angle.hpp>
 #include <type_traits>
 
+#ifdef OMATH_BUILD_TESTS
+// ReSharper disable once CppInconsistentNaming
+class UnitTestProjection_Projection_Test;
+#endif
+
 namespace omath::projection
 {
     class ViewPort final
@@ -45,6 +50,9 @@ namespace omath::projection
     requires CameraEngineConcept<TraitClass, Mat4X4Type, ViewAnglesType>
     class Camera final
     {
+#ifdef OMATH_BUILD_TESTS
+        friend UnitTestProjection_Projection_Test;
+#endif
     public:
         ~Camera() = default;
         Camera(const Vector3<float>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
@@ -164,6 +172,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,7 +226,7 @@ namespace omath::projection
 
         [[nodiscard]] Vector3<float> ndc_to_screen_position(const Vector3<float>& ndc) const noexcept
         {
-/*
+            /*
                                 ^
                                 |        y
                             1   |
@@ -197,8 +237,14 @@ namespace omath::projection
                                 |
                            -1   |
                                 v
-*/
+            */
             return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (1.f - ndc.y) / 2.f * m_view_port.m_height, ndc.z};
         }
+
+        [[nodiscard]] Vector3<float> screen_to_ndc(const Vector3<float>& screen_pos) const noexcept
+        {
+            return {screen_pos.x / m_view_port.m_width * 2.f - 1.f, 1.f - screen_pos.y / m_view_port.m_height * 2.f,
+                    screen_pos.z};
+        }
     };
 } // namespace omath::projection

include/omath/projection/error_codes.hpp

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

source/collision/line_tracer.cpp

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

source/matrix.cpp

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

tests/general/unit_test_angle.cpp

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

tests/general/unit_test_matrix.cpp

@@ -1,184 +0,0 @@
-//
-// Created by vlad on 5/18/2024.
-//
-
-#ifdef OMATH_ENABLE_LEGACY
-
-#include <gtest/gtest.h>
-#include <omath/matrix.hpp>
-#include "omath/vector3.hpp"
-
-using namespace omath;
-
-
-class UnitTestMatrix : public ::testing::Test
-{
-protected:
-    Matrix m1;
-    Matrix m2;
-
-    void SetUp() override
-    {
-        m1 = Matrix(2, 2);
-        m2 = Matrix{{1.0f, 2.0f}, {3.0f, 4.0f}};
-    }
-};
-
-// Test constructors
-TEST_F(UnitTestMatrix, Constructor_Size)
-{
-    const Matrix m(3, 3);
-    EXPECT_EQ(m.row_count(), 3);
-    EXPECT_EQ(m.columns_count(), 3);
-}
-
-TEST_F(UnitTestMatrix, Operator_SquareBrackets)
-{
-    EXPECT_EQ((m2[0, 0]), 1.0f);
-    EXPECT_EQ((m2[0, 1]), 2.0f);
-    EXPECT_EQ((m2[1, 0]), 3.0f);
-    EXPECT_EQ((m2[1, 1]), 4.0f);
-}
-
-
-TEST_F(UnitTestMatrix, Constructor_InitializerList)
-{
-    Matrix m{{1.0f, 2.0f}, {3.0f, 4.0f}};
-    EXPECT_EQ(m.row_count(), 2);
-    EXPECT_EQ(m.columns_count(), 2);
-    EXPECT_FLOAT_EQ(m.at(0, 0), 1.0f);
-    EXPECT_FLOAT_EQ(m.at(1, 1), 4.0f);
-}
-
-TEST_F(UnitTestMatrix, Constructor_Copy)
-{
-    Matrix m3 = m2;
-    EXPECT_EQ(m3.row_count(), m2.row_count());
-    EXPECT_EQ(m3.columns_count(), m2.columns_count());
-    EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
-}
-
-TEST_F(UnitTestMatrix, Constructor_Move)
-{
-    Matrix m3 = std::move(m2);
-    EXPECT_EQ(m3.row_count(), 2);
-    EXPECT_EQ(m3.columns_count(), 2);
-    EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
-    EXPECT_EQ(m2.row_count(), 0);  // m2 should be empty after the move
-    EXPECT_EQ(m2.columns_count(), 0);
-}
-
-// Test matrix operations
-TEST_F(UnitTestMatrix, Operator_Multiplication_Matrix)
-{
-    Matrix m3 = m2 * m2;
-    EXPECT_EQ(m3.row_count(), 2);
-    EXPECT_EQ(m3.columns_count(), 2);
-    EXPECT_FLOAT_EQ(m3.at(0, 0), 7.0f);
-    EXPECT_FLOAT_EQ(m3.at(1, 1), 22.0f);
-}
-
-TEST_F(UnitTestMatrix, Operator_Multiplication_Scalar)
-{
-    Matrix m3 = m2 * 2.0f;
-    EXPECT_FLOAT_EQ(m3.at(0, 0), 2.0f);
-    EXPECT_FLOAT_EQ(m3.at(1, 1), 8.0f);
-}
-
-TEST_F(UnitTestMatrix, Operator_Division_Scalar)
-{
-    Matrix m3 = m2 / 2.0f;
-    EXPECT_FLOAT_EQ(m3.at(0, 0), 0.5f);
-    EXPECT_FLOAT_EQ(m3.at(1, 1), 2.0f);
-}
-
-// Test matrix functions
-TEST_F(UnitTestMatrix, Transpose)
-{
-    Matrix m3 = m2.transpose();
-    EXPECT_FLOAT_EQ(m3.at(0, 1), 3.0f);
-    EXPECT_FLOAT_EQ(m3.at(1, 0), 2.0f);
-}
-
-TEST_F(UnitTestMatrix, Determinant)
-{
-    const float det = m2.determinant();
-    EXPECT_FLOAT_EQ(det, -2.0f);
-}
-
-TEST_F(UnitTestMatrix, Minor)
-{
-    const float minor = m2.minor(0, 0);
-    EXPECT_FLOAT_EQ(minor, 4.0f);
-}
-
-TEST_F(UnitTestMatrix, AlgComplement)
-{
-    const float algComp = m2.alg_complement(0, 0);
-    EXPECT_FLOAT_EQ(algComp, 4.0f);
-}
-
-TEST_F(UnitTestMatrix, Strip)
-{
-    Matrix m3 = m2.strip(0, 0);
-    EXPECT_EQ(m3.row_count(), 1);
-    EXPECT_EQ(m3.columns_count(), 1);
-    EXPECT_FLOAT_EQ(m3.at(0, 0), 4.0f);
-}
-
-TEST_F(UnitTestMatrix, ProjectionMatrix)
-{
-    const Matrix proj = Matrix::projection_matrix(45.0f, 1.33f, 0.1f, 100.0f);
-    EXPECT_EQ(proj.row_count(), 4);
-    EXPECT_EQ(proj.columns_count(), 4);
-    // Further checks on projection matrix elements could be added
-}
-
-// Test other member functions
-TEST_F(UnitTestMatrix, Set)
-{
-    m1.set(3.0f);
-    EXPECT_FLOAT_EQ(m1.at(0, 0), 3.0f);
-    EXPECT_FLOAT_EQ(m1.at(1, 1), 3.0f);
-}
-
-TEST_F(UnitTestMatrix, Sum)
-{
-    const float sum = m2.sum();
-    EXPECT_FLOAT_EQ(sum, 10.0f);
-}
-
-TEST_F(UnitTestMatrix, Clear)
-{
-    m2.clear();
-    EXPECT_FLOAT_EQ(m2.at(0, 0), 0.0f);
-    EXPECT_FLOAT_EQ(m2.at(1, 1), 0.0f);
-}
-
-TEST_F(UnitTestMatrix, ToString)
-{
-    const std::string str = m2.to_string();
-    EXPECT_FALSE(str.empty());
-}
-
-// Test assignment operators
-TEST_F(UnitTestMatrix, AssignmentOperator_Copy)
-{
-    Matrix m3(2, 2);
-    m3 = m2;
-    EXPECT_EQ(m3.row_count(), m2.row_count());
-    EXPECT_EQ(m3.columns_count(), m2.columns_count());
-    EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
-}
-
-TEST_F(UnitTestMatrix, AssignmentOperator_Move)
-{
-    Matrix m3(2, 2);
-    m3 = std::move(m2);
-    EXPECT_EQ(m3.row_count(), 2);
-    EXPECT_EQ(m3.columns_count(), 2);
-    EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
-    EXPECT_EQ(m2.row_count(), 0);  // m2 should be empty after the move
-    EXPECT_EQ(m2.columns_count(), 0);
-}
-#endif

tests/general/unit_test_projection.cpp

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