Merge pull request #90 from orange-cpp/feature/ndc_invalid_calc_fix

Fixes NDC calculation and updates formulas
nuked not needed test
2026-02-13 23:13:26 +00:00 · 2025-10-21 04:45:07 +03:00 · 2025-10-21 04:38:43 +03:00 · 2025-10-21 04:38:43 +03:00 · 2025-10-21 04:38:43 +03:00 · 2025-10-19 04:00:20 +03:00
13 changed files with 106 additions and 31 deletions
--- a/.github/images/showcase/tf2.jpg
+++ b/.github/images/showcase/tf2.jpg
--- a/README.md
+++ b/README.md
@@ -75,6 +75,10 @@ It provides the latest features, is highly customizable, has all for cheat devel

 ![CS2 Preview]

+<br>
+
+![TF2 Preview]
+
 <br>
 <br>

@@ -87,7 +91,7 @@ It provides the latest features, is highly customizable, has all for cheat devel
 [APEX Preview]: .github/images/showcase/apex.png
 [BO2 Preview]: .github/images/showcase/cod_bo2.png
 [CS2 Preview]: .github/images/showcase/cs2.jpeg
-
+[TF2 Preview]: .github/images/showcase/tf2.jpg
 <!----------------------------------{ Buttons }--------------------------------->
 [INSTALL]: INSTALL.md
 [DOCUMENTATION]: http://libomath.org
--- a/include/omath/linear_algebra/mat.hpp
+++ b/include/omath/linear_algebra/mat.hpp
@@ -666,8 +666,7 @@ namespace omath
    }
    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
    [[nodiscard]]
-    Mat<4, 4, Type, St> mat_ortho_left_handed(const Type left, const Type right,
-                                              const Type bottom, const Type top,
+    Mat<4, 4, Type, St> mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top,
                                              const Type near, const Type far) noexcept
    {
        return
@@ -680,9 +679,8 @@ namespace omath
    }
    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
    [[nodiscard]]
-    Mat<4, 4, Type, St> mat_ortho_right_handed(const Type left, const Type right,
-                                              const Type bottom, const Type top,
-                                              const Type near, const Type far) noexcept
+    Mat<4, 4, Type, St> mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top,
+                                               const Type near, const Type far) noexcept
    {
        return
        {
--- a/include/omath/linear_algebra/vector2.hpp
+++ b/include/omath/linear_algebra/vector2.hpp
@@ -234,6 +234,21 @@ namespace omath
    };
 } // namespace omath

+template<> struct std::hash<omath::Vector2<float>>
+{
+    [[nodiscard]]
+    std::size_t operator()(const omath::Vector2<float>& vec) const noexcept
+    {
+        std::size_t hash = 0;
+        constexpr std::hash<float> hasher;
+
+        hash ^= hasher(vec.x) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
+        hash ^= hasher(vec.y) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
+
+        return hash;
+    }
+};
+
 template<class Type>
 struct std::formatter<omath::Vector2<Type>> // NOLINT(*-dcl58-cpp)
 {
--- a/include/omath/linear_algebra/vector3.hpp
+++ b/include/omath/linear_algebra/vector3.hpp
@@ -273,6 +273,7 @@ namespace omath

 template<> struct std::hash<omath::Vector3<float>>
 {
+    [[nodiscard]]
    std::size_t operator()(const omath::Vector3<float>& vec) const noexcept
    {
        std::size_t hash = 0;
--- a/include/omath/linear_algebra/vector4.hpp
+++ b/include/omath/linear_algebra/vector4.hpp
@@ -202,6 +202,22 @@ namespace omath
 };
 } // namespace omath

+template<> struct std::hash<omath::Vector4<float>>
+{
+    [[nodiscard]]
+    std::size_t operator()(const omath::Vector4<float>& vec) const noexcept
+    {
+        std::size_t hash = 0;
+        constexpr std::hash<float> hasher;
+
+        hash ^= hasher(vec.x) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
+        hash ^= hasher(vec.y) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
+        hash ^= hasher(vec.z) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
+        hash ^= hasher(vec.w) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
+        return hash;
+    }
+};
+
 template<class Type>
 struct std::formatter<omath::Vector4<Type>> // NOLINT(*-dcl58-cpp)
 {
--- a/include/omath/omath.hpp
+++ b/include/omath/omath.hpp
@@ -89,3 +89,4 @@

 // Utility
 #include "omath/utility/pattern_scan.hpp"
+#include "omath/utility/pe_pattern_scan.hpp"
--- a/include/omath/projection/camera.hpp
+++ b/include/omath/projection/camera.hpp
@@ -54,6 +54,12 @@ namespace omath::projection
        friend UnitTestProjection_Projection_Test;
 #endif
    public:
+        enum class ScreenStart
+        {
+            TOP_LEFT_CORNER,
+            BOTTOM_LEFT_CORNER,
+        };
+
        ~Camera() = default;
        Camera(const Vector3<float>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
               const FieldOfView& fov, const float near, const float far) noexcept
@@ -146,15 +152,22 @@ namespace omath::projection
            return m_origin;
        }

+
+        template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
        [[nodiscard]] std::expected<Vector3<float>, Error>
        world_to_screen(const Vector3<float>& world_position) const noexcept
        {
-            auto normalized_cords = world_to_view_port(world_position);
+            const auto normalized_cords = world_to_view_port(world_position);

            if (!normalized_cords.has_value())
                return std::unexpected{normalized_cords.error()};

-            return ndc_to_screen_position(*normalized_cords);
+            if constexpr (screen_start == ScreenStart::TOP_LEFT_CORNER)
+                return ndc_to_screen_position_from_top_left_corner(*normalized_cords);
+            else if constexpr (screen_start == ScreenStart::BOTTOM_LEFT_CORNER)
+                return ndc_to_screen_position_from_bottom_left_corner(*normalized_cords);
+            else
+                std::unreachable();
        }

        [[nodiscard]] std::expected<Vector3<float>, Error>
@@ -225,7 +238,8 @@ namespace omath::projection
            return std::ranges::any_of(ndc.raw_array(), [](const auto& val) { return val < -1 || val > 1; });
        }

-        [[nodiscard]] Vector3<float> ndc_to_screen_position(const Vector3<float>& ndc) const noexcept
+        [[nodiscard]] Vector3<float>
+        ndc_to_screen_position_from_top_left_corner(const Vector3<float>& ndc) const noexcept
        {
            /*
                                ^
@@ -239,7 +253,27 @@ 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};
+
+            return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (ndc.y / -2.f + 0.5f) * m_view_port.m_height, ndc.z};
+        }
+
+        [[nodiscard]] Vector3<float>
+        ndc_to_screen_position_from_bottom_left_corner(const Vector3<float>& ndc) const noexcept
+        {
+            /*
+                                ^
+                                |        y
+                            1   |
+                                |
+                                |
+                    -1 ---------0--------- 1  --> x
+                                |
+                                |
+                           -1   |
+                                v
+            */
+
+            return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (ndc.y / 2.f + 0.5f) * m_view_port.m_height, ndc.z};
        }

        [[nodiscard]] Vector3<float> screen_to_ndc(const Vector3<float>& screen_pos) const noexcept
--- a/include/omath/utility/pattern_scan.hpp
+++ b/include/omath/utility/pattern_scan.hpp
@@ -9,17 +9,13 @@
 #include <string_view>
 #include <vector>

-// ReSharper disable once CppInconsistentNaming
+// ReSharper disable CppInconsistentNaming
 class unit_test_pattern_scan_read_test_Test;
-// ReSharper disable once CppInconsistentNaming
 class unit_test_pattern_scan_corner_case_1_Test;
-// ReSharper disable once CppInconsistentNaming
 class unit_test_pattern_scan_corner_case_2_Test;
-// ReSharper disable once CppInconsistentNaming
 class unit_test_pattern_scan_corner_case_3_Test;
-// ReSharper disable once CppInconsistentNaming
 class unit_test_pattern_scan_corner_case_4_Test;
-
+// ReSharper restore CppInconsistentNaming
 namespace omath
 {
    enum class PatternScanError
@@ -37,11 +33,11 @@ namespace omath
    public:
        [[nodiscard]]
        static std::span<std::byte>::iterator scan_for_pattern(const std::span<std::byte>& range,
-                                                                     const std::string_view& pattern);
+                                                               const std::string_view& pattern);

        [[nodiscard]]
        static std::span<std::byte>::iterator scan_for_pattern(std::span<std::byte>&& range,
-                                                                     const std::string_view& pattern) = delete;
+                                                               const std::string_view& pattern) = delete;

        template<class IteratorType>
        requires std::input_or_output_iterator<std::remove_cvref_t<IteratorType>>
--- a/source/engines/unity_engine/formulas.cpp
+++ b/source/engines/unity_engine/formulas.cpp
@@ -25,7 +25,7 @@ namespace omath::unity_engine
    }
    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
    {
-        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), -right_vector(angles),
+        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(-forward_vector(angles), right_vector(angles),
                                                               up_vector(angles), cam_origin);
    }
    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
@@ -37,13 +37,6 @@ namespace omath::unity_engine
    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
                                              const float far) noexcept
    {
-        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, 0, 0},
-                {0, 1.f / (fov_half_tan), 0, 0},
-                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
-                {0, 0, -1.f, 0},
-        };
+        return omath::mat_perspective_right_handed(field_of_view, aspect_ratio, near, far);
    }
 } // namespace omath::unity_engine
--- a/source/utility/pe_pattern_scan.cpp
+++ b/source/utility/pe_pattern_scan.cpp
@@ -328,7 +328,7 @@ namespace omath
                    // ReSharper disable once CppTooWideScopeInitStatement
                    const auto result = PatternScanner::scan_for_pattern(scan_range, pattern);

-                    if (result != scan_range.cend())
+                    if (result != scan_range.end())
                        return reinterpret_cast<std::uintptr_t>(&*result);

                    return std::nullopt;
--- a/tests/engines/unit_test_unity_engine.cpp
+++ b/tests/engines/unit_test_unity_engine.cpp
@@ -87,9 +87,9 @@ TEST(unit_test_unity_engine, Project)
    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);

    const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
-    const auto proj = cam.world_to_screen({5.f, 3, 10.f});
+    const auto proj = cam.world_to_screen<omath::unity_engine::Camera::ScreenStart::BOTTOM_LEFT_CORNER>({10.f, 3, 10.f});

-    EXPECT_NEAR(proj->x, 951.769f, 0.001f);
+    EXPECT_NEAR(proj->x, 1263.538, 0.001f);
    EXPECT_NEAR(proj->y, 547.061f, 0.001f);
 }

--- a/tests/general/unit_test_mat.cpp
+++ b/tests/general/unit_test_mat.cpp
@@ -214,3 +214,20 @@ TEST(UnitTestMatStandalone, Enverse)

    EXPECT_EQ(mv, m.inverted());
 }
+
+TEST(UnitTestMatStandalone, Equanity)
+{
+    constexpr omath::Vector3<float> left_handed = {0, 2, 10};
+    constexpr omath::Vector3<float> right_handed = {0, 2, -10};
+
+    auto proj_left_handed = omath::mat_perspective_left_handed(90.f, 16.f / 9.f, 0.1, 1000);
+    auto proj_right_handed = omath::mat_perspective_right_handed(90.f, 16.f / 9.f, 0.1, 1000);
+
+    auto ndc_left_handed = proj_left_handed * omath::mat_column_from_vector(left_handed);
+    auto ndc_right_handed = proj_right_handed * omath::mat_column_from_vector(right_handed);
+
+    ndc_left_handed /= ndc_left_handed.at(3, 0);
+    ndc_right_handed /= ndc_right_handed.at(3, 0);
+
+    EXPECT_EQ(ndc_left_handed, ndc_right_handed);
+}
Author	SHA1	Message	Date
Orange++	ed8afb02a1	Merge pull request #90 from orange-cpp/feature/ndc_invalid_calc_fix Fixes NDC calculation and updates formulas	2025-10-21 04:45:07 +03:00
Orange	d86695fad7	nuked not needed test	2025-10-21 04:38:43 +03:00
Orange	570c035f27	added second method of w2s	2025-10-21 04:38:43 +03:00
Orange	5657282577	Fixes incorrect NDC calculation and updates formulas Corrects the NDC calculation in `world_to_screen` to improve accuracy. Replaces custom perspective projection matrix calculation with `omath::mat_perspective_right_handed` for correctness and consistency. Updates test cases and provides debugging information by printing view and projection matrices. Addresses an issue in the feature/ndc_invalid_calc_fix branch.	2025-10-21 04:38:43 +03:00
Orange	551ac62075	Added TF2 into gallery	2025-10-19 04:00:20 +03:00
Orange++	1b1be48ee6	Merge pull request #89 from luadebug/wasm Fix pattern scan range check to use end() instead of cend()	2025-10-17 15:27:03 +03:00
Saikari	1f9ea136b0	Fix pattern scan range check to use end() instead of cend()	2025-10-16 19:47:27 +03:00
Orange	8dadb22e75	Removes ReSharper disable comments Removes the `ReSharper disable CppInconsistentNaming` comments from the header file.	2025-10-14 13:23:09 +03:00
Orange	8dd9860aa1	Adds PE pattern scan utility Includes a new utility for scanning PE patterns.	2025-10-14 13:20:14 +03:00
Orange++	9a0470f781	Merge pull request #88 from orange-cpp/feaute/more_support_for_hash Adds hash support for Vector2, Vector3, and Vector4	2025-10-14 13:08:28 +03:00
Orange	eb8688c90c	Unifies orthographic matrix generation Consolidates the generation of left-handed and right-handed orthographic matrices into a shared implementation to reduce code duplication.	2025-10-14 13:06:23 +03:00
Orange	9f2f619a21	Adds hash support for Vector2, Vector3, and Vector4 Implements `std::hash` specialization for `omath::Vector2`, `omath::Vector3`, and `omath::Vector4` with float components. This enables usage of these vector types as keys in hash-based containers, such as `std::unordered_map` and `std::unordered_set`.	2025-10-14 13:00:28 +03:00