Merge pull request #95 from orange-cpp/pathfinding_improvement

removed brackets
2026-02-14 23:43:26 +00:00 · 2025-10-30 05:44:00 +03:00 · 2025-10-30 05:38:58 +03:00 · 2025-10-30 05:37:34 +03:00 · 2025-10-28 01:21:41 +03:00 · 2025-10-28 01:19:21 +03:00
43 changed files with 1033 additions and 206 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -56,7 +56,7 @@ SpaceBeforeParensOptions:
  AfterIfMacros: true
  AfterOverloadedOperator: false
  BeforeNonEmptyParentheses: false
-SpaceBeforeRangeBasedForLoopColon: false
+SpaceBeforeRangeBasedForLoopColon: true
 SpaceInEmptyParentheses: false
 SpacesInCStyleCastParentheses: false
 SpacesInConditionalStatement: false
--- a/.github/images/showcase/tf2.jpg
+++ b/.github/images/showcase/tf2.jpg
--- a/.github/workflows/cmake-multi-platform.yml
+++ b/.github/workflows/cmake-multi-platform.yml
@@ -19,27 +19,32 @@ jobs:
    name: Arch Linux (Clang)
    runs-on: ubuntu-latest
    container: archlinux:latest
-
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
    steps:
      - name: Install basic tool-chain with pacman
        shell: bash
        run: |
          pacman -Sy --noconfirm archlinux-keyring
          pacman -Syu --noconfirm --needed \
-                 git base-devel clang cmake ninja
+                 git base-devel clang cmake ninja zip unzip fmt

      - name: Checkout repository (with sub-modules)
        uses: actions/checkout@v4
        with:
          submodules: recursive

+      - name: Set up vcpkg
+        shell: bash
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
      - name: Configure (cmake --preset)
        shell: bash
-        run: cmake --preset linux-release -DOMATH_BUILD_TESTS=ON -DOMATH_BUILD_BENCHMARK=OFF
+        run: cmake --preset linux-release-vcpkg -DOMATH_BUILD_TESTS=ON -DOMATH_BUILD_BENCHMARK=OFF -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"

      - name: Build
        shell: bash
-        run: cmake --build cmake-build/build/linux-release --target unit_tests omath
+        run: cmake --build cmake-build/build/linux-release-vcpkg --target unit_tests omath

      - name: Run unit_tests
        shell: bash
@@ -53,6 +58,8 @@ jobs:
  windows-build-and-test:
    name: Windows (MSVC)
    runs-on: windows-latest
+    env:
+      OMATH_BUILD_VIA_VCPKG: ON

    steps:
      - name: Checkout repository (with sub-modules)
@@ -68,11 +75,11 @@ jobs:

      - name: Configure (cmake --preset)
        shell: bash
-        run: cmake --preset windows-release -DOMATH_BUILD_TESTS=ON -DOMATH_BUILD_BENCHMARK=OFF
+        run: cmake --preset windows-release-vcpkg -DOMATH_BUILD_TESTS=ON -DOMATH_BUILD_BENCHMARK=OFF -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"

      - name: Build
        shell: bash
-        run: cmake --build cmake-build/build/windows-release --target unit_tests omath
+        run: cmake --build cmake-build/build/windows-release-vcpkg --target unit_tests omath

      - name: Run unit_tests.exe
        shell: bash
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +0,0 @@
-[submodule "extlibs/googletest"]
-	path = extlibs/googletest
-	url = https://github.com/google/googletest.git
-[submodule "extlibs/benchmark"]
-	path = extlibs/benchmark
-	url = https://github.com/google/benchmark.git
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -2,7 +2,5 @@
 <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" />
  </component>
 </project>
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.26)

-project(omath VERSION 3.9.2 LANGUAGES CXX)
+project(omath VERSION 4.0.0 LANGUAGES CXX)

 include(CMakePackageConfigHelpers)
 include(CheckCXXCompilerFlag)
@@ -11,8 +11,8 @@ else ()
    check_cxx_compiler_flag("-mavx2" COMPILER_SUPPORTS_AVX2)
 endif ()

-option(OMATH_BUILD_TESTS "Build unit tests" ${PROJECT_IS_TOP_LEVEL})
-option(OMATH_BUILD_BENCHMARK "Build benchmarks" ${PROJECT_IS_TOP_LEVEL})
+option(OMATH_BUILD_TESTS "Build unit tests" OFF)
+option(OMATH_BUILD_BENCHMARK "Build benchmarks" OFF)
 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" ${COMPILER_SUPPORTS_AVX2})
@@ -21,7 +21,23 @@ option(OMATH_BUILD_EXAMPLES "Build example projects with you can learn & play" O
 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" OFF)
-option(OMATH_ENABLE_LEGACY "Will enable legacy classes that MUST be used ONLY for backward compatibility" OFF)
+option(OMATH_ENABLE_LEGACY "Will enable legacy classes that MUST be used ONLY for backward compatibility" ON)
+
+
+if (VCPKG_MANIFEST_FEATURES)
+    foreach (omath_feature IN LISTS VCPKG_MANIFEST_FEATURES)
+        if (omath_feature STREQUAL "imgui")
+            set(OMATH_IMGUI_INTEGRATION ON)
+        elseif (omath_feature STREQUAL "avx2")
+            set(OMATH_USE_AVX2 ${COMPILER_SUPPORTS_AVX2})
+        elseif (omath_feature STREQUAL "tests")
+            set(OMATH_BUILD_TESTS ON)
+        elseif (omath_feature STREQUAL "benchmark")
+            set(OMATH_BUILD_BENCHMARK ON)
+        endif ()
+
+    endforeach ()
+endif ()

 if (OMATH_USE_AVX2 AND NOT COMPILER_SUPPORTS_AVX2)
    message(WARNING "OMATH_USE_AVX2 requested, but compiler/target does not support AVX2. Disabling.")
@@ -40,6 +56,7 @@ if (${PROJECT_IS_TOP_LEVEL})
    message(STATUS "[${PROJECT_NAME}]: AVX2 feature status ${OMATH_USE_AVX2}")
    message(STATUS "[${PROJECT_NAME}]: ImGUI integration feature status ${OMATH_IMGUI_INTEGRATION}")
    message(STATUS "[${PROJECT_NAME}]: Legacy features support ${OMATH_ENABLE_LEGACY}")
+    message(STATUS "[${PROJECT_NAME}]: Building using vcpkg ${OMATH_BUILD_VIA_VCPKG}")
 endif ()

 file(GLOB_RECURSE OMATH_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp")
@@ -84,7 +101,7 @@ if (OMATH_SUPRESS_SAFETY_CHECKS)
 endif ()

 if (OMATH_ENABLE_LEGACY)
-    target_compile_options(${PROJECT_NAME} PUBLIC OMATH_ENABLE_LEGACY)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_LEGACY)
 endif ()

 set_target_properties(${PROJECT_NAME} PROPERTIES
@@ -117,9 +134,6 @@ endif ()

 target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_23)

-add_subdirectory(extlibs)
-
-
 if (OMATH_BUILD_TESTS)
    add_subdirectory(tests)
    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_BUILD_TESTS)
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -8,7 +8,8 @@
      "binaryDir": "${sourceDir}/cmake-build/build/${presetName}",
      "installDir": "${sourceDir}/cmake-build/install/${presetName}",
      "cacheVariables": {
-        "CMAKE_CXX_COMPILER": "cl.exe"
+        "CMAKE_CXX_COMPILER": "cl.exe",
+        "CMAKE_MAKE_PROGRAM": "Ninja"
      },
      "condition": {
        "type": "equals",
@@ -16,6 +17,17 @@
        "rhs": "Windows"
      }
    },
+    {
+      "name": "windows-base-vcpkg",
+      "hidden": true,
+      "inherits": "windows-base",
+      "cacheVariables": {
+        "OMATH_BUILD_VIA_VCPKG": "ON",
+        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
+        "VCPKG_INSTALLED_DIR": "${sourceDir}/cmake-build/vcpkg_installed",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2"
+      }
+    },
    {
      "name": "windows-debug",
      "displayName": "Debug",
@@ -24,6 +36,23 @@
        "CMAKE_BUILD_TYPE": "Debug"
      }
    },
+    {
+      "name": "windows-debug-vcpkg",
+      "displayName": "Debug",
+      "inherits": "windows-base-vcpkg",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug"
+      }
+    },
+    {
+      "name": "windows-release-vcpkg",
+      "displayName": "Release",
+      "inherits": "windows-base-vcpkg",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "OMATH_BUILD_VIA_VCPKG": "ON"
+      }
+    },
    {
      "name": "windows-release",
      "displayName": "Release",
@@ -39,7 +68,8 @@
      "binaryDir": "${sourceDir}/cmake-build/build/${presetName}",
      "installDir": "${sourceDir}/cmake-build/install/${presetName}",
      "cacheVariables": {
-        "CMAKE_CXX_COMPILER": "clang++"
+        "CMAKE_CXX_COMPILER": "clang++",
+        "CMAKE_MAKE_PROGRAM": "ninja"
      },
      "condition": {
        "type": "equals",
@@ -47,6 +77,17 @@
        "rhs": "Linux"
      }
    },
+    {
+      "name": "linux-base-vcpkg",
+      "hidden": true,
+      "inherits": "linux-base",
+      "cacheVariables": {
+        "OMATH_BUILD_VIA_VCPKG": "ON",
+        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
+        "VCPKG_INSTALLED_DIR": "${sourceDir}/cmake-build/vcpkg_installed",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2"
+      }
+    },
    {
      "name": "linux-debug",
      "displayName": "Linux Debug",
@@ -55,6 +96,14 @@
        "CMAKE_BUILD_TYPE": "Debug"
      }
    },
+    {
+      "name": "linux-debug-vcpkg",
+      "displayName": "Linux Debug",
+      "inherits": "linux-base-vcpkg",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug"
+      }
+    },
    {
      "name": "linux-release",
      "displayName": "Linux Release",
@@ -63,6 +112,14 @@
        "CMAKE_BUILD_TYPE": "Release"
      }
    },
+    {
+      "name": "linux-release-vcpkg",
+      "displayName": "Linux Release",
+      "inherits": "linux-base-vcpkg",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release"
+      }
+    },
    {
      "name": "darwin-base",
      "hidden": true,
@@ -86,6 +143,14 @@
        "CMAKE_BUILD_TYPE": "Debug"
      }
    },
+    {
+      "name": "darwin-debug-vcpkg",
+      "displayName": "Darwin Debug",
+      "inherits": "darwin-base",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug"
+      }
+    },
    {
      "name": "darwin-release",
      "displayName": "Darwin Release",
@@ -93,6 +158,14 @@
      "cacheVariables": {
        "CMAKE_BUILD_TYPE": "Release"
      }
+    },
+    {
+      "name": "darwin-release-vcpkg",
+      "displayName": "Darwin Release",
+      "inherits": "darwin-debug",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release"
+      }
    }
  ]
 }
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -18,7 +18,7 @@ In order to send code back to the official OMath repository, you must first crea
 account ([fork](https://help.github.com/articles/creating-a-pull-request-from-a-fork/)) and
 then [create a pull request](https://help.github.com/articles/creating-a-pull-request-from-a-fork/) back to OMath.

-OMath developement is performed on multiple branches. Changes are then pull requested into master. By default, changes
+OMath development is performed on multiple branches. Changes are then pull requested into master. By default, changes
 merged into master will not roll out to stable build users unless the `stable` tag is updated.

 ### 📜 Code-Style
--- a/32
+++ b/32
@@ -16,8 +16,38 @@ freely, subject to the following restrictions:
   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)
+   or have any other affiliation (past or present)
   with any of the following entities:
+     * "Advertising Placement Services" LLC
+     * "NEW SOLUTIONS VERTICALS" LLC
+     * "Autoexpert" LLC
+     * "Creditit" LLC
+     * "Yandex.Taxi" LLC
+     * "Yandex.Eda" LLC
+     * "Yandex.Lavka" LLC
+     * "Yandex.Telecom" LLC
+     * "Yandex.Cloud" LLC
+     * "Micromobility" LLC
+     * "MM-Tech" LLC
+     * "Carsharing" LLC
+     * "Yandex.Drive" LLC
+     * "EDADIL PROMO" LLC
+     * "Kinopoisk" LLC
+     * "Yandex.Music" LLC
+     * "Refueling (Yandex.Zapravki)" LLC
+     * "Yandex.Pay" LLC
+     * "Financial and Payment Technologies" LLC
+     * "Yandex.Delivery" LLC
+     * "Delivery Club" LLC
+     * "Yandex.Check" LLC
+     * "SMB-Service" LLC
+     * "ADV-TECH" LLC
+     * "Yandex Fantech" LLC
+     * "Yandex Smena" LLC
+     * "Market.Operations" LLC
+     * "Yandex.Market" LLC
+     * "ID Tech" LLC
+     * "Yandex.Crowd" LLC
     * "Yandex" LLC
     * "Rutube" LLC
     * "Kaspersky" LLC
--- a/README.md
+++ b/README.md
@@ -52,8 +52,9 @@ It provides the latest features, is highly customizable, has all for cheat devel
 - **Collision Detection**: Production ready code to handle collision detection by using simple interfaces.
 - **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!
- **Engine support**: Supports coordinate systems of Source, Unity, Unreal, IWEngine and canonical OpenGL.
+- **Engine support**: Supports coordinate systems of **Source, Unity, Unreal, Frostbite, IWEngine and canonical OpenGL**.
 - **Cross platform**: Supports Windows, MacOS and Linux.
+- **Algorithms**: Has ability to scan for byte pattern with wildcards in PE files/modules, binary slices, works even with Wine apps. 
 <div align = center>
 
 # Gallery
@@ -74,6 +75,10 @@ It provides the latest features, is highly customizable, has all for cheat devel

 ![CS2 Preview]

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

@@ -86,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/2
+++ b/2
@@ -1 +1 @@
-3.9.2
+4.0.0
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -11,5 +11,9 @@ set_target_properties(${PROJECT_NAME} PROPERTIES
        CXX_STANDARD 23
        CXX_STANDARD_REQUIRED ON)

-
+if (TARGET benchmark::benchmark) # Benchmark is being linked as submodule
    target_link_libraries(${PROJECT_NAME} PRIVATE benchmark::benchmark omath)
+else()
+    find_package(benchmark CONFIG REQUIRED) # Benchmark is being linked as vcpkg package
+    target_link_libraries(${PROJECT_NAME} PRIVATE benchmark::benchmark omath)
+endif ()
--- a/extlibs/CMakeLists.txt
+++ b/extlibs/CMakeLists.txt
@@ -1,9 +0,0 @@
-
-if (OMATH_BUILD_TESTS)
-    add_subdirectory(googletest)
-endif ()
-
-if (OMATH_BUILD_BENCHMARK)
-    set(BENCHMARK_ENABLE_TESTING OFF)
-    add_subdirectory(benchmark)
-endif ()
--- a/extlibs/benchmark
+++ b/extlibs/benchmark
--- a/extlibs/googletest
+++ b/extlibs/googletest
--- a/include/omath/engines/frostbite_engine/camera.hpp
+++ b/include/omath/engines/frostbite_engine/camera.hpp
@@ -0,0 +1,13 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+
+#pragma once
+#include "omath/engines/frostbite_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+#include "traits/camera_trait.hpp"
+
+namespace omath::frostbite_engine
+{
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+} // namespace omath::unity_engine
--- a/include/omath/engines/frostbite_engine/constants.hpp
+++ b/include/omath/engines/frostbite_engine/constants.hpp
@@ -0,0 +1,25 @@
+//
+// Created by Vlad on 10/21/2025.
+//
+
+#pragma once
+#include "omath/linear_algebra/mat.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <omath/trigonometry/angle.hpp>
+#include <omath/trigonometry/view_angles.hpp>
+
+namespace omath::frostbite_engine
+{
+    constexpr Vector3<float> k_abs_up = {0, 1, 0};
+    constexpr Vector3<float> k_abs_right = {1, 0, 0};
+    constexpr Vector3<float> k_abs_forward = {0, 0, 1};
+
+    using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3X3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat1X3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
+    using PitchAngle = Angle<float, -90.f, 90.f, AngleFlags::Clamped>;
+    using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+    using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+
+    using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
+} // namespace omath::frostbite_engine
--- a/include/omath/engines/frostbite_engine/formulas.hpp
+++ b/include/omath/engines/frostbite_engine/formulas.hpp
@@ -0,0 +1,26 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+
+#pragma once
+#include "omath/engines/frostbite_engine/constants.hpp"
+
+namespace omath::frostbite_engine
+{
+    [[nodiscard]]
+    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+} // namespace omath::unity_engine
--- a/include/omath/engines/frostbite_engine/traits/camera_trait.hpp
+++ b/include/omath/engines/frostbite_engine/traits/camera_trait.hpp
@@ -0,0 +1,24 @@
+//
+// Created by Vlad on 8/10/2025.
+//
+
+#pragma once
+#include "omath/engines/frostbite_engine/formulas.hpp"
+#include "omath/projection/camera.hpp"
+
+namespace omath::frostbite_engine
+{
+    class CameraTrait final
+    {
+    public:
+        [[nodiscard]]
+        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+
+        [[nodiscard]]
+        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+        [[nodiscard]]
+        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+                                             float near, float far) noexcept;
+    };
+
+} // namespace omath::unreal_engine
--- a/include/omath/engines/frostbite_engine/traits/pred_engine_trait.hpp
+++ b/include/omath/engines/frostbite_engine/traits/pred_engine_trait.hpp
@@ -0,0 +1,76 @@
+//
+// Created by Vlad on 8/6/2025.
+//
+#pragma once
+#include "omath/engines/frostbite_engine/formulas.hpp"
+#include "omath/projectile_prediction/projectile.hpp"
+#include "omath/projectile_prediction/target.hpp"
+#include <optional>
+
+namespace omath::frostbite_engine
+{
+    class PredEngineTrait final
+    {
+    public:
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+                                                                    const float pitch, const float yaw,
+                                                                    const float time, const float gravity) noexcept
+        {
+            auto current_pos = projectile.m_origin
+                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
+                                                 RollAngle::from_degrees(0)})
+                                         * projectile.m_launch_speed * time;
+            current_pos.y -= (gravity * projectile.m_gravity_scale) * (time * time) * 0.5f;
+
+            return current_pos;
+        }
+        [[nodiscard]]
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+                                                                const float time, const float gravity) noexcept
+        {
+            auto predicted = target.m_origin + target.m_velocity * time;
+
+            if (target.m_is_airborne)
+                predicted.y -= gravity * (time * time) * 0.5f;
+
+            return predicted;
+        }
+        [[nodiscard]]
+        static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
+        {
+            return std::sqrt(delta.x * delta.x + delta.z * delta.z);
+        }
+
+        [[nodiscard]]
+        constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
+        {
+            return vec.y;
+        }
+
+        [[nodiscard]]
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+                                                         Vector3<float> predicted_target_position,
+                                                         const std::optional<float> projectile_pitch) noexcept
+        {
+            const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
+            const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
+
+            return {predicted_target_position.x, predicted_target_position.y + height, projectile.m_origin.z};
+        }
+        // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
+        // 89 look up, -89 look down
+        [[nodiscard]]
+        static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto direction = (view_to - origin).normalized();
+            return angles::radians_to_degrees(std::asin(direction.y));
+        }
+        [[nodiscard]]
+        static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto direction = (view_to - origin).normalized();
+
+            return angles::radians_to_degrees(std::atan2(direction.x, direction.z));
+        };
+    };
+} // namespace omath::unity_engine
--- a/include/omath/linear_algebra/mat.hpp
+++ b/include/omath/linear_algebra/mat.hpp
@@ -39,6 +39,7 @@ namespace omath
    class Mat final
    {
    public:
+        using ContainedType = Type;
        constexpr Mat() noexcept
        {
            clear();
@@ -666,8 +667,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,8 +680,7 @@ 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,
+    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
@@ -221,7 +221,7 @@ namespace omath
        }
 #ifdef OMATH_IMGUI_INTEGRATION
        [[nodiscard]]
-        ImVec2 to_im_vec2() const noexcept
+        constexpr ImVec2 to_im_vec2() const noexcept
        {
            return {static_cast<float>(this->x), static_cast<float>(this->y)};
        }
@@ -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
@@ -184,7 +184,7 @@ namespace omath

 #ifdef OMATH_IMGUI_INTEGRATION
        [[nodiscard]]
-        ImVec4 to_im_vec4() const noexcept
+        constexpr ImVec4 to_im_vec4() const noexcept
        {
            return {
                    static_cast<float>(this->x),
@@ -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
@@ -76,6 +76,14 @@
 #include "omath/engines/unity_engine/traits/camera_trait.hpp"
 #include "omath/engines/unity_engine/traits/pred_engine_trait.hpp"

+//Frostbite Engine
+#include "omath/engines/frostbite_engine/constants.hpp"
+#include "omath/engines/frostbite_engine/formulas.hpp"
+#include "omath/engines/frostbite_engine/camera.hpp"
+#include "omath/engines/frostbite_engine/traits/camera_trait.hpp"
+#include "omath/engines/frostbite_engine/traits/pred_engine_trait.hpp"
+
+
 // Unreal Engine
 #include "omath/engines/unreal_engine/constants.hpp"
 #include "omath/engines/unreal_engine/formulas.hpp"
@@ -89,3 +97,4 @@

 // Utility
 #include "omath/utility/pattern_scan.hpp"
+#include "omath/utility/pe_pattern_scan.hpp"
--- a/include/omath/pathfinding/a_star.hpp
+++ b/include/omath/pathfinding/a_star.hpp
@@ -22,9 +22,5 @@ namespace omath::pathfinding
        static std::vector<Vector3<float>>
        reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
                               const Vector3<float>& current) noexcept;
-
-        [[nodiscard]]
-        static auto get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
-                                     const Vector3<float>& end_vertex) noexcept;
    };
 } // namespace omath::pathfinding
--- 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,8 +238,7 @@ 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
-        {
+        // NDC REPRESENTATION:
        /*
                                ^
                                |        y
@@ -239,7 +251,39 @@ 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>
+        ndc_to_screen_position_from_top_left_corner(const Vector3<float>& ndc) const noexcept
+        {
+            /*
+            +------------------------>
+            | (0, 0)
+            |
+            |
+            |
+            |
+            |
+            |
+            ⌄
+            */
+            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
+        {
+            /*
+             ^
+             |
+             |
+             |
+             |
+             |
+             |
+             | (0, 0)
+             +------------------------>
+             */
+            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
--- a/include/omath/utility/pe_pattern_scan.hpp
+++ b/include/omath/utility/pe_pattern_scan.hpp
@@ -19,7 +19,7 @@ namespace omath
    {
    public:
        [[nodiscard]]
-        static std::optional<std::uintptr_t> scan_for_pattern_in_loaded_module(const std::string_view& module_name,
+        static std::optional<std::uintptr_t> scan_for_pattern_in_loaded_module(const void* module_base_address,
                                                                               const std::string_view& pattern);

        [[nodiscard]]
--- a/source/engines/frostbite_engine/formulas.cpp
+++ b/source/engines/frostbite_engine/formulas.cpp
@@ -0,0 +1,42 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+#include "omath/engines/frostbite_engine/formulas.hpp"
+
+namespace omath::frostbite_engine
+{
+    Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    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),
+                                                               up_vector(angles), cam_origin);
+    }
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * 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
+    {
+        return mat_perspective_left_handed(field_of_view, aspect_ratio, near, far);
+    }
+} // namespace omath::unity_engine
--- a/source/engines/frostbite_engine/traits/camera_trait.cpp
+++ b/source/engines/frostbite_engine/traits/camera_trait.cpp
@@ -0,0 +1,26 @@
+//
+// Created by Vlad on 8/11/2025.
+//
+#include "omath/engines/frostbite_engine/traits/camera_trait.hpp"
+
+namespace omath::frostbite_engine
+{
+
+    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
+    {
+        const auto direction = (look_at - cam_origin).normalized();
+
+        return {PitchAngle::from_radians(-std::asin(direction.y)),
+                YawAngle::from_radians(std::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)};
+    }
+    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return frostbite_engine::calc_view_matrix(angles, cam_origin);
+    }
+    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
+                                               const projection::ViewPort& view_port, const float near,
+                                               const float far) noexcept
+    {
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+    }
+} // namespace omath::unity_engine
--- 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/pathfinding/a_star.cpp
+++ b/source/pathfinding/a_star.cpp
@@ -4,9 +4,25 @@
 #include "omath/pathfinding/a_star.hpp"
 #include <algorithm>
 #include <optional>
+#include <queue>
 #include <unordered_map>
 #include <unordered_set>

+namespace
+{
+    struct OpenListNode final
+    {
+        omath::Vector3<float> position;
+        float f_cost;
+
+        [[nodiscard]]
+        bool operator>(const OpenListNode& other) const noexcept
+        {
+            return f_cost > other.f_cost;
+        }
+    };
+}
+
 namespace omath::pathfinding
 {
    struct PathNode final
@@ -37,23 +53,13 @@ namespace omath::pathfinding
        std::ranges::reverse(path);
        return path;
    }
-    auto Astar::get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
-                                 const Vector3<float>& end_vertex) noexcept
-    {
-        return std::ranges::min_element(open_list,
-                                        [&end_vertex](const auto& a, const auto& b)
-                                        {
-                                            const float fa = a.second.g_cost + a.first.distance_to(end_vertex);
-                                            const float fb = b.second.g_cost + b.first.distance_to(end_vertex);
-                                            return fa < fb;
-                                        });
-    }

    std::vector<Vector3<float>> Astar::find_path(const Vector3<float>& start, const Vector3<float>& end,
                                                 const NavigationMesh& nav_mesh) noexcept
    {
        std::unordered_map<Vector3<float>, PathNode> closed_list;
-        std::unordered_map<Vector3<float>, PathNode> open_list;
+        std::unordered_map<Vector3<float>, PathNode> node_data;
+        std::priority_queue<OpenListNode, std::vector<OpenListNode>, std::greater<>> open_list;

        auto maybe_start_vertex = nav_mesh.get_closest_vertex(start);
        auto maybe_end_vertex = nav_mesh.get_closest_vertex(end);
@@ -64,20 +70,27 @@ namespace omath::pathfinding
        const auto start_vertex = maybe_start_vertex.value();
        const auto end_vertex = maybe_end_vertex.value();

-        open_list.emplace(start_vertex, PathNode{std::nullopt, 0.f});
+        node_data.emplace(start_vertex, PathNode{std::nullopt, 0.f});
+        open_list.push({start_vertex, start_vertex.distance_to(end_vertex)});

        while (!open_list.empty())
        {
-            auto current_it = get_perfect_node(open_list, end_vertex);
+            auto current = open_list.top().position;
+            open_list.pop();

-            const auto current = current_it->first;
-            const auto current_node = current_it->second;
+            if (closed_list.contains(current))
+                continue;
+
+            auto current_node_it = node_data.find(current);
+            if (current_node_it == node_data.end())
+                continue;
+
+            const auto current_node = current_node_it->second;

            if (current == end_vertex)
                return reconstruct_final_path(closed_list, current);

            closed_list.emplace(current, current_node);
-            open_list.erase(current_it);

            for (const auto& neighbor: nav_mesh.get_neighbors(current))
            {
@@ -86,11 +99,14 @@ namespace omath::pathfinding

                const float tentative_g_cost = current_node.g_cost + neighbor.distance_to(current);

-                // ReSharper disable once CppTooWideScopeInitStatement
-                const auto open_it = open_list.find(neighbor);
+                auto node_it = node_data.find(neighbor);

-                if (open_it == open_list.end() || tentative_g_cost < open_it->second.g_cost)
-                    open_list[neighbor] = PathNode{current, tentative_g_cost};
+                if (node_it == node_data.end() || tentative_g_cost < node_it->second.g_cost)
+                {
+                    node_data[neighbor] = PathNode{current, tentative_g_cost};
+                    const float f_cost = tentative_g_cost + neighbor.distance_to(end_vertex);
+                    open_list.push({neighbor, f_cost});
+                }
            }
        }

--- a/source/pathfinding/navigation_mesh.cpp
+++ b/source/pathfinding/navigation_mesh.cpp
@@ -3,6 +3,8 @@
 //
 #include "omath/pathfinding/navigation_mesh.hpp"
 #include <algorithm>
+#include <cstring>
+#include <limits>
 #include <stdexcept>
 namespace omath::pathfinding
 {
@@ -13,7 +15,7 @@ namespace omath::pathfinding
                                                  { return a.first.distance_to(point) < b.first.distance_to(point); });

        if (res == m_vertex_map.cend())
-            return std::unexpected("Failed to get clossest point");
+            return std::unexpected("Failed to get closest point");

        return res->first;
    }
@@ -30,55 +32,68 @@ namespace omath::pathfinding

    std::vector<uint8_t> NavigationMesh::serialize() const noexcept
    {
-        auto dump_to_vector = []<typename T>(const T& t, std::vector<uint8_t>& vec)
-        {
-            for (size_t i = 0; i < sizeof(t); i++)
-                vec.push_back(*(reinterpret_cast<const uint8_t*>(&t) + i));
-        };
+        std::vector<std::uint8_t> raw;

-        std::vector<uint8_t> raw;
+        // Pre-calculate total size for better performance
+        std::size_t total_size = 0;
+        for (const auto& [vertex, neighbors] : m_vertex_map)
+        {
+            total_size += sizeof(vertex) + sizeof(std::uint16_t) + sizeof(Vector3<float>) * neighbors.size();
+        }
+        raw.reserve(total_size);
+
+        auto dump_to_vector = [&raw]<typename T>(const T& t)
+        {
+            const auto* byte_ptr = reinterpret_cast<const std::uint8_t*>(&t);
+            raw.insert(raw.end(), byte_ptr, byte_ptr + sizeof(T));
+        };

        for (const auto& [vertex, neighbors] : m_vertex_map)
        {
-            const auto neighbors_count = neighbors.size();
+            // Clamp neighbors count to fit in uint16_t (prevents silent data corruption)
+            // NOTE: If neighbors.size() > 65535, only the first 65535 neighbors will be serialized.
+            // This is a limitation of the current serialization format using uint16_t for count.
+            const auto clamped_count =
+                    std::min<std::size_t>(neighbors.size(), std::numeric_limits<std::uint16_t>::max());
+            const auto neighbors_count = static_cast<std::uint16_t>(clamped_count);

-            dump_to_vector(vertex, raw);
-            dump_to_vector(neighbors_count, raw);
+            dump_to_vector(vertex);
+            dump_to_vector(neighbors_count);

-            for (const auto& neighbor: neighbors)
-                dump_to_vector(neighbor, raw);
+            // Only serialize up to the clamped count
+            for (std::size_t i = 0; i < clamped_count; ++i)
+                dump_to_vector(neighbors[i]);
        }
        return raw;
    }

    void NavigationMesh::deserialize(const std::vector<uint8_t>& raw) noexcept
    {
-        auto load_from_vector = [](const std::vector<uint8_t>& vec, size_t& offset, auto& value)
+        auto load_from_vector = [](const std::vector<uint8_t>& vec, std::size_t& offset, auto& value)
        {
            if (offset + sizeof(value) > vec.size())
-            {
                throw std::runtime_error("Deserialize: Invalid input data size.");
-            }
+
            std::copy_n(vec.data() + offset, sizeof(value), reinterpret_cast<uint8_t*>(&value));
            offset += sizeof(value);
        };

        m_vertex_map.clear();

-        size_t offset = 0;
+        std::size_t offset = 0;

        while (offset < raw.size())
        {
            Vector3<float> vertex;
            load_from_vector(raw, offset, vertex);

-            uint16_t neighbors_count;
+            std::uint16_t neighbors_count;
            load_from_vector(raw, offset, neighbors_count);

            std::vector<Vector3<float>> neighbors;
            neighbors.reserve(neighbors_count);

-            for (size_t i = 0; i < neighbors_count; ++i)
+            for (std::size_t i = 0; i < neighbors_count; ++i)
            {
                Vector3<float> neighbor;
                load_from_vector(raw, offset, neighbor);
--- a/source/projectile_prediction/proj_pred_engine_avx2.cpp
+++ b/source/projectile_prediction/proj_pred_engine_avx2.cpp
@@ -18,97 +18,104 @@ namespace omath::projectile_prediction
                                                  [[maybe_unused]] const Target& target) const
    {
 #if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
-        const float bulletGravity = m_gravityConstant * projectile.m_gravityScale;
-        const float v0 = projectile.m_launchSpeed;
-        const float v0Sqr = v0 * v0;
-        const Vector3 projOrigin = projectile.m_origin;
+        const float bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
+        const float v0 = projectile.m_launch_speed;
+        const float v0_sqr = v0 * v0;
+        const Vector3 proj_origin = projectile.m_origin;

        constexpr int SIMD_FACTOR = 8;
-        float currentTime = m_simulationTimeStep;
+        float current_time = m_simulation_time_step;

-        for (; currentTime <= m_maximumSimulationTime; currentTime += m_simulationTimeStep * SIMD_FACTOR)
+        for (; current_time <= m_maximum_simulation_time; current_time += m_simulation_time_step * SIMD_FACTOR)
        {
            const __m256 times
-                    = _mm256_setr_ps(currentTime, currentTime + m_simulationTimeStep,
-                                     currentTime + m_simulationTimeStep * 2, currentTime + m_simulationTimeStep * 3,
-                                     currentTime + m_simulationTimeStep * 4, currentTime + m_simulationTimeStep * 5,
-                                     currentTime + m_simulationTimeStep * 6, currentTime + m_simulationTimeStep * 7);
+                    = _mm256_setr_ps(current_time, current_time + m_simulation_time_step,
+                                     current_time + m_simulation_time_step * 2, current_time + m_simulation_time_step * 3,
+                                     current_time + m_simulation_time_step * 4, current_time + m_simulation_time_step * 5,
+                                     current_time + m_simulation_time_step * 6, current_time + m_simulation_time_step * 7);

-            const __m256 targetX
+            const __m256 target_x
                    = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.x), times, _mm256_set1_ps(target.m_origin.x));
-            const __m256 targetY
+            const __m256 target_y
                    = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.y), times, _mm256_set1_ps(target.m_origin.y));
-            const __m256 timesSq = _mm256_mul_ps(times, times);
-            const __m256 targetZ = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.z), times,
-                                                   _mm256_fnmadd_ps(_mm256_set1_ps(0.5f * m_gravityConstant), timesSq,
+            const __m256 times_sq = _mm256_mul_ps(times, times);
+            const __m256 target_z = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.z), times,
+                                                   _mm256_fnmadd_ps(_mm256_set1_ps(0.5f * m_gravity_constant), times_sq,
                                                                    _mm256_set1_ps(target.m_origin.z)));

-            const __m256 deltaX = _mm256_sub_ps(targetX, _mm256_set1_ps(projOrigin.x));
-            const __m256 deltaY = _mm256_sub_ps(targetY, _mm256_set1_ps(projOrigin.y));
-            const __m256 deltaZ = _mm256_sub_ps(targetZ, _mm256_set1_ps(projOrigin.z));
+            const __m256 delta_x = _mm256_sub_ps(target_x, _mm256_set1_ps(proj_origin.x));
+            const __m256 delta_y = _mm256_sub_ps(target_y, _mm256_set1_ps(proj_origin.y));
+            const __m256 delta_z = _mm256_sub_ps(target_z, _mm256_set1_ps(proj_origin.z));

-            const __m256 dSqr = _mm256_add_ps(_mm256_mul_ps(deltaX, deltaX), _mm256_mul_ps(deltaY, deltaY));
+            const __m256 d_sqr = _mm256_add_ps(_mm256_mul_ps(delta_x, delta_x), _mm256_mul_ps(delta_y, delta_y));

-            const __m256 bgTimesSq = _mm256_mul_ps(_mm256_set1_ps(bulletGravity), timesSq);
-            const __m256 term = _mm256_add_ps(deltaZ, _mm256_mul_ps(_mm256_set1_ps(0.5f), bgTimesSq));
-            const __m256 termSq = _mm256_mul_ps(term, term);
-            const __m256 numerator = _mm256_add_ps(dSqr, termSq);
-            const __m256 denominator = _mm256_add_ps(timesSq, _mm256_set1_ps(1e-8f)); // Avoid division by zero
-            const __m256 requiredV0Sqr = _mm256_div_ps(numerator, denominator);
+            const __m256 bg_times_sq = _mm256_mul_ps(_mm256_set1_ps(bullet_gravity), times_sq);
+            const __m256 term = _mm256_add_ps(delta_z, _mm256_mul_ps(_mm256_set1_ps(0.5f), bg_times_sq));
+            const __m256 term_sq = _mm256_mul_ps(term, term);
+            const __m256 numerator = _mm256_add_ps(d_sqr, term_sq);
+            const __m256 denominator = _mm256_add_ps(times_sq, _mm256_set1_ps(1e-8f)); // Avoid division by zero
+            const __m256 required_v0_sqr = _mm256_div_ps(numerator, denominator);

-            const __m256 v0SqrVec = _mm256_set1_ps(v0Sqr + 1e-3f);
-            const __m256 mask = _mm256_cmp_ps(requiredV0Sqr, v0SqrVec, _CMP_LE_OQ);
+            const __m256 v0_sqr_vec = _mm256_set1_ps(v0_sqr + 1e-3f);
+            const __m256 mask = _mm256_cmp_ps(required_v0_sqr, v0_sqr_vec, _CMP_LE_OQ);

-            const unsigned validMask = _mm256_movemask_ps(mask);
+            const unsigned valid_mask = _mm256_movemask_ps(mask);

-            if (!validMask)
+            if (!valid_mask)
                continue;

-            alignas(32) float validTimes[SIMD_FACTOR];
-            _mm256_store_ps(validTimes, times);
+            alignas(32) float valid_times[SIMD_FACTOR];
+            _mm256_store_ps(valid_times, times);

            for (int i = 0; i < SIMD_FACTOR; ++i)
            {
-                if (!(validMask & (1 << i)))
+                if (!(valid_mask & (1 << i)))
                    continue;

-                const float candidateTime = validTimes[i];
+                const float candidate_time = valid_times[i];

-                if (candidateTime > m_maximumSimulationTime)
+                if (candidate_time > m_maximum_simulation_time)
                    continue;

                // Fine search around candidate time
-                for (float fineTime = candidateTime - m_simulationTimeStep * 2;
-                     fineTime <= candidateTime + m_simulationTimeStep * 2; fineTime += m_simulationTimeStep)
+                for (float fine_time = candidate_time - m_simulation_time_step * 2;
+                     fine_time <= candidate_time + m_simulation_time_step * 2; fine_time += m_simulation_time_step)
                {
-                    if (fineTime < 0)
+                    if (fine_time < 0)
                        continue;

-                    const Vector3 targetPos = target.PredictPosition(fineTime, m_gravityConstant);
-                    const auto pitch = CalculatePitch(projOrigin, targetPos, bulletGravity, v0, fineTime);
+                    // Manually compute predicted target position to avoid adding method to Target
+                    Vector3 target_pos = target.m_origin + target.m_velocity * fine_time;
+                    if (target.m_is_airborne)
+                        target_pos.z -= 0.5f * m_gravity_constant * fine_time * fine_time;
+
+                    const auto pitch = calculate_pitch(proj_origin, target_pos, bullet_gravity, v0, fine_time);
                    if (!pitch)
                        continue;

-                    const Vector3 delta = targetPos - projOrigin;
+                    const Vector3 delta = target_pos - proj_origin;
                    const float d = std::sqrt(delta.x * delta.x + delta.y * delta.y);
-                    const float height = d * std::tan(angles::DegreesToRadians(*pitch));
-                    return Vector3(targetPos.x, targetPos.y, projOrigin.z + height);
+                    const float height = d * std::tan(angles::degrees_to_radians(*pitch));
+                    return Vector3(target_pos.x, target_pos.y, proj_origin.z + height);
                }
            }
        }

        // Fallback scalar processing for remaining times
-        for (; currentTime <= m_maximumSimulationTime; currentTime += m_simulationTimeStep)
+        for (; current_time <= m_maximum_simulation_time; current_time += m_simulation_time_step)
        {
-            const Vector3 targetPos = target.PredictPosition(currentTime, m_gravityConstant);
-            const auto pitch = CalculatePitch(projOrigin, targetPos, bulletGravity, v0, currentTime);
+            Vector3 target_pos = target.m_origin + target.m_velocity * current_time;
+            if (target.m_is_airborne)
+                target_pos.z -= 0.5f * m_gravity_constant * current_time * current_time;
+
+            const auto pitch = calculate_pitch(proj_origin, target_pos, bullet_gravity, v0, current_time);
            if (!pitch)
                continue;

-            const Vector3 delta = targetPos - projOrigin;
+            const Vector3 delta = target_pos - proj_origin;
            const float d = std::sqrt(delta.x * delta.x + delta.y * delta.y);
-            const float height = d * std::tan(angles::DegreesToRadians(*pitch));
-            return Vector3(targetPos.x, targetPos.y, projOrigin.z + height);
+            const float height = d * std::tan(angles::degrees_to_radians(*pitch));
+            return Vector3(target_pos.x, target_pos.y, proj_origin.z + height);
        }

        return std::nullopt;
@@ -134,22 +141,22 @@ namespace omath::projectile_prediction
            return std::nullopt;

        const Vector3 delta = target_pos - proj_origin;
-        const float dSqr = delta.x * delta.x + delta.y * delta.y;
+        const float d_sqr = delta.x * delta.x + delta.y * delta.y;
        const float h = delta.z;

        const float term = h + 0.5f * bullet_gravity * time * time;
-        const float requiredV0Sqr = (dSqr + term * term) / (time * time);
-        const float v0Sqr = v0 * v0;
+        const float required_v0_sqr = (d_sqr + term * term) / (time * time);
+        const float v0_sqr = v0 * v0;

-        if (requiredV0Sqr > v0Sqr + 1e-3f)
+        if (required_v0_sqr > v0_sqr + 1e-3f)
            return std::nullopt;

-        if (dSqr == 0.0f)
+        if (d_sqr == 0.0f)
            return term >= 0.0f ? 90.0f : -90.0f;

-        const float d = std::sqrt(dSqr);
-        const float tanTheta = term / d;
-        return angles::RadiansToDegrees(std::atan(tanTheta));
+        const float d = std::sqrt(d_sqr);
+        const float tan_theta = term / d;
+        return angles::radians_to_degrees(std::atan(tan_theta));
 #else
        throw std::runtime_error(
                std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
--- a/source/utility/pe_pattern_scan.cpp
+++ b/source/utility/pe_pattern_scan.cpp
@@ -7,9 +7,6 @@
 #include <span>
 #include <stdexcept>
 #include <variant>
-#ifdef _WIN32
-#include <Windows.h>
-#endif

 // Internal PE shit defines
 // Big thx for linuxpe sources as ref
@@ -206,6 +203,26 @@ namespace
        return x64_headers;
    }

+    [[nodiscard]]
+    std::optional<NtHeaderVariant> get_nt_header_from_loaded_module(const void* module_base_address)
+    {
+        const auto module_byte_ptr = static_cast<const std::byte*>(module_base_address);
+        ImageNtHeaders<NtArchitecture::x32_bit> x86_headers{};
+        const auto dos_header = static_cast<const DosHeader*>(module_base_address);
+
+        x86_headers = *reinterpret_cast<const ImageNtHeaders<NtArchitecture::x32_bit>*>(module_byte_ptr
+                                                                                        + dos_header->e_lfanew);
+
+        if (x86_headers.optional_header.magic == opt_hdr32_magic)
+            return x86_headers;
+
+        if (x86_headers.optional_header.magic != opt_hdr64_magic)
+            return std::nullopt;
+
+        return *reinterpret_cast<const ImageNtHeaders<NtArchitecture::x64_bit>*>(module_byte_ptr
+                                                                                 + dos_header->e_lfanew);
+    }
+
    [[nodiscard]]
    constexpr bool invalid_dos_header_file(const DosHeader& dos_header)
    {
@@ -216,7 +233,8 @@ namespace
    constexpr bool invalid_nt_header_file(const NtHeaderVariant& variant)
    {
        constexpr std::uint32_t nt_hdr_magic = 0x4550;
-        return std::visit([](const auto& header) -> bool { return header.signature != nt_hdr_magic; }, variant);
+        return std::visit([&nt_hdr_magic](const auto& header) -> bool { return header.signature != nt_hdr_magic; },
+                          variant);
    }

    struct ExtractedSection
@@ -286,35 +304,37 @@ namespace
 namespace omath
 {

-    std::optional<std::uintptr_t>
-    PePatternScanner::scan_for_pattern_in_loaded_module([[maybe_unused]] const std::string_view& module_name,
-                                                        [[maybe_unused]] const std::string_view& pattern)
+    std::optional<std::uintptr_t> PePatternScanner::scan_for_pattern_in_loaded_module(const void* module_base_address,
+                                                                                      const std::string_view& pattern)
    {
-#ifdef _WIN32
-        const auto base_address = reinterpret_cast<std::uintptr_t>(GetModuleHandleA(module_name.data()));
+        const auto base_address = reinterpret_cast<std::uintptr_t>(module_base_address);

        if (!base_address)
            return std::nullopt;

-        const auto dos_headers = reinterpret_cast<PIMAGE_DOS_HEADER>(base_address);
-        const auto image_nt_headers = reinterpret_cast<PIMAGE_NT_HEADERS>(base_address + dos_headers->e_lfanew);
+        auto nt_header_variant = get_nt_header_from_loaded_module(module_base_address);

+        if (!nt_header_variant)
+            return std::nullopt;
+
+        return std::visit(
+                [base_address, &pattern](const auto& nt_header) -> std::optional<std::uintptr_t>
+                {
                    // Define .code segment as scan area
-        const auto start = image_nt_headers->OptionalHeader.BaseOfCode;
-        const auto scan_size = image_nt_headers->OptionalHeader.SizeOfCode;
+                    const auto start = nt_header.optional_header.base_of_code;
+                    const auto scan_size = nt_header.optional_header.size_code;

                    const auto scan_range = std::span{reinterpret_cast<std::byte*>(base_address) + start, scan_size};

                    // 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;
-#else
-        throw std::runtime_error("Pattern scan for loaded modules is only for windows platform");
-#endif
+                },
+                nt_header_variant.value());
    }
    std::optional<PeSectionScanResult>
    PePatternScanner::scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -15,5 +15,11 @@ set_target_properties(${PROJECT_NAME} PROPERTIES
        CXX_STANDARD_REQUIRED ON)


+
+if (TARGET gtest) # GTest is being linked as submodule
    target_link_libraries(${PROJECT_NAME} PRIVATE gtest gtest_main omath::omath)
+else() # GTest is being linked as vcpkg package
+    find_package(GTest CONFIG REQUIRED)
+    target_link_libraries(${PROJECT_NAME} PRIVATE GTest::gtest GTest::gtest_main omath::omath)
+endif()
 gtest_discover_tests(${PROJECT_NAME})
--- a/tests/engines/unit_test_frostbite_engine.cpp
+++ b/tests/engines/unit_test_frostbite_engine.cpp
@@ -0,0 +1,236 @@
+//
+// Created by Vlad on 10/23/2025.
+//
+#include <gtest/gtest.h>
+#include <omath/engines/frostbite_engine/camera.hpp>
+#include <omath/engines/frostbite_engine/constants.hpp>
+#include <omath/engines/frostbite_engine/formulas.hpp>
+#include <print>
+#include <random>
+
+TEST(unit_test_frostbite_engine, ForwardVector)
+{
+    const auto forward = omath::frostbite_engine::forward_vector({});
+
+    EXPECT_EQ(forward, omath::frostbite_engine::k_abs_forward);
+}
+
+TEST(unit_test_frostbite_engine, ForwardVectorRotationYaw)
+{
+    omath::frostbite_engine::ViewAngles angles;
+
+    angles.yaw = omath::frostbite_engine::YawAngle::from_degrees(90.f);
+
+    const auto forward = omath::frostbite_engine::forward_vector(angles);
+    EXPECT_NEAR(forward.x, omath::frostbite_engine::k_abs_right.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::frostbite_engine::k_abs_right.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::frostbite_engine::k_abs_right.z, 0.00001f);
+}
+
+TEST(unit_test_frostbite_engine, ForwardVectorRotationPitch)
+{
+    omath::frostbite_engine::ViewAngles angles;
+
+    angles.pitch = omath::frostbite_engine::PitchAngle::from_degrees(-90.f);
+
+    const auto forward = omath::frostbite_engine::forward_vector(angles);
+    EXPECT_NEAR(forward.x, omath::frostbite_engine::k_abs_up.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::frostbite_engine::k_abs_up.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::frostbite_engine::k_abs_up.z, 0.00001f);
+}
+
+TEST(unit_test_frostbite_engine, ForwardVectorRotationRoll)
+{
+    omath::frostbite_engine::ViewAngles angles;
+
+    angles.roll = omath::frostbite_engine::RollAngle::from_degrees(-90.f);
+
+    const auto forward = omath::frostbite_engine::up_vector(angles);
+    EXPECT_NEAR(forward.x, omath::frostbite_engine::k_abs_right.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::frostbite_engine::k_abs_right.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::frostbite_engine::k_abs_right.z, 0.00001f);
+}
+
+TEST(unit_test_frostbite_engine, RightVector)
+{
+    const auto right = omath::frostbite_engine::right_vector({});
+
+    EXPECT_EQ(right, omath::frostbite_engine::k_abs_right);
+}
+
+TEST(unit_test_frostbite_engine, UpVector)
+{
+    const auto up = omath::frostbite_engine::up_vector({});
+    EXPECT_EQ(up, omath::frostbite_engine::k_abs_up);
+}
+
+TEST(unit_test_frostbite_engine, ProjectTargetMovedFromCamera)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const auto cam = omath::frostbite_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});
+
+        EXPECT_TRUE(projected.has_value());
+
+        if (!projected.has_value())
+            continue;
+
+        EXPECT_NEAR(projected->x, 640, 0.00001f);
+        EXPECT_NEAR(projected->y, 360, 0.00001f);
+    }
+}
+TEST(unit_test_frostbite_engine, Project)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+
+    const auto cam = omath::frostbite_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+    const auto proj = cam.world_to_screen<omath::frostbite_engine::Camera::ScreenStart::BOTTOM_LEFT_CORNER>({10.f, 3, 10.f});
+
+    EXPECT_NEAR(proj->x, 1263.538, 0.001f);
+    EXPECT_NEAR(proj->y, 547.061f, 0.001f);
+}
+
+TEST(unit_test_frostbite_engine, CameraSetAndGetFov)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::frostbite_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
+    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_frostbite_engine, CameraSetAndGetOrigin)
+{
+    auto cam = omath::frostbite_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
+    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_frostbite_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::frostbite_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_frostbite_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::frostbite_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_frostbite_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::frostbite_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_frostbite_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::frostbite_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);
+}
--- 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_imgui_intergration.cpp
+++ b/tests/general/unit_test_imgui_intergration.cpp
@@ -0,0 +1,39 @@
+//
+// Created by Vlad on 10/23/2025.
+//
+#ifdef OMATH_IMGUI_INTEGRATION
+#include <omath/omath.hpp>
+#include <gtest/gtest.h>
+
+#define IMGUI_DEFINE_MATH_OPERATORS
+#include <imgui.h>
+
+
+
+using namespace omath;
+
+TEST(unit_test_imgui_intergration, Vector2ToImVec2)
+{
+    constexpr Vector2 omath_vector_2d = {1.f, 2.f};
+    constexpr ImVec2 imgui_vector_2d = {1, 2.f};
+
+    constexpr auto converted = omath_vector_2d.to_im_vec2();
+    EXPECT_NEAR(converted.x, imgui_vector_2d.x, 1.e-5f);
+    EXPECT_NEAR(converted.y, imgui_vector_2d.y, 1.e-5f);
+}
+
+TEST(unit_test_imgui_intergration, Vector4ToImVec4)
+{
+    constexpr Vector4 omath_vector_2d = {1.f, 2.f, 3.f, 4.f};
+    constexpr ImVec4 imgui_vector_4d = {1, 2.f, 3.f, 4.f};
+
+    constexpr auto converted = omath_vector_2d.to_im_vec4();
+
+    EXPECT_NEAR(converted.x, imgui_vector_4d.x, 1.e-5f);
+    EXPECT_NEAR(converted.y, imgui_vector_4d.y, 1.e-5f);
+    EXPECT_NEAR(converted.z, imgui_vector_4d.z, 1.e-5f);
+    EXPECT_NEAR(converted.w, imgui_vector_4d.w, 1.e-5f);
+}
+
+
+#endif
--- 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);
+}
--- a/vcpkg-configuration.json
+++ b/vcpkg-configuration.json
@@ -0,0 +1,14 @@
+{
+  "default-registry": {
+    "kind": "git",
+    "baseline": "b1b19307e2d2ec1eefbdb7ea069de7d4bcd31f01",
+    "repository": "https://github.com/microsoft/vcpkg"
+  },
+  "registries": [
+    {
+      "kind": "artifact",
+      "location": "https://github.com/microsoft/vcpkg-ce-catalog/archive/refs/heads/main.zip",
+      "name": "microsoft"
+    }
+  ]
+}
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -0,0 +1,42 @@
+{
+  "name": "omath",
+  "version": "3.10.1",
+  "description": "General purpose math library",
+  "homepage": "https://github.com/orange-cpp/omath",
+  "license": "Zlib",
+  "supports": "windows | linux",
+  "dependencies": [
+    {
+      "name": "vcpkg-cmake",
+      "host": true
+    },
+    {
+      "name": "vcpkg-cmake-config",
+      "host": true
+    }
+  ],
+  "features": {
+    "avx2": {
+      "description": "Omath will use AVX2 to boost performance",
+      "supports": "!arm"
+    },
+    "benchmark": {
+      "description": "Build benchmarks",
+      "dependencies": [
+        "benchmark"
+      ]
+    },
+    "imgui": {
+      "description": "Omath will define method to convert omath types to imgui types",
+      "dependencies": [
+        "imgui"
+      ]
+    },
+    "tests": {
+      "description": "Build unit-tests using GTest",
+      "dependencies": [
+        "gtest"
+      ]
+    }
+  }
+}
Author	SHA1	Message	Date
Orange++	7d194a5c36	Merge pull request #95 from orange-cpp/pathfinding_improvement removed brackets	2025-10-30 05:44:00 +03:00
Orange	eec34c1efb	removed brackets Initial plan Initial exploration and analysis complete Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com> Optimize performance: A* pathfinding, Vector3 hash, pattern scanner, AVX2 code, and serialization Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com> Add bounds check for navigation mesh serialization Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com> Document serialization limitation for large neighbor counts Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com> Add _codeql_build_dir to gitignore Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com> Removes codeql detected source root Eliminates the automatically generated file that was causing issues. This file was added by codeql and no longer needed. revert cleaned up gitignore moved to anon namespace Improves navigation mesh serialization and clamping Ensures correct serialization of navigation meshes by clamping neighbor counts to prevent data corruption when exceeding uint16_t limits. Updates data types to `std::uint8_t` and `std::size_t` for consistency. Uses `std::copy_n` instead of `std::memcpy` for deserialization.	2025-10-30 05:38:58 +03:00
Orange	765d5e7216	fixed typo	2025-10-30 05:37:34 +03:00
Orange	7cb8a4de52	Clarifies release process for stable builds Explains that changes merged into master won't reach stable users unless the `stable` tag is updated.	2025-10-28 01:21:41 +03:00
Orange++	d2fbc286b1	Merge pull request #93 from orange-cpp/feaure/small_improvement removed useless option	2025-10-28 01:19:21 +03:00
Orange	64385757af	fix	2025-10-28 01:15:36 +03:00
Orange	ea7b812645	removed	2025-10-28 01:11:02 +03:00
Orange	b214cdf3a1	removed useless option	2025-10-28 01:09:47 +03:00
Orange	dccc12ee30	added some comments	2025-10-27 11:25:31 +03:00
Orange	60e744978c	force disabled tests	2025-10-27 11:22:24 +03:00
Orange++	495a2a80e4	Merge pull request #92 from orange-cpp/feature/projection_utility added vcpkg integration	2025-10-27 11:11:28 +03:00
Orange	6fbc010fa1	considered to switch to v4	2025-10-27 11:05:55 +03:00
Orange	c8f77de4f2	updated version	2025-10-27 10:59:30 +03:00
Orange	5c2d09b175	patch	2025-10-27 10:58:26 +03:00
Orange	b3646ab708	Adds default and artifact registries Configures the default Vcpkg registry and adds an artifact registry for the microsoft catalog. This enables the tool to find and use pre-built packages from the Microsoft catalog.	2025-10-27 10:57:57 +03:00
Orange	d751eaf132	Adds Darwin build presets with Vcpkg support Adds new CMake presets for Darwin platforms, including debug and release configurations with optional Vcpkg integration. This allows for easier builds on Darwin systems utilizing pre-built libraries from Vcpkg.	2025-10-27 09:57:12 +03:00
Orange	62e7ccb054	Update CMake configuration for Vcpkg integration and feature enablement. Enables features and sets build configurations via Vcpkg manifest. Adds new presets for Windows and Linux debug/release builds using Vcpkg. Conditionally enables features (imgui, avx2, tests, benchmark) based on Vcpkg manifest features.	2025-10-27 09:55:49 +03:00
Orange	4d9e055bb3	Fixes invalid NT header check in variant Ensures the NT header signature check uses a capture to avoid potential issues with variable scope.	2025-10-27 09:22:00 +03:00
Orange	9be7ca886d	Disables Vcpkg build override Disables the automatic override of build options by Vcpkg. This prevents unintended consequences when using Vcpkg and allows for more control over the build process.	2025-10-27 09:19:51 +03:00
Orange	30568f3633	Disables tests and benchmarks by default for VCPKG Changes the default state of `OMATH_BUILD_TESTS` and `OMATH_BUILD_BENCHMARK` to OFF when built via VCPKG. Previously, these flags were inherited from the project's top level. This change ensures that these are explicitly enabled via VCPKG manifest features, providing better control over build configuration.	2025-10-27 09:19:09 +03:00
Orange	5f22499b66	Links tests to gtest when available Conditionally links the test target to gtest when it is available, rather than requiring the OMATH_BUILD_VIA_VCPKG flag to be false. This allows for a more flexible test setup.	2025-10-27 09:05:40 +03:00
Orange	f75afb8354	fix	2025-10-27 08:59:42 +03:00
Orange	e38df8bd23	Removes baseline from omath vcpkg.json Eliminates the `builtin-baseline` setting from the omath vcpkg.json file. This setting is no longer necessary.	2025-10-27 08:56:37 +03:00
Orange	ae347c8509	fix	2025-10-27 08:51:58 +03:00
Orange	ee40979a2d	fix	2025-10-27 08:41:22 +03:00
Orange	69d0b7b829	fix	2025-10-27 08:37:55 +03:00
Orange	490ccfe983	fix	2025-10-27 08:36:48 +03:00
Orange	5630c2708e	Update build system and enable VCPKG Migrates to CMake presets and enables VCPKG to manage dependencies. Removes explicit submodule configuration. Updates benchmark and googletest to be integrated or linked properly. The goal is to ease the build process and reduce complexity related to linking and dependency management.	2025-10-27 08:34:05 +03:00
Orange	ed7220dc9c	Configures CMake for Vcpkg integration Sets up CMake presets to utilize the Vcpkg toolchain. Specifies the Vcpkg root directory and manifest features. Defines the installation directory for Vcpkg packages. Forces the usage of Ninja as the make program.	2025-10-27 08:11:13 +03:00
Orange	5e4fae9e42	Enables Vcpkg usage for CMake builds Configures CMake to utilize vcpkg for dependency management on both Linux and Windows platforms. This ensures consistent build environments across different operating systems and simplifies the integration of external libraries.	2025-10-27 08:07:25 +03:00
Orange	063f43e74c	fix	2025-10-27 08:03:42 +03:00
Orange	171b4ca3da	Adds Vcpkg setup to CI workflows Adds vcpkg setup for Arch Linux and Windows CI jobs. This ensures consistent dependency management and builds via Vcpkg for both platforms and enables OMath to build via vcpkg. Clones the vcpkg repository and bootstraps it during the job execution.	2025-10-27 08:00:53 +03:00
Orange	878e3358c0	Adds vcpkg integration and updates build configuration Configures CMakePresets.json to utilize vcpkg for dependency management. Adds support for building with vcpkg. Adds error message for missing VCPKG_ROOT environment variable. Adds explicit VCPKG_MANIFEST_FEATURES and VCPKG_INSTALLED_DIR to CMakePresets.json. Adds benchmark dependency to vcpkg.json.	2025-10-27 07:53:53 +03:00
Orange	81aef68143	Adds support for tests and benchmarks via Vcpkg features Enables building unit tests using GTest and benchmarks using Benchmark, through Vcpkg features. Adds `tests` and `benchmark` features to `vcpkg.json`, and adds corresponding CMake logic to control their build based on Vcpkg manifest features.	2025-10-27 06:42:43 +03:00
Orange++	e2a37f2c81	Fix formatting and spacing in LICENSE file Corrected formatting and removed extra spaces in the LICENSE file.	2025-10-27 02:32:06 +03:00
Orange	69575c1cb3	added additional check	2025-10-23 06:43:09 +03:00
Orange	8adf5db409	added vcpkg manifest file	2025-10-23 06:35:22 +03:00
Orange	2c7e443f52	added contained type alias	2025-10-23 06:26:57 +03:00
Orange	6ad4ef29e9	fix	2025-10-23 01:08:19 +03:00
Orange++	8feb805067	Remove 'future' from affiliation clause in LICENSE	2025-10-23 01:00:40 +03:00
Orange	816da38987	added frostbite into global header	2025-10-23 00:55:49 +03:00
Orange	0ba795c767	added Frostbite into readme	2025-10-23 00:50:35 +03:00
Orange	88b709f531	deleted not needed header	2025-10-23 00:49:54 +03:00
Orange	a7eacb529e	updated comments	2025-10-23 00:48:54 +03:00
Orange++	5a4026a4fc	Merge pull request #91 from orange-cpp/feature/frostbite_engine Defines constants for Frostbite engine	2025-10-23 00:18:07 +03:00
Orange	404c7de594	added frostbite sources	2025-10-23 00:08:17 +03:00
Orange	f26f48cc53	Defines constants for Frostbite engine Introduces a constants header file for the Frostbite engine, including common vectors, matrices, and angle types. This provides a centralized location for defining and accessing essential mathematical constants used throughout the engine.	2025-10-21 04:56:49 +03:00
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
Orange++	568883ff1c	Merge pull request #87 from orange-cpp/feature/no_win_api Removes Windows-specific API dependencies for pattern scanning	2025-10-13 14:25:03 +03:00
Orange++	97003b953a	Update README.md	2025-10-13 14:24:53 +03:00
Orange	5646654317	Removes Windows-specific API dependencies for pattern scanning Replaces calls to Windows API functions (GetModuleHandleA) with a void pointer parameter. Simplifies pattern scanning for loaded modules by removing Windows-specific code and replacing it with a generic approach.	2025-10-13 14:17:30 +03:00
@@ -1 +1 @@
 .9.2
 .0.0