added frostbite into global header

Defines constants for Frostbite engine

.idea/editor.xml

@@ -201,7 +201,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticDataMemberInUnnamedStruct/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticSpecifierOnAnonymousNamespaceMember/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStringLiteralToCharPointerConversion/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateArgumentsCanBeDeduced/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterNeverUsed/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterShadowing/@EntryIndexedValue" value="WARNING" type="string" />
@@ -215,7 +215,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaEndRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnamedNamespaceInHeaderFile/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnsignedZeroComparison/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnusedIncludeDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUseAlgorithmWithCount/@EntryIndexedValue" value="SUGGESTION" type="string" />

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.26)
 
-project(omath VERSION 3.8.2 LANGUAGES CXX)
+project(omath VERSION 3.9.2 LANGUAGES CXX)
 
 include(CMakePackageConfigHelpers)
 include(CheckCXXCompilerFlag)
@@ -28,22 +28,23 @@ if (OMATH_USE_AVX2 AND NOT COMPILER_SUPPORTS_AVX2)
     set(OMATH_USE_AVX2 OFF CACHE BOOL "Omath will use AVX2 to boost performance" FORCE)
 endif ()
 
-message(STATUS "[${PROJECT_NAME}]: Building on ${CMAKE_HOST_SYSTEM_NAME}, compiler ${CMAKE_CXX_COMPILER_ID}")
-message(STATUS "[${PROJECT_NAME}]: Warnings as errors ${OMATH_THREAT_WARNING_AS_ERROR}")
-message(STATUS "[${PROJECT_NAME}]: Build unit tests ${OMATH_BUILD_TESTS}")
-message(STATUS "[${PROJECT_NAME}]: Build benchmark ${OMATH_BUILD_BENCHMARK}")
-message(STATUS "[${PROJECT_NAME}]: As dynamic library ${OMATH_BUILD_AS_SHARED_LIBRARY}")
-message(STATUS "[${PROJECT_NAME}]: Static C++ runtime ${OMATH_STATIC_MSVC_RUNTIME_LIBRARY}")
-message(STATUS "[${PROJECT_NAME}]: CMake unity build ${OMATH_USE_UNITY_BUILD}")
-message(STATUS "[${PROJECT_NAME}]: Example projects ${OMATH_BUILD_EXAMPLES}")
-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}")
+if (${PROJECT_IS_TOP_LEVEL})
+    message(STATUS "[${PROJECT_NAME}]: Building on ${CMAKE_HOST_SYSTEM_NAME}, compiler ${CMAKE_CXX_COMPILER_ID}")
+    message(STATUS "[${PROJECT_NAME}]: Warnings as errors ${OMATH_THREAT_WARNING_AS_ERROR}")
+    message(STATUS "[${PROJECT_NAME}]: Build unit tests ${OMATH_BUILD_TESTS}")
+    message(STATUS "[${PROJECT_NAME}]: Build benchmark ${OMATH_BUILD_BENCHMARK}")
+    message(STATUS "[${PROJECT_NAME}]: As dynamic library ${OMATH_BUILD_AS_SHARED_LIBRARY}")
+    message(STATUS "[${PROJECT_NAME}]: Static C++ runtime ${OMATH_STATIC_MSVC_RUNTIME_LIBRARY}")
+    message(STATUS "[${PROJECT_NAME}]: CMake unity build ${OMATH_USE_UNITY_BUILD}")
+    message(STATUS "[${PROJECT_NAME}]: Example projects ${OMATH_BUILD_EXAMPLES}")
+    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}")
+endif ()
 
 file(GLOB_RECURSE OMATH_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp")
 file(GLOB_RECURSE OMATH_HEADERS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp")
 
-
 if (OMATH_BUILD_AS_SHARED_LIBRARY)
     add_library(${PROJECT_NAME} SHARED ${OMATH_SOURCES} ${OMATH_HEADERS})
 else ()
@@ -111,8 +112,8 @@ if (OMATH_USE_AVX2)
         target_compile_options(${PROJECT_NAME} PUBLIC -msimd128 -mavx2)
     elseif (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|AppleClang")
         target_compile_options(${PROJECT_NAME} PUBLIC -mfma -mavx2)
-    endif()
-endif()
+    endif ()
+endif ()
 
 target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_23)
 

INSTALL.md

@@ -59,7 +59,7 @@ target("...")
    cmake --preset windows-release -S .
    cmake --build cmake-build/build/windows-release --target omath -j 6
    ```
-   Use **\<platform\>-\<build configuration\>** preset to build siutable version for yourself. Like **windows-release** or **linux-release**.
+   Use **\<platform\>-\<build configuration\>** preset to build suitable version for yourself. Like **windows-release** or **linux-release**.
 
     | Platform Name | Build Config  |
     |---------------|---------------|

LICENSE

@@ -20,6 +20,7 @@ freely, subject to the following restrictions:
    with any of the following entities:
      * "Yandex" LLC
      * "Rutube" LLC
+     * "Kaspersky" LLC
    Or if you represent or are associated with any legal, organizational, or 
    professional entity providing services to or on behalf of the aforementioned entities:
    You are expressly forbidden from accessing, using, modifying, distributing, or

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

VERSION

@@ -1 +1 @@
-3.8.2
+3.9.2

docs/index.md

@@ -0,0 +1,17 @@
+# Welcome to MkDocs
+
+For full documentation visit [mkdocs.org](https://www.mkdocs.org).
+
+## Commands
+
+* `mkdocs new [dir-name]` - Create a new project.
+* `mkdocs serve` - Start the live-reloading docs server.
+* `mkdocs build` - Build the documentation site.
+* `mkdocs -h` - Print help message and exit.
+
+## Project layout
+
+    mkdocs.yml    # The configuration file.
+    docs/
+        index.md  # The documentation homepage.
+        ...       # Other markdown pages, images and other files.

include/omath/3d_primitives/box.hpp

@@ -3,8 +3,8 @@
 //
 
 #pragma once
+#include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
-#include "omath/triangle.hpp"
 #include <array>
 
 namespace omath::primitives

include/omath/3d_primitives/plane.hpp

@@ -3,8 +3,8 @@
 //
 
 #pragma once
+#include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
-#include "omath/triangle.hpp"
 #include <array>
 
 namespace omath::primitives

include/omath/collision/line_tracer.hpp

@@ -3,8 +3,8 @@
 //
 #pragma once
 
+#include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
-#include "omath/triangle.hpp"
 
 namespace omath::collision
 {

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

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

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

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

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

include/omath/engines/iw_engine/constants.hpp

@@ -5,8 +5,8 @@
 #pragma once
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/vector3.hpp"
-#include <omath/angle.hpp>
-#include <omath/view_angles.hpp>
+#include <omath/trigonometry/angle.hpp>
+#include <omath/trigonometry/view_angles.hpp>
 
 namespace omath::iw_engine
 {

include/omath/engines/opengl_engine/constants.hpp

@@ -5,8 +5,8 @@
 
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/vector3.hpp"
-#include <omath/angle.hpp>
-#include <omath/view_angles.hpp>
+#include <omath/trigonometry/angle.hpp>
+#include <omath/trigonometry/view_angles.hpp>
 
 namespace omath::opengl_engine
 {

include/omath/engines/source_engine/constants.hpp

@@ -5,8 +5,8 @@
 
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/vector3.hpp"
-#include <omath/angle.hpp>
-#include <omath/view_angles.hpp>
+#include <omath/trigonometry/angle.hpp>
+#include <omath/trigonometry/view_angles.hpp>
 
 namespace omath::source_engine
 {

include/omath/engines/unity_engine/constants.hpp

@@ -6,8 +6,8 @@
 
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/vector3.hpp"
-#include <omath/angle.hpp>
-#include <omath/view_angles.hpp>
+#include <omath/trigonometry/angle.hpp>
+#include <omath/trigonometry/view_angles.hpp>
 
 namespace omath::unity_engine
 {

include/omath/engines/unreal_engine/constants.hpp

@@ -6,8 +6,8 @@
 
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/vector3.hpp"
-#include <omath/angle.hpp>
-#include <omath/view_angles.hpp>
+#include <omath/trigonometry/angle.hpp>
+#include <omath/trigonometry/view_angles.hpp>
 
 namespace omath::unreal_engine
 {

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
         {

include/omath/linear_algebra/triangle.hpp

@@ -2,7 +2,7 @@
 // Created by Orange on 11/13/2024.
 //
 #pragma once
-#include "linear_algebra/vector3.hpp"
+#include "vector3.hpp"
 
 namespace omath
 {

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)
 {

include/omath/linear_algebra/vector3.hpp

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "omath/angle.hpp"
+#include "omath/trigonometry/angle.hpp"
 #include "omath/linear_algebra/vector2.hpp"
 #include <cstdint>
 #include <expected>
@@ -245,15 +245,6 @@ namespace omath
             return std::make_tuple(this->x, this->y, z);
         }
 
-        [[nodiscard]] Vector3 view_angle_to(const Vector3& other) const noexcept
-        {
-            const auto distance = distance_to(other);
-            const auto delta = other - *this;
-
-            return {angles::radians_to_degrees(std::asin(delta.z / distance)),
-                    angles::radians_to_degrees(std::atan2(delta.y, delta.x)), 0};
-        }
-
         [[nodiscard]]
         bool operator<(const Vector3& other) const noexcept
         {
@@ -282,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;

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)
 {

include/omath/omath.hpp

@@ -6,8 +6,8 @@
 #pragma once
 
 // Basic math utilities
-#include "omath/angles.hpp"
-#include "omath/angle.hpp"
+#include "omath/trigonometry/angles.hpp"
+#include "omath/trigonometry/angle.hpp"
 
 // Vector classes (in dependency order)
 #include "omath/linear_algebra/vector2.hpp"
@@ -18,11 +18,11 @@
 #include "omath/linear_algebra/mat.hpp"
 
 // Color functionality
-#include "omath/color.hpp"
+#include "omath/utility/color.hpp"
 
 // Geometric primitives
-#include "omath/triangle.hpp"
-#include "omath/view_angles.hpp"
+#include "omath/linear_algebra/triangle.hpp"
+#include "omath/trigonometry/view_angles.hpp"
 
 // 3D primitives
 #include "omath/3d_primitives/box.hpp"
@@ -76,9 +76,25 @@
 #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"
 #include "omath/engines/unreal_engine/camera.hpp"
 #include "omath/engines/unreal_engine/traits/camera_trait.hpp"
 #include "omath/engines/unreal_engine/traits/pred_engine_trait.hpp"
+
+// Reverse Engineering
+#include "omath/rev_eng/external_rev_object.hpp"
+#include "omath/rev_eng/internal_rev_object.hpp"
+
+// Utility
+#include "omath/utility/pattern_scan.hpp"
+#include "omath/utility/pe_pattern_scan.hpp"

include/omath/projection/camera.hpp

@@ -7,8 +7,8 @@
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/vector3.hpp"
 #include "omath/projection/error_codes.hpp"
+#include <omath/trigonometry/angle.hpp>
 #include <expected>
-#include <omath/angle.hpp>
 #include <type_traits>
 
 #ifdef OMATH_BUILD_TESTS
@@ -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,9 +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
-        {
-            /*
+        // NDC REPRESENTATION:
+        /*
                                 ^
                                 |        y
                             1   |
@@ -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

include/omath/rev_eng/external_rev_object.hpp

@@ -0,0 +1,35 @@
+//
+// Created by Vlad on 10/4/2025.
+//
+
+#pragma once
+#include <cstddef>
+#include <cstdint>
+
+namespace omath::rev_eng
+{
+    template<class ExternalMemoryManagementTrait>
+    class ExternalReverseEngineeredObject
+    {
+    public:
+        explicit ExternalReverseEngineeredObject(const std::uintptr_t addr): m_object_address(addr)
+        {
+        }
+    private:
+        std::uintptr_t m_object_address{};
+
+    protected:
+        template<class Type>
+        [[nodiscard]]
+        Type get_by_offset(const std::ptrdiff_t offset) const
+        {
+            return ExternalMemoryManagementTrait::read_memory(m_object_address+offset);
+        }
+
+        template<class Type>
+        void set_by_offset(const std::ptrdiff_t offset, const Type& value) const
+        {
+            return ExternalMemoryManagementTrait::write_memory(m_object_address+offset, value);
+        }
+    };
+} // namespace omath::rev_eng

include/omath/rev_eng/internal_rev_object.hpp

@@ -0,0 +1,37 @@
+//
+// Created by Vlad on 8/8/2025.
+//
+
+#pragma once
+#include <cstddef>
+#include <cstdint>
+
+namespace omath::rev_eng
+{
+    class InternalReverseEngineeredObject
+    {
+    protected:
+        template<class Type>
+        [[nodiscard]] Type& get_by_offset(const std::ptrdiff_t offset)
+        {
+            return *reinterpret_cast<Type*>(reinterpret_cast<std::uintptr_t>(this) + offset);
+        }
+
+        template<class Type>
+        [[nodiscard]] const Type& get_by_offset(const std::ptrdiff_t offset) const
+        {
+            return *reinterpret_cast<Type*>(reinterpret_cast<std::uintptr_t>(this) + offset);
+        }
+
+        template<std::size_t id, class ReturnType>
+        ReturnType call_virtual_method(auto... arg_list)
+        {
+#ifdef _MSC_VER
+            using VirtualMethodType = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
+#else
+            using VirtualMethodType = ReturnType(*)(void*, decltype(arg_list)...);
+#endif
+            return (*reinterpret_cast<VirtualMethodType**>(this))[id](this, arg_list...);
+        }
+    };
+} // namespace omath::rev_eng

include/omath/trigonometry/angle.hpp

@@ -3,7 +3,7 @@
 //
 
 #pragma once
-#include "omath/angles.hpp"
+#include "omath/trigonometry/angles.hpp"
 #include <algorithm>
 #include <format>
 #include <utility>

include/omath/utility/color.hpp

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "linear_algebra/vector4.hpp"
+#include "omath/linear_algebra/vector4.hpp"
 #include <cstdint>
 
 namespace omath

include/omath/utility/pattern_scan.hpp

@@ -0,0 +1,78 @@
+//
+// Created by Vlad on 10/4/2025.
+//
+
+#pragma once
+#include <expected>
+#include <optional>
+#include <span>
+#include <string_view>
+#include <vector>
+
+// ReSharper disable CppInconsistentNaming
+class unit_test_pattern_scan_read_test_Test;
+class unit_test_pattern_scan_corner_case_1_Test;
+class unit_test_pattern_scan_corner_case_2_Test;
+class unit_test_pattern_scan_corner_case_3_Test;
+class unit_test_pattern_scan_corner_case_4_Test;
+// ReSharper restore CppInconsistentNaming
+namespace omath
+{
+    enum class PatternScanError
+    {
+        INVALID_PATTERN_STRING
+    };
+    class PatternScanner final
+    {
+        friend unit_test_pattern_scan_read_test_Test;
+        friend unit_test_pattern_scan_corner_case_1_Test;
+        friend unit_test_pattern_scan_corner_case_2_Test;
+        friend unit_test_pattern_scan_corner_case_3_Test;
+        friend unit_test_pattern_scan_corner_case_4_Test;
+
+    public:
+        [[nodiscard]]
+        static std::span<std::byte>::iterator scan_for_pattern(const std::span<std::byte>& range,
+                                                               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;
+
+        template<class IteratorType>
+        requires std::input_or_output_iterator<std::remove_cvref_t<IteratorType>>
+        static IteratorType scan_for_pattern(const IteratorType& begin, const IteratorType& end,
+                                             const std::string_view& pattern)
+        {
+            const auto parsed_pattern = parse_pattern(pattern);
+
+            if (!parsed_pattern) [[unlikely]]
+                return end;
+
+            const auto whole_range_size = static_cast<std::ptrdiff_t>(std::distance(begin, end));
+
+            const std::ptrdiff_t scan_size = whole_range_size - static_cast<std::ptrdiff_t>(pattern.size());
+
+            for (std::ptrdiff_t i = 0; i < scan_size; i++)
+            {
+                bool found = true;
+
+                for (std::ptrdiff_t j = 0; j < static_cast<std::ptrdiff_t>(parsed_pattern->size()); j++)
+                {
+                    found = parsed_pattern->at(j) == std::nullopt || parsed_pattern->at(j) == *(begin + i + j);
+
+                    if (!found)
+                        break;
+                }
+                if (found)
+                    return begin + i;
+            }
+            return end;
+        }
+
+    private:
+        [[nodiscard]]
+        static std::expected<std::vector<std::optional<std::byte>>, PatternScanError>
+        parse_pattern(const std::string_view& pattern_string);
+    };
+} // namespace omath

include/omath/utility/pe_pattern_scan.hpp

@@ -0,0 +1,30 @@
+//
+// Created by Vlad on 10/7/2025.
+//
+
+#pragma once
+#include <cstdint>
+#include <filesystem>
+#include <optional>
+#include <string_view>
+namespace omath
+{
+    struct PeSectionScanResult
+    {
+        std::uint64_t virtual_base_addr;
+        std::uint64_t raw_base_addr;
+        std::ptrdiff_t target_offset;
+    };
+    class PePatternScanner final
+    {
+    public:
+        [[nodiscard]]
+        static std::optional<std::uintptr_t> scan_for_pattern_in_loaded_module(const void* module_base_address,
+                                                                               const std::string_view& pattern);
+
+        [[nodiscard]]
+        static std::optional<PeSectionScanResult>
+        scan_for_pattern_in_file(const std::filesystem::path& path_to_file, const std::string_view& pattern,
+                                 const std::string_view& target_section_name = ".text");
+    };
+} // namespace omath

mkdocs.yml

@@ -0,0 +1 @@
+site_name: My Docs

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

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

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

source/utility/pattern_scan.cpp

@@ -0,0 +1,75 @@
+//
+// Created by Vlad on 10/4/2025.
+//
+#include "omath/utility/pattern_scan.hpp"
+#include <charconv>
+#include <cstdint>
+#include <algorithm>
+
+namespace
+{
+    [[nodiscard]]
+    constexpr bool is_wildcard(const std::string_view& byte_str)
+    {
+        return byte_str == "?" || byte_str == "??";
+    }
+
+    [[nodiscard]]
+    constexpr bool invalid_byte_str_size(const std::string_view& byte_str)
+    {
+        return byte_str.empty() || byte_str.size() >= 3;
+    }
+}
+
+namespace omath
+{
+
+    std::span<std::byte>::iterator
+    PatternScanner::scan_for_pattern(const std::span<std::byte>& range, const std::string_view& pattern)
+    {
+        return scan_for_pattern(range.begin(), range.end(), pattern);
+    }
+    std::expected<std::vector<std::optional<std::byte>>, PatternScanError>
+    PatternScanner::parse_pattern(const std::string_view& pattern_string)
+    {
+        std::vector<std::optional<std::byte>> pattern;
+
+        auto start = pattern_string.cbegin();
+
+        while (start != pattern_string.cend())
+        {
+            const auto end = std::ranges::find(start, pattern_string.cend(), ' ');
+
+            const auto sting_view_start = std::distance(pattern_string.cbegin(), start);
+            const auto sting_view_end = std::distance(start, end);
+
+            const std::string_view byte_str = pattern_string.substr(sting_view_start, sting_view_end);
+
+            if (invalid_byte_str_size(byte_str)) [[unlikely]]
+            {
+                start = end != pattern_string.end() ? std::next(end) : end;
+                continue;
+            }
+
+            if (is_wildcard(byte_str))
+            {
+                pattern.emplace_back(std::nullopt);
+
+                start = end != pattern_string.end() ? std::next(end) : end;
+                continue;
+            }
+
+            std::uint8_t value = 0;
+            // ReSharper disable once CppTooWideScopeInitStatement
+            const auto [_, error_code] = std::from_chars(byte_str.data(), byte_str.data() + byte_str.size(), value, 16);
+
+            if (error_code != std::errc{}) [[unlikely]]
+                return std::unexpected(PatternScanError::INVALID_PATTERN_STRING);
+
+            pattern.emplace_back(static_cast<std::byte>(value));
+
+            start = end != pattern_string.end() ? std::next(end) : end;
+        }
+        return pattern;
+    }
+} // namespace omath

source/utility/pe_pattern_scan.cpp

@@ -0,0 +1,359 @@
+//
+// Created by Vlad on 10/7/2025.
+//
+#include "omath/utility/pe_pattern_scan.hpp"
+#include "omath/utility/pattern_scan.hpp"
+#include <fstream>
+#include <span>
+#include <stdexcept>
+#include <variant>
+
+// Internal PE shit defines
+// Big thx for linuxpe sources as ref
+// Link: https://github.com/can1357/linux-pe
+namespace
+{
+    constexpr std::uint16_t opt_hdr32_magic = 0x010B;
+    constexpr std::uint16_t opt_hdr64_magic = 0x020B;
+
+    // Standard fields.
+    // ReSharper disable CppDeclaratorNeverUsed
+    struct DataDirectory final
+    {
+        std::uint32_t rva;
+        std::uint32_t size;
+    };
+    struct OptionalHeaderX64 final
+    {
+        std::uint16_t magic;
+
+        std::uint16_t linker_version;
+
+        std::uint32_t size_code;
+        std::uint32_t size_init_data;
+        std::uint32_t size_uninit_data;
+
+        std::uint32_t entry_point;
+        std::uint32_t base_of_code;
+
+        // NT additional fields.
+        std::uint64_t image_base;
+        std::uint32_t section_alignment;
+        std::uint32_t file_alignment;
+
+        std::uint32_t os_version;
+        std::uint32_t img_version;
+        std::uint32_t subsystem_version;
+        std::uint32_t win32_version_value;
+
+        std::uint32_t size_image;
+        std::uint32_t size_headers;
+
+        std::uint32_t checksum;
+        std::uint16_t subsystem;
+        std::uint16_t characteristics;
+
+        std::uint64_t size_stack_reserve;
+        std::uint64_t size_stack_commit;
+        std::uint64_t size_heap_reserve;
+        std::uint64_t size_heap_commit;
+
+        std::uint32_t ldr_flags;
+
+        std::uint32_t num_data_directories;
+        DataDirectory data_directories[16];
+    };
+    struct OptionalHeaderX86 final
+    {
+        // Standard fields.
+        std::uint16_t magic{};
+        std::uint16_t linker_version{};
+
+        std::uint32_t size_code{};
+        std::uint32_t size_init_data{};
+        std::uint32_t size_uninit_data{};
+
+        std::uint32_t entry_point{};
+        std::uint32_t base_of_code{};
+        std::uint32_t base_of_data{};
+
+        // NT additional fields.
+        std::uint32_t image_base{};
+        std::uint32_t section_alignment{};
+        std::uint32_t file_alignment{};
+
+        std::uint32_t os_version{};
+        std::uint32_t img_version{};
+        std::uint32_t subsystem_version{};
+        std::uint32_t win32_version_value{};
+
+        std::uint32_t size_image{};
+        std::uint32_t size_headers{};
+
+        std::uint32_t checksum{};
+        std::uint16_t subsystem{};
+        std::uint16_t characteristics{};
+
+        std::uint32_t size_stack_reserve{};
+        std::uint32_t size_stack_commit{};
+        std::uint32_t size_heap_reserve{};
+        std::uint32_t size_heap_commit{};
+
+        std::uint32_t ldr_flags{};
+
+        std::uint32_t num_data_directories{};
+        DataDirectory data_directories[16]{};
+    };
+    template<bool x64 = true>
+    using OptionalHeader = std::conditional_t<x64, OptionalHeaderX64, OptionalHeaderX86>;
+
+    struct FileHeader final
+    {
+        std::uint16_t machine;
+        std::uint16_t num_sections;
+        std::uint32_t timedate_stamp;
+        std::uint32_t ptr_symbols;
+        std::uint32_t num_symbols;
+        std::uint16_t size_optional_header;
+        std::uint16_t characteristics;
+    };
+
+    struct DosHeader final
+    {
+        std::uint16_t e_magic;
+        std::uint16_t e_cblp;
+        std::uint16_t e_cp;
+        std::uint16_t e_crlc;
+        std::uint16_t e_cparhdr;
+        std::uint16_t e_minalloc;
+        std::uint16_t e_maxalloc;
+        std::uint16_t e_ss;
+        std::uint16_t e_sp;
+        std::uint16_t e_csum;
+        std::uint16_t e_ip;
+        std::uint16_t e_cs;
+        std::uint16_t e_lfarlc;
+        std::uint16_t e_ovno;
+        std::uint16_t e_res[4];
+        std::uint16_t e_oemid;
+        std::uint16_t e_oeminfo;
+        std::uint16_t e_res2[10];
+        std::uint32_t e_lfanew;
+    };
+
+    enum class NtArchitecture
+    {
+        x32_bit,
+        x64_bit,
+    };
+    template<NtArchitecture architecture>
+    struct ImageNtHeaders final
+    {
+        std::uint32_t signature;
+        FileHeader file_header;
+        OptionalHeader<architecture == NtArchitecture::x64_bit> optional_header;
+    };
+
+    struct SectionHeader final
+    {
+        char name[8];
+        union
+        {
+            std::uint32_t physical_address;
+            std::uint32_t virtual_size;
+        };
+        std::uint32_t virtual_address;
+
+        std::uint32_t size_raw_data;
+        std::uint32_t ptr_raw_data;
+
+        std::uint32_t ptr_relocs;
+        std::uint32_t ptr_line_numbers;
+        std::uint32_t num_relocs;
+        std::uint32_t num_line_numbers;
+
+        std::uint32_t characteristics;
+    };
+    // ReSharper restore CppDeclaratorNeverUsed
+
+    using NtHeaderVariant =
+            std::variant<ImageNtHeaders<NtArchitecture::x64_bit>, ImageNtHeaders<NtArchitecture::x32_bit>>;
+} // namespace
+
+// Internal PE scanner functions
+namespace
+{
+    [[nodiscard]]
+    std::optional<NtHeaderVariant> get_nt_header_from_file(std::fstream& file, const DosHeader& dos_header)
+    {
+        ImageNtHeaders<NtArchitecture::x32_bit> x86_headers{};
+        file.seekg(dos_header.e_lfanew, std::ios::beg);
+        file.read(reinterpret_cast<char*>(&x86_headers), sizeof(x86_headers));
+
+        if (x86_headers.optional_header.magic == opt_hdr32_magic)
+            return x86_headers;
+
+        if (x86_headers.optional_header.magic != opt_hdr64_magic)
+            return std::nullopt;
+
+        ImageNtHeaders<NtArchitecture::x64_bit> x64_headers{};
+        file.seekg(dos_header.e_lfanew, std::ios::beg);
+        file.read(reinterpret_cast<char*>(&x64_headers), sizeof(x64_headers));
+
+        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)
+    {
+        constexpr std::uint16_t dos_hdr_magic = 0x5A4D;
+        return dos_header.e_magic != dos_hdr_magic;
+    }
+    [[nodiscard]]
+    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);
+    }
+
+    struct ExtractedSection
+    {
+        std::uint64_t virtual_base_addr;
+        std::uint64_t raw_base_addr;
+        std::vector<std::byte> data;
+    };
+
+    [[nodiscard]]
+    std::optional<ExtractedSection> extract_section_from_pe_file(const std::filesystem::path& path_to_file,
+                                                                 const std::string_view& section_name)
+    {
+        std::fstream file(path_to_file, std::ios::binary | std::ios::in);
+
+        if (!file.is_open()) [[unlikely]]
+            return std::nullopt;
+
+        DosHeader dos_header{};
+        file.read(reinterpret_cast<char*>(&dos_header), sizeof(dos_header));
+
+        if (invalid_dos_header_file(dos_header)) [[unlikely]]
+            return std::nullopt;
+
+        const auto nt_headers = get_nt_header_from_file(file, dos_header);
+
+        if (!nt_headers)
+            return std::nullopt;
+
+        if (invalid_nt_header_file(nt_headers.value())) [[unlikely]]
+            return std::nullopt;
+
+        return std::visit(
+                [&file, &dos_header, &section_name](auto& concrete_headers) -> std::optional<ExtractedSection>
+                {
+                    constexpr std::size_t size_of_signature = sizeof(concrete_headers.signature);
+                    const auto offset_to_segment_table = dos_header.e_lfanew
+                                                         + concrete_headers.file_header.size_optional_header
+                                                         + sizeof(FileHeader) + size_of_signature;
+
+                    file.seekg(static_cast<std::fstream::off_type>(offset_to_segment_table), std::ios::beg);
+
+                    for (std::size_t i = 0; i < concrete_headers.file_header.num_sections; i++)
+                    {
+                        SectionHeader current_section{};
+                        file.read(reinterpret_cast<char*>(&current_section), sizeof(current_section));
+
+                        if (std::string_view(current_section.name) != section_name)
+                            continue;
+
+                        std::vector<std::byte> section_data(current_section.size_raw_data);
+
+                        file.seekg(current_section.ptr_raw_data, std::ios::beg);
+                        file.read(reinterpret_cast<char*>(section_data.data()),
+                                  static_cast<std::streamsize>(section_data.size()));
+                        return ExtractedSection{.virtual_base_addr = current_section.virtual_address
+                                                                     + concrete_headers.optional_header.image_base,
+                                                .raw_base_addr = current_section.ptr_raw_data,
+                                                .data = std::move(section_data)};
+                    }
+                    return std::nullopt;
+                },
+                nt_headers.value());
+    }
+} // namespace
+
+namespace omath
+{
+
+    std::optional<std::uintptr_t> PePatternScanner::scan_for_pattern_in_loaded_module(const void* module_base_address,
+                                                                                      const std::string_view& pattern)
+    {
+        const auto base_address = reinterpret_cast<std::uintptr_t>(module_base_address);
+
+        if (!base_address)
+            return std::nullopt;
+
+        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 = 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.end())
+                        return reinterpret_cast<std::uintptr_t>(&*result);
+
+                    return std::nullopt;
+                },
+                nt_header_variant.value());
+    }
+    std::optional<PeSectionScanResult>
+    PePatternScanner::scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                               const std::string_view& pattern,
+                                               const std::string_view& target_section_name)
+    {
+        const auto pe_section = extract_section_from_pe_file(path_to_file, target_section_name);
+
+        if (!pe_section.has_value())
+            return std::nullopt;
+
+        const auto scan_result =
+                PatternScanner::scan_for_pattern(pe_section->data.cbegin(), pe_section->data.cend(), pattern);
+
+        if (scan_result == pe_section->data.cend())
+            return std::nullopt;
+        const auto offset = std::distance(pe_section->data.begin(), scan_result);
+
+        return PeSectionScanResult{.virtual_base_addr = pe_section->virtual_base_addr,
+                                   .raw_base_addr = pe_section->raw_base_addr,
+                                   .target_offset = offset};
+    }
+} // namespace omath

tests/CMakeLists.txt

@@ -16,5 +16,4 @@ set_target_properties(${PROJECT_NAME} PROPERTIES
 
 
 target_link_libraries(${PROJECT_NAME} PRIVATE gtest gtest_main omath::omath)
-
 gtest_discover_tests(${PROJECT_NAME})

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);
+}

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);
 }
 

tests/general/unit_test_angle.cpp

@@ -2,10 +2,10 @@
 // Created by Orange on 11/30/2024.
 //
 
+#include <omath/trigonometry/angle.hpp>
 #include <cmath>
 #include <gtest/gtest.h>
 #include <numbers>
-#include <omath/angle.hpp>
 
 using namespace omath;
 

tests/general/unit_test_angles.cpp

@@ -1,8 +1,8 @@
 //
 // Created by Orange on 11/30/2024.
 //
+#include <omath/trigonometry/angles.hpp>
 #include <gtest/gtest.h>
-#include <omath/angles.hpp>
 
 TEST(unit_test_angles, radians_to_deg)
 {

tests/general/unit_test_color.cpp

@@ -1,9 +1,8 @@
 //
 // Created by Vlad on 01.09.2024.
 //
+#include <omath/utility/color.hpp>
 #include <gtest/gtest.h>
-#include <omath/color.hpp>
-
 
 using namespace omath;
 

tests/general/unit_test_line_trace.cpp

@@ -2,9 +2,9 @@
 // Revised unit‑test suite for LineTracer (segment‑based Möller–Trumbore)
 // Pure ASCII: avoids non‑standard characters that MSVC rejects.
 //
-#include "omath/linear_algebra/vector3.hpp"
+#include "omath/linear_algebra/triangle.hpp"
 #include "omath/collision/line_tracer.hpp"
-#include "omath/triangle.hpp"
+#include "omath/linear_algebra/vector3.hpp"
 #include "gtest/gtest.h"
 #include <cmath>
 

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);
+}

tests/general/unit_test_pattern_scan.cpp

@@ -0,0 +1,53 @@
+//
+// Created by Vlad on 10/4/2025.
+//
+#include "omath/utility/pe_pattern_scan.hpp"
+#include "gtest/gtest.h"
+#include <omath/utility/pattern_scan.hpp>
+#include <source_location>
+#include <print>
+TEST(unit_test_pattern_scan, read_test)
+{
+    const auto result = omath::PatternScanner::parse_pattern("FF ? ?? E9");
+
+    EXPECT_EQ(result->at(0), static_cast<std::byte>(0xFF));
+    EXPECT_EQ(result->at(1), std::nullopt);
+    EXPECT_EQ(result->at(2), std::nullopt);
+    EXPECT_EQ(result->at(3), static_cast<std::byte>(0xE9));
+}
+
+TEST(unit_test_pattern_scan, corner_case_1)
+{
+    const auto result = omath::PatternScanner::parse_pattern("     FF ? ?? E9");
+
+    EXPECT_EQ(result->at(0), static_cast<std::byte>(0xFF));
+    EXPECT_EQ(result->at(1), std::nullopt);
+    EXPECT_EQ(result->at(2), std::nullopt);
+    EXPECT_EQ(result->at(3), static_cast<std::byte>(0xE9));
+}
+
+TEST(unit_test_pattern_scan, corner_case_2)
+{
+    const auto result = omath::PatternScanner::parse_pattern("     FF ? ?? E9       ");
+
+    EXPECT_EQ(result->at(0), static_cast<std::byte>(0xFF));
+    EXPECT_EQ(result->at(1), std::nullopt);
+    EXPECT_EQ(result->at(2), std::nullopt);
+    EXPECT_EQ(result->at(3), static_cast<std::byte>(0xE9));
+}
+
+TEST(unit_test_pattern_scan, corner_case_3)
+{
+    const auto result = omath::PatternScanner::parse_pattern("     FF ?       ??      E9       ");
+
+    EXPECT_EQ(result->at(0), static_cast<std::byte>(0xFF));
+    EXPECT_EQ(result->at(1), std::nullopt);
+    EXPECT_EQ(result->at(2), std::nullopt);
+    EXPECT_EQ(result->at(3), static_cast<std::byte>(0xE9));
+}
+
+TEST(unit_test_pattern_scan, corner_case_4)
+{
+    const auto result = omath::PatternScanner::parse_pattern("X ? ?? E9 ");
+    EXPECT_FALSE(result.has_value());
+}

tests/general/unit_test_prediction.cpp

@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <omath/projectile_prediction/proj_pred_engine_legacy.hpp>
-
+#include <omath/engines/source_engine/traits/camera_trait.hpp>
 TEST(UnitTestPrediction, PredictionTest)
 {
     constexpr omath::projectile_prediction::Target target{
@@ -10,8 +10,9 @@ TEST(UnitTestPrediction, PredictionTest)
     const auto viewPoint =
             omath::projectile_prediction::ProjPredEngineLegacy(400, 1.f / 1000.f, 50, 5.f).maybe_calculate_aim_point(proj, target);
 
-    const auto [pitch, yaw, _] = proj.m_origin.view_angle_to(viewPoint.value()).as_tuple();
 
-    EXPECT_NEAR(42.547142, pitch, 0.01f);
-    EXPECT_NEAR(-1.181189, yaw, 0.01f);
+    const auto [pitch, yaw, _] =omath::source_engine::CameraTrait::calc_look_at_angle(proj.m_origin, viewPoint.value());
+
+    EXPECT_NEAR(-42.547142, pitch.as_degrees(), 0.01f);
+    EXPECT_NEAR(-1.181189, yaw.as_degrees(), 0.01f);
 }

tests/general/unit_test_reverse_enineering.cpp

@@ -0,0 +1,50 @@
+//
+// Created by Vlad on 10/4/2025.
+//
+#include "omath/linear_algebra/vector3.hpp"
+#include <gtest/gtest.h>
+#include <omath/rev_eng/internal_rev_object.hpp>
+
+class Player final
+{
+public:
+    virtual int foo() {return 1;}
+    virtual int bar() {return 2;}
+    omath::Vector3<float> m_origin{1.f, 2.f, 3.f};
+    int m_health{123};
+};
+
+class RevPlayer : omath::rev_eng::InternalReverseEngineeredObject
+{
+public:
+    omath::Vector3<float> get_origin()
+    {
+        return get_by_offset<omath::Vector3<float>>(sizeof(std::uintptr_t));
+    }
+    int get_health()
+    {
+        return get_by_offset<int>(sizeof(std::uintptr_t)+sizeof(omath::Vector3<float>));
+    }
+
+    int rev_foo()
+    {
+        return call_virtual_method<0, int>();
+    }
+    int rev_bar()
+    {
+        return call_virtual_method<1, int>();
+    }
+};
+
+
+TEST(unit_test_reverse_enineering, read_test)
+{
+    Player player_original;
+    const auto player_reversed = reinterpret_cast<RevPlayer*>(&player_original);
+
+    EXPECT_EQ(player_original.m_origin, player_reversed->get_origin());
+    EXPECT_EQ(player_original.m_health, player_reversed->get_health());
+
+    EXPECT_EQ(player_original.bar(), player_reversed->rev_bar());
+    EXPECT_EQ(player_original.foo(), player_reversed->rev_foo());
+}

tests/general/unit_test_triangle.cpp

@@ -1,7 +1,7 @@
 //
 // Created by Orange on 1/6/2025.
 //
-#include "omath/triangle.hpp"
+#include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
 #include <cmath> // For std::sqrt, std::isinf, std::isnan
 #include <gtest/gtest.h>

tests/general/unit_test_view_angles.cpp

@@ -1,4 +1,4 @@
 //
 // Created by Orange on 11/30/2024.
 //
-#include <omath/view_angles.hpp>
+#include <omath/trigonometry/view_angles.hpp>

writerside/c.list

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE categories
-        SYSTEM "https://resources.jetbrains.com/writerside/1.0/categories.dtd">
-<categories>
-    <category id="wrs" name="Writerside documentation" order="1"/>
-    <category id="inf" name="Learn more" order="2"/>
-</categories>

writerside/cfg/buildprofiles.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE buildprofiles SYSTEM "https://resources.jetbrains.com/writerside/1.0/build-profiles.dtd">
-<buildprofiles xsi:noNamespaceSchemaLocation="https://resources.jetbrains.com/writerside/1.0/build-profiles.xsd"
-               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-
-    <variables></variables>
-    <build-profile instance="o">
-        <variables>
-            <noindex-content>true</noindex-content>
-        </variables>
-    </build-profile>
-
-</buildprofiles>

writerside/o.tree

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE instance-profile
-        SYSTEM "https://resources.jetbrains.com/writerside/1.0/product-profile.dtd">
-
-<instance-profile id="o"
-                 name="OMATH"
-                 start-page="starter-topic.md">
-
-    <toc-element topic="starter-topic.md"/>
-    <toc-element topic="Documentation.md"/>
-    <toc-element topic="Code-Of-Conduct.md"/>
-    <toc-element topic="Community.md"/>
-    <toc-element topic="License.md"/>
-</instance-profile>

writerside/redirection-rules.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE rules SYSTEM "https://resources.jetbrains.com/writerside/1.0/redirection-rules.dtd">
-<rules>
-    <!-- format is as follows
-    <rule id="<unique id>">
-        <accepts>page.html</accepts>
-    </rule>
-    -->
-    <rule id="4e037516">
-        <description><![CDATA[Created after removal of "<Empty-MD-Topic.md>" from OMATH]]></description>
-        <accepts>Empty-MD-Topic.html</accepts>
-    </rule>
-</rules>

writerside/topics/Code-Of-Conduct.md

@@ -1,95 +0,0 @@
-# Code Of Conduct
-
-## 🎯 Goal
-
-My goal is to provide a space where it is safe for everyone to contribute to,
-and get support for, open-source software in a respectful and cooperative
-manner.
-
-I value all contributions and want to make this project and its
-surrounding community a place for everyone.
-
-As members, contributors, and everyone else who may participate in the
-development, I strive to keep the entire experience civil.
-
-## 📜 Standards
-
-Our community standards exist in order to make sure everyone feels comfortable
-contributing to the project(s) together.
-
-Our standards are:
-- Do not harass, attack, or in any other way discriminate against anyone, including
-  for their protected traits, including, but not limited to, sex, religion, race,
-  appearance, gender, identity, nationality, sexuality, etc.
-- Do not go off-topic, do not post spam.
-- Treat everyone with respect.
-
-Examples of breaking each rule respectively include:
-- Harassment, bullying or inappropriate jokes about another person.
-- Posting distasteful imagery, trolling, or posting things unrelated to the topic at hand.
-- Treating someone as worse because of their lack of understanding of an issue.
-
-## ⚡ Enforcement
-
-Enforcement of this CoC is done by Orange++ and/or other core contributors.
-
-I, as the core developer, will strive my best to keep this community civil and
-following the standards outlined above.
-
-### 🚩 Reporting incidents
-
-If you believe an incident of breaking these standards has occurred, but nobody has
-taken appropriate action, you can privately contact the people responsible for dealing
-with such incidents in multiple ways:
-
-***E-Mail***
-- `orange-cpp@yandex.ru`
-
-***Discord***
-- `@orange_cpp`
-
-***Telegram***
-- `@orange_cpp`
-
-I guarantee your privacy and will not share those reports with anyone.
-
-## ⚖️ Enforcement Strategy
-
-Depending on the severity of the infraction, any action from the list below may be applied.
-Please keep in mind cases are reviewed on a per-case basis and members are the ultimate
-deciding factor in the type of punishment.
-
-If the matter benefited from an outside opinion, a member might reach for more opinions
-from people unrelated, however, the final decision regarding the action
-to be taken is still up to the member.
-
-For example, if the matter at hand regards a representative of a marginalized group or minority,
-the member might ask for a first-hand opinion from another representative of such group.
-
-### ✏️ Correction/Edit
-
-If your message is found to be misleading or poorly worded, a member might
-edit your message.
-
-### ⚠️ Warning/Deletion
-
-If your message is found inappropriate, a member might give you a public or private warning,
-and/or delete your message.
-
-### 🔇 Mute
-
-If your message is disruptive, or you have been repeatedly violating the standards,
-a member might mute (or temporarily ban) you.
-
-### ⛔ Ban
-
-If your message is hateful, very disruptive, or other, less serious infractions are repeated
-ignoring previous punishments, a member might ban you permanently.
-
-## 🔎 Scope
-
-This CoC shall apply to all projects ran under the Orange++ lead and all _official_ communities
-outside of GitHub.
-
-However, it is worth noting that official communities outside of GitHub might have their own,
-additional sets of rules.

writerside/topics/Community.md

@@ -1,11 +0,0 @@
-# Credits
-
-Thanks to everyone who made this possible, including:
-
-- Saikari aka luadebug for VCPKG port.
-
-And a big hand to everyone else who has contributed over the past!
-
-THANKS! <3
-
-    -- Orange++ <orange-cpp@yandex.ru>

writerside/topics/Documentation.md

@@ -1,54 +0,0 @@
-# 📥Installation Guide
-
-## Using vcpkg
-**Note**: Support vcpkg for package management
-1. Install [vcpkg](https://github.com/microsoft/vcpkg)
-2. Run the following command to install the orange-math package:
-```
-vcpkg install orange-math
-```
-CMakeLists.txt
-```cmake
-find_package(omath CONFIG REQUIRED)
-target_link_libraries(main PRIVATE omath::omath)
-```
-For detailed commands on installing different versions and more information, please refer to Microsoft's [official instructions](https://learn.microsoft.com/en-us/vcpkg/get_started/overview).
-
-## Build from source using CMake
-1. **Preparation**
-
-   Install needed tools: cmake, clang, git, msvc (windows only).
-
-    1. **Linux:**
-        ```bash
-        sudo pacman -Sy cmake ninja clang git
-        ```
-    2. **MacOS:**
-        ```bash
-        brew install llvm git cmake ninja
-        ```
-    3. **Windows:**
-
-       Install Visual Studio from [here](https://visualstudio.microsoft.com/downloads/) and Git from [here](https://git-scm.com/downloads).
-
-       Use x64 Native Tools shell to execute needed commands down below.
-2. **Clone the repository:**
-   ```bash
-   git clone https://github.com/orange-cpp/omath.git
-   ```
-3. **Navigate to the project directory:**
-   ```bash
-   cd omath
-   ```
-4. **Build the project using CMake:**
-   ```bash
-   cmake --preset windows-release -S .
-   cmake --build cmake-build/build/windows-release --target omath -j 6
-   ```
-   Use **\<platform\>-\<build configuration\>** preset to build siutable version for yourself. Like **windows-release** or **linux-release**.
-
-   | Platform Name | Build Config  |
-       |---------------|---------------|
-   | windows       | release/debug |
-   | linux         | release/debug |
-   | darwin        | release/debug |

writerside/topics/License.md

@@ -1,9 +0,0 @@
-# License
-
-Copyright (c) 2025 Orange++
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

writerside/topics/starter-topic.md

@@ -1,67 +0,0 @@
-# Intro
-
-![banner](https://i.imgur.com/SM9ccP6.png)
-
-Oranges's Math Library (omath) is a comprehensive, open-source library aimed at providing efficient, reliable, and versatile mathematical functions and algorithms. Developed primarily in C++, this library is designed to cater to a wide range of mathematical operations essential in scientific computing, engineering, and academic research.
-
-## 👁‍🗨 Features
-- **Efficiency**: Optimized for performance, ensuring quick computations using AVX2.
-- **Versatility**: Includes a wide array of mathematical functions and algorithms.
-- **Ease of Use**: Simplified interface for convenient integration into various projects.
-- **Projectile Prediction**: Projectile prediction engine with O(N) algo complexity, that can power you projectile aim-bot.
-- **3D Projection**: No need to find view-projection matrix anymore you can make your own projection pipeline.
-- **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!
-
-## Supported Render Pipelines
-| ENGINE   | SUPPORT |
-|----------|---------|
-| Source   | ✅YES    |
-| Unity    | ✅YES    |
-| IWEngine | ✅YES    |
-| Unreal   | ❌NO     |
-
-## Supported Operating Systems
-
-| OS             | SUPPORT |
-|----------------|---------|
-| Windows 10/11  | ✅YES    |
-| Linux          | ✅YES    |
-| Darwin (MacOS) | ✅YES    |
-
-## ⏬ Installation
-Please read our [installation guide](https://github.com/orange-cpp/omath/blob/main/INSTALL.md). If this link doesn't work check out INSTALL.md file.
-
-## ❔ Usage
-Simple world to screen function
-```c++
-TEST(UnitTestProjection, IsPointOnScreen)
-{
-    const omath::projection::Camera camera({0.f, 0.f, 0.f}, {0, 0.f, 0.f} , {1920.f, 1080.f}, 110.f, 0.1f, 500.f);
-
-    const auto proj = camera.WorldToScreen({100, 0, 15});
-    EXPECT_TRUE(proj.has_value());
-}
-```
-## Showcase
-
-With `omath/projection` module you can achieve simple ESP hack for powered by Source/Unreal/Unity engine games, like [Apex Legends](https://store.steampowered.com/app/1172470/Apex_Legends/).
-
-![banner](https://i.imgur.com/lcJrfcZ.png)
-Or for InfinityWard Engine based games. Like Call of Duty Black Ops 2!
-![banner](https://i.imgur.com/F8dmdoo.png)
-Or create simple trigger bot with embeded traceline from omath::collision::LineTrace
-![banner](https://i.imgur.com/fxMjRKo.jpeg)
-Or even advanced projectile aimbot
-[Watch Video](https://youtu.be/lM_NJ1yCunw?si=5E87OrQMeypxSJ3E)
-
-
-## 🫵🏻 Contributing
-Contributions to `omath` are welcome! Please read `CONTRIBUTING.md` for details on our code of conduct and the process for submitting pull requests.
-
-## 📜 License
-This project is licensed under the MIT - see the `LICENSE` file for details.
-
-## 💘 Acknowledgments
--  [All contributors](https://github.com/orange-cpp/omath/graphs/contributors)

writerside/v.list

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE vars SYSTEM "https://resources.jetbrains.com/writerside/1.0/vars.dtd">
-<vars>
-    <var name="product" value="Writerside"/>
-</vars>

writerside/writerside.cfg

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE ihp SYSTEM "https://resources.jetbrains.com/writerside/1.0/ihp.dtd">
-
-<ihp version="2.0">
-    <topics dir="topics" web-path="topics"/>
-    <images dir="images" web-path="images"/>
-    <instance src="o.tree"/>
-</ihp>