Merge pull request #40 from orange-cpp/u/orange/inverted-matrix

U/orange/inverted matrix

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/uml.iml" filepath="$PROJECT_DIR$/.idea/uml.iml" />
-    </modules>
-  </component>
-</project>

.idea/uml.iml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module classpath="CMake" type="CPP_MODULE" version="4" />

.idea/vcs.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$/extlibs/googletest" vcs="Git" />
-  </component>
-</project>

CMakeLists.txt

@@ -13,13 +13,12 @@ option(OMATH_IMGUI_INTEGRATION "Omath will define method to convert omath types
 option(OMATH_BUILD_EXAMPLES "Build example projects with you can learn & play" OFF)
 option(OMATH_STATIC_MSVC_RUNTIME_LIBRARY  "Force Omath to link static runtime" OFF)
 option(OMATH_SUPRESS_SAFETY_CHECKS "Supress some safety checks in release build to improve general performance" ON)
-
+option(OMATH_USE_UNITY_BUILD "Will enable unity build to speed up compilation" ON)
 
 if (OMATH_BUILD_AS_SHARED_LIBRARY)
     add_library(omath SHARED source/matrix.cpp)
 else()
-    add_library(omath STATIC source/matrix.cpp
-            source/matrix.cpp)
+    add_library(omath STATIC source/matrix.cpp)
 endif()
 
 message(STATUS "Building on ${CMAKE_HOST_SYSTEM_NAME}")
@@ -55,11 +54,15 @@ endif()
 set_target_properties(omath PROPERTIES
         ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
-        UNITY_BUILD ON
-        UNITY_BUILD_BATCH_SIZE 20
         CXX_STANDARD 23
         CXX_STANDARD_REQUIRED ON)
 
+if (OMATH_USE_UNITY_BUILD)
+    set_target_properties(omath PROPERTIES
+            UNITY_BUILD ON
+            UNITY_BUILD_BATCH_SIZE 20)
+endif()
+
 if (OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
     set_target_properties(omath PROPERTIES
             MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"

CREDITS.md

@@ -0,0 +1,11 @@
+# OMATH 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>

README.md

@@ -91,7 +91,8 @@ With `omath/projection` module you can achieve simple ESP hack for powered by So
 ![banner](https://i.imgur.com/lcJrfcZ.png)
 Or for InfinityWard Engine based games. Like Call of Duty Black Ops 2!
 ![banner](https://i.imgur.com/F8dmdoo.png)
-
+Or create simple trigger bot with embeded traceline from omath::collision::LineTrace
+![banner](https://i.imgur.com/fxMjRKo.jpeg)
 Or even advanced projectile aimbot
 [Watch Video](https://youtu.be/lM_NJ1yCunw?si=5E87OrQMeypxSJ3E)
 </details>

include/omath/3d_primitives/box.hpp

@@ -0,0 +1,17 @@
+//
+// Created by Vlad on 4/18/2025.
+//
+
+#pragma once
+#include <array>
+#include "omath/triangle.hpp"
+#include "omath/vector3.hpp"
+
+
+namespace omath::primitives
+{
+    [[nodiscard]]
+    std::array<Triangle<Vector3<float>>, 12> CreateBox(const Vector3<float>& top, const Vector3<float>& bottom,
+                                             const Vector3<float>& dirForward, const Vector3<float>& dirRight,
+                                             float ratio = 4.f);
+}

include/omath/angle.hpp

@@ -3,9 +3,9 @@
 //
 
 #pragma once
-#include "omath/angles.hpp"
 #include <algorithm>
 #include <utility>
+#include "omath/angles.hpp"
 
 
 namespace omath
@@ -17,7 +17,7 @@ namespace omath
     };
 
     template<class Type = float, Type min = Type(0), Type max = Type(360), AngleFlags flags = AngleFlags::Normalized>
-    requires std::is_arithmetic_v<Type>
+        requires std::is_arithmetic_v<Type>
     class Angle
     {
         Type m_angle;
@@ -34,6 +34,7 @@ namespace omath
                 std::unreachable();
             }
         }
+
     public:
         [[nodiscard]]
         constexpr static Angle FromDegrees(const Type& degrees)
@@ -42,7 +43,6 @@ namespace omath
         }
         constexpr Angle() : m_angle(0)
         {
-
         }
         [[nodiscard]]
         constexpr static Angle FromRadians(const Type& degrees)
@@ -149,4 +149,4 @@ namespace omath
             return Angle{-m_angle};
         }
     };
-}
+} // namespace omath

include/omath/collision/line_tracer.hpp

@@ -13,7 +13,7 @@ namespace omath::collision
     public:
         Vector3<float> start;
         Vector3<float> end;
-
+        bool infinite_length = false;
         [[nodiscard]]
         Vector3<float> DirectionVector() const;
 

include/omath/engines/iw_engine/formulas.hpp

@@ -16,8 +16,10 @@ namespace omath::iw_engine
     [[nodiscard]]
     Vector3<float> UpVector(const ViewAngles& angles);
 
-    [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
+    [[nodiscard]]
+    Mat4x4 RotationMatrix(const ViewAngles& angles);
 
+    [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
 
     [[nodiscard]]
     Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);

include/omath/engines/opengl_engine/constants.hpp

@@ -17,9 +17,10 @@ namespace omath::opengl_engine
     using Mat4x4 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
     using Mat3x3 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
     using Mat1x3 = Mat<1, 3, float, MatStoreType::COLUMN_MAJOR>;
-    using PitchAngle = Angle<float, 0.f, 180.f, AngleFlags::Clamped>;
-    using YawAngle = Angle<float, 0.f, 360.f, AngleFlags::Normalized>;
-    using RollAngle = Angle<float, 0.f, 360.f, AngleFlags::Normalized>;
+    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>;
 }

include/omath/engines/opengl_engine/formulas.hpp

@@ -18,6 +18,8 @@ namespace omath::opengl_engine
 
     [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
 
+    [[nodiscard]]
+    Mat4x4 RotationMatrix(const ViewAngles& angles);
 
     [[nodiscard]]
     Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);

include/omath/engines/source_engine/formulas.hpp

@@ -9,6 +9,9 @@ namespace omath::source_engine
     [[nodiscard]]
     Vector3<float> ForwardVector(const ViewAngles& angles);
 
+    [[nodiscard]]
+    Mat4x4 RotationMatrix(const ViewAngles& angles);
+
     [[nodiscard]]
     Vector3<float> RightVector(const ViewAngles& angles);
 
@@ -17,7 +20,6 @@ namespace omath::source_engine
 
     [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
 
-
     [[nodiscard]]
     Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
 } // namespace omath::source

include/omath/engines/unity_engine/constants.hpp

@@ -18,7 +18,7 @@ namespace omath::unity_engine
     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, -89.f, 89.f, AngleFlags::Clamped>;
+    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>;
 

include/omath/engines/unity_engine/formulas.hpp

@@ -18,6 +18,8 @@ namespace omath::unity_engine
 
     [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
 
+    [[nodiscard]]
+    Mat4x4 RotationMatrix(const ViewAngles& angles);
 
     [[nodiscard]]
     Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);

include/omath/mat.hpp

@@ -97,7 +97,7 @@ namespace omath
         {
             return At(row, col);
         }
-        
+
         constexpr Mat(Mat&& other) noexcept
         {
             m_data = std::move(other.m_data);
@@ -253,21 +253,24 @@ namespace omath
 
             if constexpr (Rows == 2)
                 return At(0, 0) * At(1, 1) - At(0, 1) * At(1, 0);
-            else
+
+            if constexpr (Rows > 2)
             {
                 Type det = 0;
-                for (size_t i = 0; i < Columns; ++i)
+                for (size_t column = 0; column < Columns; ++column)
                 {
-                    const Type cofactor = (i % 2 == 0 ? 1 : -1) * At(0, i) * Minor(0, i).Determinant();
+                    const Type cofactor = At(0, column) * AlgComplement(0, column);
                     det += cofactor;
                 }
                 return det;
             }
+            std::unreachable();
         }
 
         [[nodiscard]]
-        constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> Minor(const size_t row, const size_t column) const
+        constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> Strip(const size_t row, const size_t column) const
         {
+            static_assert(Rows-1 > 0 && Columns-1 > 0);
             Mat<Rows - 1, Columns - 1, Type, StoreType> result;
             for (size_t i = 0, m = 0; i < Rows; ++i)
             {
@@ -285,6 +288,19 @@ namespace omath
             return result;
         }
 
+        [[nodiscard]]
+        constexpr Type Minor(const size_t row, const size_t column) const
+        {
+            return Strip(row, column).Determinant();
+        }
+
+        [[nodiscard]]
+        constexpr Type AlgComplement(const size_t row, const size_t column) const
+        {
+            const auto minor = Minor(row, column);
+            return (row + column + 2) % 2 == 0 ? minor: -minor;
+        }
+
         [[nodiscard]]
         constexpr const std::array<Type, Rows * Columns>& RawArray() const
         {
@@ -294,7 +310,7 @@ namespace omath
         [[nodiscard]]
         constexpr std::array<Type, Rows * Columns>& RawArray()
         {
-            return const_cast<std::array<Type, Rows * Columns>>(std::as_const(*this).RawArray());
+            return m_data;
         }
 
         [[nodiscard]]
@@ -343,6 +359,25 @@ namespace omath
             };
         }
 
+        [[nodiscard]]
+        constexpr std::optional<Mat> Inverted() const
+        {
+            const auto det = Determinant();
+
+            if (det == 0)
+                return std::nullopt;
+
+            const auto transposed = Transposed();
+            Mat result;
+
+            for (std::size_t row = 0; row < Rows; row++)
+                for (std::size_t column = 0; column < Rows; column++)
+                    result.At(row, column) = transposed.AlgComplement(row, column);
+
+            result /= det;
+
+            return {result};
+        }
     private:
         std::array<Type, Rows * Columns> m_data;
     };
@@ -428,13 +463,6 @@ namespace omath
         } * MatTranslation<Type, St>(-cameraOrigin);
     }
 
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class ViewAngles>
-    [[nodiscard]]
-    Mat<4, 4, Type, St> MatRotation(const ViewAngles& angles) noexcept
-    {
-        return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
-    }
-
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
     Mat<4, 4, Type, St> MatPerspectiveLeftHanded(const float fieldOfView, const float aspectRatio, const float near,

include/omath/projection/camera.hpp

@@ -62,31 +62,37 @@ namespace omath::projection
         void SetFieldOfView(const FieldOfView& fov)
         {
             m_fieldOfView = fov;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         void SetNearPlane(const float near)
         {
             m_nearPlaneDistance = near;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         void SetFarPlane(const float far)
         {
             m_farPlaneDistance = far;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         void SetViewAngles(const ViewAnglesType& viewAngles)
         {
             m_viewAngles = viewAngles;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         void SetOrigin(const Vector3<float>& origin)
         {
             m_origin = origin;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         void SetViewPort(const ViewPort& viewPort)
         {
             m_viewPort = viewPort;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         [[nodiscard]] const FieldOfView& GetFieldOfView() const

source/3d_primitives/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(omath PRIVATE box.cpp)

source/3d_primitives/box.cpp

@@ -0,0 +1,56 @@
+//
+// Created by Vlad on 4/18/2025.
+//
+#include "omath/3d_primitives/box.hpp"
+
+
+namespace omath::primitives
+{
+    std::array<Triangle<Vector3<float>>, 12> CreateBox(const Vector3<float>& top, const Vector3<float>& bottom,
+                                                       const Vector3<float>& dirForward,
+                                                       const Vector3<float>& dirRight,
+                                                       const float ratio)
+    {
+        const auto height = top.DistTo(bottom);
+        const auto sideSize = height / ratio;
+
+        // corner layout (0‑3 bottom, 4‑7 top)
+        std::array<Vector3<float>, 8> p;
+        p[0] = bottom + (dirForward + dirRight) * sideSize; // front‑right‑bottom
+        p[1] = bottom + (dirForward - dirRight) * sideSize; // front‑left‑bottom
+        p[2] = bottom + (-dirForward + dirRight) * sideSize; // back‑right‑bottom
+        p[3] = bottom + (-dirForward - dirRight) * sideSize; // back‑left‑bottom
+        p[4] = top + (dirForward + dirRight) * sideSize; // front‑right‑top
+        p[5] = top + (dirForward - dirRight) * sideSize; // front‑left‑top
+        p[6] = top + (-dirForward + dirRight) * sideSize; // back‑right‑top
+        p[7] = top + (-dirForward - dirRight) * sideSize; // back‑left‑top
+
+        std::array<Triangle<Vector3<float>>, 12> poly;
+
+        // bottom face (+Y up ⇒ wind CW when viewed from above)
+        poly[0] = {p[0], p[2], p[3]};
+        poly[1] = {p[0], p[3], p[1]};
+
+        // top face
+        poly[2] = {p[4], p[7], p[6]};
+        poly[3] = {p[4], p[5], p[7]};
+
+        // front face
+        poly[4] = {p[0], p[5], p[1]};
+        poly[5] = {p[0], p[4], p[5]};
+
+        // right face
+        poly[6] = {p[0], p[6], p[2]};
+        poly[7] = {p[0], p[4], p[6]};
+
+        // back face
+        poly[8] = {p[2], p[7], p[3]};
+        poly[9] = {p[2], p[6], p[7]};
+
+        // left face
+        poly[10] = {p[1], p[7], p[5]};
+        poly[11] = {p[1], p[3], p[7]};
+
+        return poly;
+    }
+}

source/CMakeLists.txt

@@ -7,4 +7,5 @@ add_subdirectory(projectile_prediction)
 add_subdirectory(pathfinding)
 add_subdirectory(projection)
 add_subdirectory(collision)
-add_subdirectory(engines)
+add_subdirectory(engines)
+add_subdirectory(3d_primitives)

source/collision/line_tracer.cpp

@@ -54,7 +54,12 @@ namespace omath::collision
         const auto tHit = sideB.Dot(q) * invDet;
 
 
-        if (tHit <= kEpsilon)
+        if (ray.infinite_length)
+        {
+            if (tHit <= kEpsilon)
+                return ray.end;
+        }
+        else if (tHit <= kEpsilon || tHit > 1.0f - kEpsilon)
             return ray.end;
 
         return ray.start + rayDir * tHit;

source/engines/iw_engine/formulas.cpp

@@ -9,23 +9,27 @@ namespace omath::iw_engine
 
     Vector3<float> ForwardVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsForward);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsForward);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
 
     Vector3<float> RightVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsRight);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsRight);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
     Vector3<float> UpVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsUp);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsUp);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
+    Mat4x4 RotationMatrix(const ViewAngles& angles)
+    {
+        return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
+    }
 
     Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
     {

source/engines/opengl_engine/formulas.cpp

@@ -9,19 +9,19 @@ namespace omath::opengl_engine
 
     Vector3<float> ForwardVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsForward);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector<float, MatStoreType::COLUMN_MAJOR>(kAbsForward);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
     Vector3<float> RightVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsRight);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector<float, MatStoreType::COLUMN_MAJOR>(kAbsRight);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
     Vector3<float> UpVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsUp);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector<float, MatStoreType::COLUMN_MAJOR>(kAbsUp);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
@@ -30,6 +30,12 @@ namespace omath::opengl_engine
         return MatCameraView<float, MatStoreType::COLUMN_MAJOR>(-ForwardVector(angles), RightVector(angles),
                                                                 UpVector(angles), cam_origin);
     }
+    Mat4x4 RotationMatrix(const ViewAngles& angles)
+    {
+        return MatRotationAxisX<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch) *
+               MatRotationAxisY<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw) *
+               MatRotationAxisZ<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
+    }
     Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
                                            const float far)
     {

source/engines/source_engine/formulas.cpp

@@ -8,20 +8,25 @@ namespace omath::source_engine
 {
     Vector3<float> ForwardVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsForward);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsForward);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
 
+    Mat4x4 RotationMatrix(const ViewAngles& angles)
+    {
+        return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
+    }
+
     Vector3<float> RightVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsRight);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsRight);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
     Vector3<float> UpVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsUp);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsUp);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }

source/engines/unity_engine/formulas.cpp

@@ -9,19 +9,19 @@ namespace omath::unity_engine
 {
     Vector3<float> ForwardVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsForward);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsForward);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
     Vector3<float> RightVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsRight);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsRight);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
     Vector3<float> UpVector(const ViewAngles& angles)
     {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsUp);
+        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsUp);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
@@ -30,6 +30,12 @@ namespace omath::unity_engine
         return MatCameraView<float, MatStoreType::ROW_MAJOR>(ForwardVector(angles), -RightVector(angles),
                                                              UpVector(angles), cam_origin);
     }
+    Mat4x4 RotationMatrix(const ViewAngles& angles)
+    {
+        return MatRotationAxisX<float, MatStoreType::ROW_MAJOR>(angles.pitch) *
+               MatRotationAxisY<float, MatStoreType::ROW_MAJOR>(angles.yaw) *
+               MatRotationAxisZ<float, MatStoreType::ROW_MAJOR>(angles.roll);
+    }
     Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
                                            const float far)
     {

source/projectile_prediction/proj_pred_engine_avx2.cpp

@@ -2,11 +2,12 @@
 // Created by Vlad on 2/23/2025.
 //
 #include "omath/projectile_prediction/proj_pred_engine_avx2.hpp"
-#include "source_location"
-
+#include <source_location>
+#include <stdexcept>
 
 #if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
 #include <immintrin.h>
+#else
 #include <format>
 #endif
 

tests/CMakeLists.txt

@@ -18,6 +18,7 @@ add_executable(unit-tests
         general/unit_test_view_angles.cpp
         general/unit_test_angle.cpp
         general/unit_test_triangle.cpp
+        general/unit_test_box_primitive.cpp
 
         engines/unit_test_open_gl.cpp
         engines/unit_test_unity_engine.cpp

tests/engines/unit_test_iw_engine.cpp

@@ -27,6 +27,42 @@ TEST(UnitTestIwEngine, UpVector)
     EXPECT_EQ(up, omath::iw_engine::kAbsUp);
 }
 
+TEST(UnitTestIwEngine, ForwardVectorRotationYaw)
+{
+    omath::iw_engine::ViewAngles angles;
+
+    angles.yaw = omath::iw_engine::YawAngle::FromDegrees(-90.f);
+
+    const auto forward = omath::iw_engine::ForwardVector(angles);
+    EXPECT_NEAR(forward.x, omath::iw_engine::kAbsRight.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::iw_engine::kAbsRight.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::iw_engine::kAbsRight.z, 0.00001f);
+}
+
+TEST(UnitTestIwEngine, ForwardVectorRotationPitch)
+{
+    omath::iw_engine::ViewAngles angles;
+
+    angles.pitch = omath::iw_engine::PitchAngle::FromDegrees(-89.f);
+
+    const auto forward = omath::iw_engine::ForwardVector(angles);
+    EXPECT_NEAR(forward.x, omath::iw_engine::kAbsUp.x, 0.02f);
+    EXPECT_NEAR(forward.y, omath::iw_engine::kAbsUp.y, 0.01f);
+    EXPECT_NEAR(forward.z, omath::iw_engine::kAbsUp.z, 0.01f);
+}
+
+TEST(UnitTestIwEngine, ForwardVectorRotationRoll)
+{
+    omath::iw_engine::ViewAngles angles;
+
+    angles.roll = omath::iw_engine::RollAngle::FromDegrees(90.f);
+
+    const auto forward = omath::iw_engine::UpVector(angles);
+    EXPECT_NEAR(forward.x, omath::iw_engine::kAbsRight.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::iw_engine::kAbsRight.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::iw_engine::kAbsRight.z, 0.00001f);
+}
+
 TEST(UnitTestIwEngine, ProjectTargetMovedFromCamera)
 {
     constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);

tests/engines/unit_test_open_gl.cpp

@@ -10,14 +10,12 @@
 TEST(UnitTestOpenGL, ForwardVector)
 {
     const auto forward = omath::opengl_engine::ForwardVector({});
-
     EXPECT_EQ(forward, omath::opengl_engine::kAbsForward);
 }
 
 TEST(UnitTestOpenGL, RightVector)
 {
     const auto right = omath::opengl_engine::RightVector({});
-
     EXPECT_EQ(right, omath::opengl_engine::kAbsRight);
 }
 
@@ -27,6 +25,44 @@ TEST(UnitTestOpenGL, UpVector)
     EXPECT_EQ(up, omath::opengl_engine::kAbsUp);
 }
 
+TEST(UnitTestOpenGL, ForwardVectorRotationYaw)
+{
+    omath::opengl_engine::ViewAngles angles;
+
+    angles.yaw = omath::opengl_engine::YawAngle::FromDegrees(90.f);
+
+    const auto forward = omath::opengl_engine::ForwardVector(angles);
+    EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsRight.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsRight.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsRight.z, 0.00001f);
+}
+
+
+
+TEST(UnitTestOpenGL, ForwardVectorRotationPitch)
+{
+    omath::opengl_engine::ViewAngles angles;
+
+    angles.pitch = omath::opengl_engine::PitchAngle::FromDegrees(-90.f);
+
+    const auto forward = omath::opengl_engine::ForwardVector(angles);
+    EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsUp.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsUp.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsUp.z, 0.00001f);
+}
+
+TEST(UnitTestOpenGL, ForwardVectorRotationRoll)
+{
+    omath::opengl_engine::ViewAngles angles;
+
+    angles.roll = omath::opengl_engine::RollAngle::FromDegrees(-90.f);
+
+    const auto forward = omath::opengl_engine::UpVector(angles);
+    EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsRight.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsRight.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsRight.z, 0.00001f);
+}
+
 TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
 {
     constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);

tests/engines/unit_test_source_engine.cpp

@@ -27,6 +27,42 @@ TEST(UnitTestSourceEngine, UpVector)
     EXPECT_EQ(up, omath::source_engine::kAbsUp);
 }
 
+TEST(UnitTestSourceEngine, ForwardVectorRotationYaw)
+{
+    omath::source_engine::ViewAngles angles;
+
+    angles.yaw = omath::source_engine::YawAngle::FromDegrees(-90.f);
+
+    const auto forward = omath::source_engine::ForwardVector(angles);
+    EXPECT_NEAR(forward.x, omath::source_engine::kAbsRight.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::source_engine::kAbsRight.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::source_engine::kAbsRight.z, 0.00001f);
+}
+
+TEST(UnitTestSourceEngine, ForwardVectorRotationPitch)
+{
+    omath::source_engine::ViewAngles angles;
+
+    angles.pitch = omath::source_engine::PitchAngle::FromDegrees(-89.f);
+
+    const auto forward = omath::source_engine::ForwardVector(angles);
+    EXPECT_NEAR(forward.x, omath::source_engine::kAbsUp.x, 0.02f);
+    EXPECT_NEAR(forward.y, omath::source_engine::kAbsUp.y, 0.01f);
+    EXPECT_NEAR(forward.z, omath::source_engine::kAbsUp.z, 0.01f);
+}
+
+TEST(UnitTestSourceEngine, ForwardVectorRotationRoll)
+{
+    omath::source_engine::ViewAngles angles;
+
+    angles.roll = omath::source_engine::RollAngle::FromDegrees(90.f);
+
+    const auto forward = omath::source_engine::UpVector(angles);
+    EXPECT_NEAR(forward.x, omath::source_engine::kAbsRight.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::source_engine::kAbsRight.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::source_engine::kAbsRight.z, 0.00001f);
+}
+
 TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
 {
     constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);

tests/engines/unit_test_unity_engine.cpp

@@ -14,6 +14,42 @@ TEST(UnitTestUnityEngine, ForwardVector)
     EXPECT_EQ(forward, omath::unity_engine::kAbsForward);
 }
 
+TEST(UnitTestUnityEngine, ForwardVectorRotationYaw)
+{
+    omath::unity_engine::ViewAngles angles;
+
+    angles.yaw = omath::unity_engine::YawAngle::FromDegrees(90.f);
+
+    const auto forward = omath::unity_engine::ForwardVector(angles);
+    EXPECT_NEAR(forward.x, omath::unity_engine::kAbsRight.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::unity_engine::kAbsRight.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::unity_engine::kAbsRight.z, 0.00001f);
+}
+
+TEST(UnitTestUnityEngine, ForwardVectorRotationPitch)
+{
+    omath::unity_engine::ViewAngles angles;
+
+    angles.pitch = omath::unity_engine::PitchAngle::FromDegrees(-90.f);
+
+    const auto forward = omath::unity_engine::ForwardVector(angles);
+    EXPECT_NEAR(forward.x, omath::unity_engine::kAbsUp.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::unity_engine::kAbsUp.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::unity_engine::kAbsUp.z, 0.00001f);
+}
+
+TEST(UnitTestUnityEngine, ForwardVectorRotationRoll)
+{
+    omath::unity_engine::ViewAngles angles;
+
+    angles.roll = omath::unity_engine::RollAngle::FromDegrees(-90.f);
+
+    const auto forward = omath::unity_engine::UpVector(angles);
+    EXPECT_NEAR(forward.x, omath::unity_engine::kAbsRight.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::unity_engine::kAbsRight.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::unity_engine::kAbsRight.z, 0.00001f);
+}
+
 TEST(UnitTestUnityEngine, RightVector)
 {
     const auto right = omath::unity_engine::RightVector({});

tests/general/unit_test_box_primitive.cpp

@@ -0,0 +1,6 @@
+//
+// Created by Vlad on 4/18/2025.
+//
+#include <gtest/gtest.h>
+#include <omath/3d_primitives/box.hpp>
+

tests/general/unit_test_line_trace.cpp

@@ -1,80 +1,121 @@
+//
+// Revised unit‑test suite for LineTracer (segment‑based Möller–Trumbore)
+// Pure ASCII: avoids non‑standard characters that MSVC rejects.
+//
 #include "gtest/gtest.h"
 #include "omath/collision/line_tracer.hpp"
 #include "omath/triangle.hpp"
 #include "omath/vector3.hpp"
+#include <cmath>
 
 using namespace omath;
 using namespace omath::collision;
 
-class LineTracerTest : public ::testing::Test
+using Vec3 = Vector3<float>;
+
+namespace
 {
-protected:
-    // Set up common variables for use in each test
-    Vector3<float> vertex1{0.0f, 0.0f, 0.0f};
-    Vector3<float> vertex2{1.0f, 0.0f, 0.0f};
-    Vector3<float> vertex3{0.0f, 1.0f, 0.0f};
-    Triangle<Vector3<float>> triangle{vertex1, vertex2, vertex3};
-};
 
-// Test that a ray intersecting the triangle returns false for CanTraceLine
-TEST_F(LineTracerTest, RayIntersectsTriangle)
-{
-    constexpr Ray ray{{0.3f, 0.3f, -1.0f}, {0.3f, 0.3f, 1.0f}};
-    EXPECT_FALSE(LineTracer::CanTraceLine(ray, triangle));
-}
+    // -----------------------------------------------------------------------------
+    // Constants & helpers
+    // -----------------------------------------------------------------------------
+    constexpr float kTol = 1e-5f;
 
-// Test that a ray parallel to the triangle plane returns true for CanTraceLine
-TEST_F(LineTracerTest, RayParallelToTriangle)
-{
-    constexpr Ray ray{{0.3f, 0.3f, 1.0f}, {0.3f, 0.3f, 2.0f}};
-    EXPECT_TRUE(LineTracer::CanTraceLine(ray, triangle));
-}
+    bool VecEqual(const Vec3& a, const Vec3& b, float tol = kTol)
+    {
+        return std::fabs(a.x - b.x) < tol &&
+               std::fabs(a.y - b.y) < tol &&
+               std::fabs(a.z - b.z) < tol;
+    }
 
-// Test that a ray starting inside the triangle but pointing away returns true
-TEST_F(LineTracerTest, RayStartsInTriangleButDoesNotIntersect)
-{
-    constexpr Ray ray{{0.3f, 0.3f, 0.0f}, {0.3f, 0.3f, -1.0f}};
-    EXPECT_TRUE(LineTracer::CanTraceLine(ray, triangle));
-}
+    // -----------------------------------------------------------------------------
+    // Fixture with one canonical right‑angled triangle in the XY plane.
+    // -----------------------------------------------------------------------------
+    class LineTracerFixture : public ::testing::Test
+    {
+    protected:
+        LineTracerFixture() :
+            triangle({0.f, 0.f, 0.f}, {1.f, 0.f, 0.f}, {0.f, 1.f, 0.f})
+        {
+        }
 
-// Test that a ray not intersecting the triangle plane returns true
-TEST_F(LineTracerTest, RayMissesTriangle)
-{
-    constexpr Ray ray{{2.0f, 2.0f, -1.0f}, {2.0f, 2.0f, 1.0f}};
-    EXPECT_TRUE(LineTracer::CanTraceLine(ray, triangle));
-}
-
-// Test that a ray lying exactly in the plane of the triangle without intersecting returns true
-TEST_F(LineTracerTest, RayInPlaneNotIntersecting)
-{
-    constexpr Ray ray{{-1.0f, -1.0f, 0.0f}, {1.5f, 1.5f, 0.0f}};
-    EXPECT_TRUE(LineTracer::CanTraceLine(ray, triangle));
-}
-
-
-TEST_F(LineTracerTest, RayIntersectsVertex)
-{
-    const Ray ray{{-1.0f, -1.0f, -1.0f}, vertex1}; // Intersecting at vertex1
-    EXPECT_TRUE(LineTracer::CanTraceLine(ray, triangle));
-}
-
-TEST_F(LineTracerTest, RayIntersectsEdge)
-{
-    constexpr Ray ray{{-1.0f, 0.0f, -1.0f}, {0.5f, 0.0f, 0.0f}};
-    // Intersecting on the edge between vertex1 and vertex2
-    EXPECT_TRUE(LineTracer::CanTraceLine(ray, triangle));
-}
-
-TEST_F(LineTracerTest, TriangleFarBeyondRayEndPoint)
-{
-    // Define a ray with a short length
-    constexpr Ray ray{{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}};
-
-    // Define a triangle far beyond the ray's endpoint
-    constexpr Triangle<Vector3<float>> distantTriangle{
-        {1000.0f, 1000.0f, 1000.0f}, {1001.0f, 1000.0f, 1000.0f}, {1000.0f, 1001.0f, 1000.0f}
+        Triangle<Vec3> triangle;
     };
 
-    // Expect true because the ray ends long before it could reach the distant triangle
-    EXPECT_TRUE(LineTracer::CanTraceLine(ray, distantTriangle));
-}
+    // -----------------------------------------------------------------------------
+    // Data‑driven tests for CanTraceLine
+    // -----------------------------------------------------------------------------
+    struct TraceCase
+    {
+        Ray ray;
+        bool expected_clear; // true => segment does NOT hit the triangle
+    };
+
+    class CanTraceLineParam : public LineTracerFixture,
+                              public ::testing::WithParamInterface<TraceCase>
+    {
+    };
+
+    TEST_P(CanTraceLineParam, VariousRays)
+    {
+        const auto& p = GetParam();
+        EXPECT_EQ(LineTracer::CanTraceLine(p.ray, triangle), p.expected_clear);
+    }
+
+    INSTANTIATE_TEST_SUITE_P(
+            BasicScenarios,
+            CanTraceLineParam,
+            ::testing::Values(
+                TraceCase{Ray{{ 0.3f, 0.3f, -1.f},{ 0.3f, 0.3f, 1.f}}, false}, // hit through centre
+                TraceCase{Ray{{ 0.3f, 0.3f, 1.f},{ 0.3f, 0.3f, 2.f}}, true}, // parallel above
+                TraceCase{Ray{{ 0.3f, 0.3f, 0.f},{ 0.3f, 0.3f,-1.f}}, true}, // starts inside, goes away
+                TraceCase{Ray{{ 2.0f, 2.0f, -1.f},{ 2.0f, 2.0f, 1.f}}, true}, // misses entirely
+                TraceCase{Ray{{-1.0f,-1.0f, 0.f},{ 1.5f, 1.5f, 0.f}},true}, // lies in plane, outside tri
+                TraceCase{Ray{{-1.0f,-1.0f, -1.f},{ 0.0f, 0.0f, 0.f}}, true}, // endpoint on vertex
+                TraceCase{Ray{{-1.0f, 0.0f, -1.f},{ 0.5f, 0.0f, 0.f}}, true} // endpoint on edge
+            )
+            );
+
+    // -----------------------------------------------------------------------------
+    // Validate that the reported hit point is correct for a genuine intersection.
+    // -----------------------------------------------------------------------------
+    TEST_F(LineTracerFixture, HitPointCorrect)
+    {
+        constexpr Ray ray{{0.3f, 0.3f, -1.f}, {0.3f, 0.3f, 1.f}};
+        constexpr Vec3 expected{0.3f, 0.3f, 0.f};
+
+        const Vec3 hit = LineTracer::GetRayHitPoint(ray, triangle);
+        ASSERT_FALSE(VecEqual(hit, ray.end));
+        EXPECT_TRUE(VecEqual(hit, expected));
+    }
+
+    // -----------------------------------------------------------------------------
+    // Triangle far beyond the ray should not block.
+    // -----------------------------------------------------------------------------
+    TEST_F(LineTracerFixture, DistantTriangleClear)
+    {
+        constexpr Ray short_ray{{0.f, 0.f, 0.f}, {0.f, 0.f, 1.f}};
+        constexpr Triangle<Vec3> distant{{1000.f, 1000.f, 1000.f},
+                                         {1001.f, 1000.f, 1000.f},
+                                         {1000.f, 1001.f, 1000.f}};
+
+        EXPECT_TRUE(LineTracer::CanTraceLine(short_ray, distant));
+    }
+
+    TEST(LineTracerTraceRayEdge, CantHit)
+    {
+        constexpr omath::Triangle<Vector3<float>> triangle{{2, 0, 0}, {2, 2, 0}, {2, 2, 2}};
+
+        constexpr Ray ray{{}, {1.0, 0, 0}, false};
+
+        EXPECT_TRUE(omath::collision::LineTracer::CanTraceLine(ray, triangle));
+    }
+    TEST(LineTracerTraceRayEdge, CanHit)
+    {
+        constexpr omath::Triangle<Vector3<float>> triangle{{2, 0, 0}, {2, 2, 0}, {2, 2, 2}};
+
+        constexpr Ray ray{{}, {2.1, 0, 0}, false};
+        auto endPoint = omath::collision::LineTracer::GetRayHitPoint(ray, triangle);
+        EXPECT_FALSE(omath::collision::LineTracer::CanTraceLine(ray, triangle));
+    }
+} // namespace

tests/general/unit_test_mat.cpp

@@ -180,10 +180,10 @@ TEST(UnitTestMatStandalone, Determinant_3x3)
 }
 
 // Test Minor for 3x3 matrix
-TEST(UnitTestMatStandalone, Minor_3x3)
+TEST(UnitTestMatStandalone, Strip_3x3)
 {
     constexpr Mat<3, 3> m{{3, 0, 2}, {2, 0, -2}, {0, 1, 1}};
-    auto minor = m.Minor(0, 0);
+    auto minor = m.Strip(0, 0);
     EXPECT_EQ(minor.RowCount(), 2);
     EXPECT_EQ(minor.ColumnsCount(), 2);
     EXPECT_FLOAT_EQ(minor.At(0, 0), 0.0f);
@@ -206,3 +206,11 @@ TEST(UnitTestMatStandalone, Transpose_NonSquare)
     EXPECT_FLOAT_EQ(transposed.At(1, 1), 5.0f);
     EXPECT_FLOAT_EQ(transposed.At(2, 1), 6.0f);
 }
+
+TEST(UnitTestMatStandalone, Enverse)
+{
+    constexpr Mat<2, 2> m{{1.0f, 3.0f}, {2.0f, 5.0f}};
+    constexpr Mat<2,2> mv{{-5.0f, 3.0f}, {2.0f, -1.0f}};
+
+    EXPECT_EQ(mv, m.Inverted());
+}