Merge pull request #41 from orange-cpp/u/improved-cmake

improved cmake, removed useless cmake files
2026-02-13 23:13:26 +00:00 · 2025-04-30 21:31:34 +03:00 · 2025-04-30 21:26:25 +03:00 · 2025-04-30 18:15:46 +03:00 · 2025-04-29 20:53:02 +03:00 · 2025-04-29 20:52:41 +03:00
52 changed files with 1129 additions and 377 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 /cmake-build/
 /.idea
 /out
+*.DS_Store
--- a/.idea/modules.xml
+++ b/.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>
--- a/.idea/uml.iml
+++ b/.idea/uml.iml
@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module classpath="CMake" type="CPP_MODULE" version="4" />
--- a/.idea/vcs.xml
+++ b/.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>
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,54 +11,89 @@ option(OMATH_BUILD_AS_SHARED_LIBRARY "Build Omath as .so or .dll" OFF)
 option(OMATH_USE_AVX2 "Omath will use AVX2 to boost performance" ON)
 option(OMATH_IMGUI_INTEGRATION "Omath will define method to convert omath types to imgui types" OFF)
 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)
+
+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(omath SHARED source/Matrix.cpp)
-else()
-    add_library(omath STATIC source/Matrix.cpp)
-endif()
+    add_library(omath SHARED ${OMATH_SOURCES} ${OMATH_HEADERS})
+else ()
+    add_library(omath STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
+endif ()

+message(STATUS "Building on ${CMAKE_HOST_SYSTEM_NAME}")
 add_library(omath::omath ALIAS omath)

 if (OMATH_IMGUI_INTEGRATION)
    target_compile_definitions(omath PUBLIC OMATH_IMGUI_INTEGRATION)
-endif()
+
+    # IMGUI is being linked as submodule
+    if (TARGET imgui)
+        target_link_libraries(omath PUBLIC imgui)
+        install(TARGETS imgui
+                EXPORT omathTargets
+                ARCHIVE DESTINATION lib
+                LIBRARY DESTINATION lib
+                RUNTIME DESTINATION bin)
+    else ()
+        # Assume that IMGUI linked via VCPKG.
+        find_package(imgui CONFIG REQUIRED)
+        target_link_libraries(omath PUBLIC imgui::imgui)
+    endif ()
+
+endif ()

 if (OMATH_USE_AVX2)
    target_compile_definitions(omath PUBLIC OMATH_USE_AVX2)
-endif()
+endif ()
+
+if (OMATH_SUPRESS_SAFETY_CHECKS)
+    target_compile_definitions(omath PUBLIC OMATH_SUPRESS_SAFETY_CHECKS)
+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>"
+    )
+endif ()
+
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    target_compile_options(omath PRIVATE -mavx2 -mfma)
-endif()
+endif ()

 target_compile_features(omath PUBLIC cxx_std_23)


-add_subdirectory(source)
-
-if(OMATH_BUILD_TESTS)
+if (OMATH_BUILD_TESTS)
    add_subdirectory(extlibs)
    add_subdirectory(tests)
-endif()
+endif ()

 if (OMATH_BUILD_EXAMPLES)
    add_subdirectory(examples)
-endif()
+endif ()

 if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND OMATH_THREAT_WARNING_AS_ERROR)
    target_compile_options(omath PRIVATE /W4 /WX)
-elseif(OMATH_THREAT_WARNING_AS_ERROR)
+elseif (OMATH_THREAT_WARNING_AS_ERROR)
    target_compile_options(omath PRIVATE -Wall -Wextra -Wpedantic -Werror)
-endif()
+endif ()

 target_include_directories(omath
        PUBLIC
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -64,6 +64,38 @@
      "cacheVariables": {
        "CMAKE_BUILD_TYPE": "Release"
      }
+    },
+    {
+      "name": "darwin-base",
+      "hidden": true,
+      "generator": "Ninja",
+      "binaryDir": "${sourceDir}/cmake-build/build/${presetName}",
+      "installDir": "${sourceDir}/cmake-build/install/${presetName}",
+      "cacheVariables": {
+        "CMAKE_C_COMPILER": "clang",
+        "CMAKE_CXX_COMPILER": "clang++"
+      },
+      "condition": {
+        "type": "equals",
+        "lhs": "${hostSystemName}",
+        "rhs": "Darwin"
+      }
+    },
+    {
+      "name": "darwin-debug",
+      "displayName": "Darwin Debug",
+      "inherits": "darwin-base",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug"
+      }
+    },
+    {
+      "name": "darwin-release",
+      "displayName": "Darwin Release",
+      "inherits": "darwin-debug",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release"
+      }
    }
  ]
 }
--- a/CREDITS.md
+++ b/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>
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -0,0 +1,54 @@
+# 📥Installation Guide
+
+## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> 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).
+
+## <img width="28px" src="https://upload.wikimedia.org/wikipedia/commons/e/ef/CMake_logo.svg?" /> 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 |
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 <div align = center>

-![banner](https://i.imgur.com/sjtpKi8.png)
+![banner](https://i.imgur.com/SM9ccP6.png)

 ![GitHub License](https://img.shields.io/github/license/orange-cpp/omath)
 ![GitHub contributors](https://img.shields.io/github/contributors/orange-cpp/omath)
@@ -20,40 +20,26 @@ Oranges's Math Library (omath) is a comprehensive, open-source library aimed at
 - **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!
-## ⏬ Getting Started
-### Prerequisites
- C++ Compiler
- CMake (for building the project)

-### Installation
-### 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
-1. Clone the repository:
-   ```
-   git clone https://github.com/orange-cpp/omath.git
-   ```
-2. Navigate to the project directory:
-   ```
-   cd omath
-   ```
-3. Build the project using CMake:
-   ```
-   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**.
+## 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++
@@ -65,16 +51,17 @@ TEST(UnitTestProjection, IsPointOnScreen)
    EXPECT_TRUE(proj.has_value());
 }
 ```
-
+## Showcase
 <details>
-  <summary>OMATH for making cheats</summary>
+  <summary>OMATH for making cheats (click to open)</summary>

 With `omath/projection` module you can achieve simple ESP hack for powered by Source/Unreal/Unity engine games, like [Apex Legends](https://store.steampowered.com/app/1172470/Apex_Legends/).

 ![banner](https://i.imgur.com/lcJrfcZ.png)
 Or for InfinityWard Engine based games. Like Call of Duty Black Ops 2!
 ![banner](https://i.imgur.com/F8dmdoo.png)
-
+Or create simple trigger bot with embeded traceline from omath::collision::LineTrace
+![banner](https://i.imgur.com/fxMjRKo.jpeg)
 Or even advanced projectile aimbot
 [Watch Video](https://youtu.be/lM_NJ1yCunw?si=5E87OrQMeypxSJ3E)
 </details>
--- a/include/omath/3d_primitives/box.hpp
+++ b/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);
+}
--- a/include/omath/angle.hpp
+++ b/include/omath/angle.hpp
@@ -3,8 +3,10 @@
 //

 #pragma once
-#include "omath/angles.hpp"
 #include <algorithm>
+#include <utility>
+#include "omath/angles.hpp"
+

 namespace omath
 {
@@ -15,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;
@@ -32,6 +34,7 @@ namespace omath
                std::unreachable();
            }
        }
+
    public:
        [[nodiscard]]
        constexpr static Angle FromDegrees(const Type& degrees)
@@ -40,7 +43,6 @@ namespace omath
        }
        constexpr Angle() : m_angle(0)
        {
-
        }
        [[nodiscard]]
        constexpr static Angle FromRadians(const Type& degrees)
@@ -147,4 +149,4 @@ namespace omath
            return Angle{-m_angle};
        }
    };
-}
+} // namespace omath
--- a/include/omath/collision/line_tracer.hpp
+++ b/include/omath/collision/line_tracer.hpp
@@ -3,8 +3,8 @@
 //
 #pragma once

-#include "omath/Vector3.hpp"
-#include "omath/Triangle.hpp"
+#include "omath/triangle.hpp"
+#include "omath/vector3.hpp"

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

--- a/include/omath/color.hpp
+++ b/include/omath/color.hpp
@@ -8,115 +8,166 @@
 #include "omath/vector3.hpp"
 #include "omath/vector4.hpp"

+#ifdef max
+#undef max
+#endif
+
+
+#ifdef min
+#undef min
+#endif
+
 namespace omath
 {
    struct HSV
    {
-        float m_hue{};
-        float m_saturation{};
-        float m_value{};
+        float hue{};
+        float saturation{};
+        float value{};
    };


    class Color final : public Vector4<float>
    {
-        public:
-            constexpr Color(const float r, const float g, const float b, const float a) : Vector4(r,g,b,a)
+    public:
+        constexpr Color(const float r, const float g, const float b, const float a) : Vector4(r, g, b, a)
+        {
+            Clamp(0.f, 1.f);
+        }
+
+        constexpr explicit Color() = default;
+        [[nodiscard]]
+        constexpr static Color FromRGBA(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a)
+        {
+            return Color{Vector4(r, g, b, a) / 255.f};
+        }
+
+        [[nodiscard]]
+        constexpr static Color FromHSV(float hue, const float saturation, const float value)
+        {
+            float r{}, g{}, b{};
+
+            hue = std::clamp(hue, 0.f, 1.f);
+
+            const int i = static_cast<int>(hue * 6.f);
+            const float f = hue * 6 - i;
+            const float p = value * (1 - saturation);
+            const float q = value * (1 - f * saturation);
+            const float t = value * (1 - (1 - f) * saturation);
+
+            switch (i % 6)
            {
-                Clamp(0.f, 1.f);
+                case 0:
+                    r = value, g = t, b = p;
+                    break;
+                case 1:
+                    r = q, g = value, b = p;
+                    break;
+                case 2:
+                    r = p, g = value, b = t;
+                    break;
+                case 3:
+                    r = p, g = q, b = value;
+                    break;
+                case 4:
+                    r = t, g = p, b = value;
+                    break;
+                case 5:
+                    r = value, g = p, b = q;
+                    break;
+
+                default:
+                    return {0.f, 0.f, 0.f, 0.f};
            }

-            constexpr explicit Color() : Vector4()
-            {
+            return {r, g, b, 1.f};
+        }

-            }
-            [[nodiscard]]
-            constexpr static Color FromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
-            {
-                return Color{Vector4(r, g, b, a) / 255.f};
-            }
+        [[nodiscard]]
+        constexpr static Color FromHSV(const HSV& hsv)
+        {
+            return FromHSV(hsv.hue, hsv.saturation, hsv.value);
+        }

-            [[nodiscard]]
-            constexpr static Color FromHSV(float hue, float saturation, float value)
-            {
-                float r{}, g{}, b{};
+        [[nodiscard]]
+        constexpr HSV ToHSV() const
+        {
+            HSV hsvData;

-                hue = std::clamp(hue, 0.f, 1.f);
+            const float& red = x;
+            const float& green = y;
+            const float& blue = z;

-                const int i = static_cast<int>(hue * 6.f);
-                const float f = hue * 6 - i;
-                const float p = value * (1 - saturation);
-                const float q = value * (1 - f * saturation);
-                const float t = value * (1 - (1 - f) * saturation);
-
-                switch (i % 6)
-                {
-                    case 0: r = value, g = t, b = p; break;
-                    case 1: r = q, g = value, b = p; break;
-                    case 2: r = p, g = value, b = t; break;
-                    case 3: r = p, g = q, b = value; break;
-                    case 4: r = t, g = p, b = value; break;
-                    case 5: r = value, g = p, b = q; break;
-
-                    default: return {0.f, 0.f, 0.f, 0.f};
-                }
-
-                return {r, g, b, 1.f};
-            }
-
-            [[nodiscard]]
-            constexpr HSV ToHSV() const
-            {
-                HSV hsvData;
-
-                const float& red = x;
-                const float& green = y;
-                const float& blue = z;
-
-                const float max = std::max({red, green, blue});
-                const float min = std::min({red, green, blue});
-                const float delta = max - min;
+            const float max = std::max({red, green, blue});
+            const float min = std::min({red, green, blue});
+            const float delta = max - min;


-                if (delta == 0.f)
-                    hsvData.m_hue = 0.f;
+            if (delta == 0.f)
+                hsvData.hue = 0.f;

-                else if (max == red)
-                    hsvData.m_hue = 60.f * (std::fmodf(((green - blue) / delta), 6.f));
-                else if (max == green)
-                    hsvData.m_hue = 60.f * (((blue - red) / delta) + 2.f);
-                else if (max == blue)
-                    hsvData.m_hue = 60.f * (((red - green) / delta) + 4.f);
+            else if (max == red)
+                hsvData.hue = 60.f * (std::fmodf(((green - blue) / delta), 6.f));
+            else if (max == green)
+                hsvData.hue = 60.f * (((blue - red) / delta) + 2.f);
+            else if (max == blue)
+                hsvData.hue = 60.f * (((red - green) / delta) + 4.f);

-                if (hsvData.m_hue < 0.f)
-                    hsvData.m_hue += 360.f;
+            if (hsvData.hue < 0.f)
+                hsvData.hue += 360.f;

-                hsvData.m_hue /= 360.f;
-                hsvData.m_saturation = max == 0.f ? 0.f : delta / max;
-                hsvData.m_value = max;
+            hsvData.hue /= 360.f;
+            hsvData.saturation = max == 0.f ? 0.f : delta / max;
+            hsvData.value = max;

-                return hsvData;
-            }
+            return hsvData;
+        }

-            constexpr explicit Color(const Vector4& vec) : Vector4(vec)
-            {
-                Clamp(0.f, 1.f);
-            }
+        constexpr explicit Color(const Vector4& vec) : Vector4(vec)
+        {
+            Clamp(0.f, 1.f);
+        }
+        constexpr void SetHue(const float hue)
+        {
+            auto hsv = ToHSV();
+            hsv.hue = hue;

-            [[nodiscard]]
-            constexpr Color Blend(const Color& other, float ratio) const
-            {
-                return Color( (*this * (1.f - ratio)) + (other * ratio) );
-            }
+            *this = FromHSV(hsv);
+        }

-        [[nodiscard]] static constexpr Color Red() {return {1.f, 0.f, 0.f, 1.f};}
-        [[nodiscard]] static constexpr Color Green() {return {0.f, 1.f, 0.f, 1.f};}
-        [[nodiscard]] static constexpr Color Blue() {return {0.f, 0.f, 1.f, 1.f};}
+        constexpr void SetSaturation(const float saturation)
+        {
+            auto hsv = ToHSV();
+            hsv.saturation = saturation;
+
+            *this = FromHSV(hsv);
+        }
+
+        constexpr void SetValue(const float value)
+        {
+            auto hsv = ToHSV();
+            hsv.value = value;
+
+            *this = FromHSV(hsv);
+        }
+        [[nodiscard]]
+        constexpr Color Blend(const Color& other, float ratio) const
+        {
+            ratio = std::clamp(ratio, 0.f, 1.f);
+            return Color(*this * (1.f - ratio) + other * ratio);
+        }
+
+        [[nodiscard]] static constexpr Color Red()
+        {
+            return {1.f, 0.f, 0.f, 1.f};
+        }
+        [[nodiscard]] static constexpr Color Green()
+        {
+            return {0.f, 1.f, 0.f, 1.f};
+        }
+        [[nodiscard]] static constexpr Color Blue()
+        {
+            return {0.f, 0.f, 1.f, 1.f};
+        }
    };
-
-    [[nodiscard]]
-    constexpr Color Blend(const Color& first, const Color& second, float ratio)
-    {
-        return Color{first * (1.f - std::clamp(ratio, 0.f, 1.f)) + second * ratio};
-    }
-}
+} // namespace omath
--- a/include/omath/engines/iw_engine/formulas.hpp
+++ b/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);
--- a/include/omath/engines/opengl_engine/constants.hpp
+++ b/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>;
 }
--- a/include/omath/engines/opengl_engine/formulas.hpp
+++ b/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);
--- a/include/omath/engines/source_engine/formulas.hpp
+++ b/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
--- a/include/omath/engines/unity_engine/camera.hpp
+++ b/include/omath/engines/unity_engine/camera.hpp
@@ -0,0 +1,21 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+
+#pragma once
+#include "omath/engines/unity_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+
+namespace omath::unity_engine
+{
+    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
+    {
+    public:
+        Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+               const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
+        void LookAt(const Vector3<float>& target) override;
+    protected:
+        [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
+        [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
+    };
+}
--- a/include/omath/engines/unity_engine/constants.hpp
+++ b/include/omath/engines/unity_engine/constants.hpp
@@ -0,0 +1,26 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+
+#pragma once
+
+#include <omath/vector3.hpp>
+#include <omath/mat.hpp>
+#include <omath/angle.hpp>
+#include <omath/view_angles.hpp>
+
+namespace omath::unity_engine
+{
+    constexpr Vector3<float> kAbsUp = {0, 1, 0};
+    constexpr Vector3<float> kAbsRight = {1, 0, 0};
+    constexpr Vector3<float> kAbsForward = {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::source
--- a/include/omath/engines/unity_engine/formulas.hpp
+++ b/include/omath/engines/unity_engine/formulas.hpp
@@ -0,0 +1,26 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+
+#pragma once
+#include "omath/engines/unity_engine/constants.hpp"
+
+namespace omath::unity_engine
+{
+    [[nodiscard]]
+    Vector3<float> ForwardVector(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Vector3<float> RightVector(const ViewAngles& angles);
+
+    [[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 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
+} // namespace omath::source
--- a/include/omath/mat.hpp
+++ b/include/omath/mat.hpp
@@ -9,6 +9,17 @@
 #include <stdexcept>
 #include <utility>
 #include "omath/vector3.hpp"
+#include <numeric>
+
+
+#ifdef near
+#undef near
+#endif
+
+
+#ifdef far
+#undef far
+#endif

 namespace omath
 {
@@ -81,6 +92,12 @@ namespace omath
            return At(row, col);
        }

+        [[nodiscard]]
+        constexpr Type& operator[](const size_t row, const size_t col) const
+        {
+            return At(row, col);
+        }
+
        constexpr Mat(Mat&& other) noexcept
        {
            m_data = std::move(other.m_data);
@@ -107,9 +124,10 @@ namespace omath
        [[nodiscard]]
        constexpr const Type& At(const size_t rowIndex, const size_t columnIndex) const
        {
+#if !defined(NDEBUG) && defined(OMATH_SUPRESS_SAFETY_CHECKS)
            if (rowIndex >= Rows || columnIndex >= Columns)
                throw std::out_of_range("Index out of range");
-
+#endif
            if constexpr (StoreType == MatStoreType::ROW_MAJOR)
                return m_data[rowIndex * Columns + columnIndex];

@@ -131,12 +149,7 @@ namespace omath
        [[nodiscard]]
        constexpr Type Sum() const noexcept
        {
-            Type sum = 0;
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    sum += At(i, j);
-
-            return sum;
+            return std::accumulate(m_data.begin(), m_data.end(), Type(0));
        }

        constexpr void Clear() noexcept
@@ -151,6 +164,7 @@ namespace omath

        // Operator overloading for multiplication with another Mat
        template<size_t OtherColumns>
+        [[nodiscard]]
        constexpr Mat<Rows, OtherColumns, Type, StoreType>
        operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
        {
@@ -169,9 +183,7 @@ namespace omath

        constexpr Mat& operator*=(const Type& f) noexcept
        {
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) *= f;
+            std::ranges::for_each(m_data, [&f](auto& val) {val *= f;});
            return *this;
        }

@@ -183,47 +195,39 @@ namespace omath
        }

        [[nodiscard]]
-        constexpr Mat operator*(const Type& f) const noexcept
+        constexpr Mat operator*(const Type& value) const noexcept
        {
            Mat result(*this);
-            result *= f;
+            result *= value;
            return result;
        }

-        constexpr Mat& operator/=(const Type& f) noexcept
+        constexpr Mat& operator/=(const Type& value) noexcept
        {
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) /= f;
+            std::ranges::for_each(m_data, [&value](auto& val) {val /= value;});
            return *this;
        }

        [[nodiscard]]
-        constexpr Mat operator/(const Type& f) const noexcept
+        constexpr Mat operator/(const Type& value) const noexcept
        {
            Mat result(*this);
-            result /= f;
+            result /= value;
            return result;
        }

        constexpr Mat& operator=(const Mat& other) noexcept
        {
-            if (this == &other)
-                return *this;
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) = other.At(i, j);
+            if (this != &other)
+                m_data = other.m_data;
+
            return *this;
        }

        constexpr Mat& operator=(Mat&& other) noexcept
        {
-            if (this == &other)
-                return *this;
-
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) = other.At(i, j);
+            if (this != &other)
+                m_data = std::move(other.m_data);

            return *this;
        }
@@ -247,23 +251,26 @@ namespace omath
            if constexpr (Rows == 1)
                return At(0, 0);

-            else if constexpr (Rows == 2)
+            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)
            {
@@ -281,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
        {
@@ -290,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]]
@@ -339,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;
    };
@@ -424,10 +463,29 @@ namespace omath
        } * MatTranslation<Type, St>(-cameraOrigin);
    }

-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class ViewAngles>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
    [[nodiscard]]
-    Mat<4, 4, Type, St> MatRotation(const ViewAngles& angles) noexcept
+    Mat<4, 4, Type, St> MatPerspectiveLeftHanded(const float fieldOfView, const float aspectRatio, const float near,
+                                                 const float far) noexcept
    {
-        return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
+        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
+
+        return {{1.f / (aspectRatio * fovHalfTan), 0.f, 0.f, 0.f},
+                {0.f, 1.f / fovHalfTan, 0.f, 0.f},
+                {0.f, 0.f, (far + near) / (far - near), -(2.f * near * far) / (far - near)},
+                {0.f, 0.f, 1.f, 0.f}};
+    }
+
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    [[nodiscard]]
+    Mat<4, 4, Type, St> MatPerspectiveRightHanded(const float fieldOfView, const float aspectRatio, const float near,
+                                                  const float far) noexcept
+    {
+        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
+
+        return {{1.f / (aspectRatio * fovHalfTan), 0.f, 0.f, 0.f},
+                {0.f, 1.f / fovHalfTan, 0.f, 0.f},
+                {0.f, 0.f, -(far + near) / (far - near), -(2.f * near * far) / (far - near)},
+                {0.f, 0.f, -1.f, 0.f}};
    }
 } // namespace omath
--- a/include/omath/projection/camera.hpp
+++ b/include/omath/projection/camera.hpp
@@ -5,8 +5,8 @@
 #pragma once

 #include <expected>
-#include <omath/Angle.hpp>
-#include <omath/Mat.hpp>
+#include <omath/angle.hpp>
+#include <omath/mat.hpp>
 #include <omath/vector3.hpp>
 #include <type_traits>
 #include "omath/projection/error_codes.hpp"
@@ -36,8 +36,8 @@ namespace omath::projection
            m_viewPort(viewPort), m_fieldOfView(fov), m_farPlaneDistance(far), m_nearPlaneDistance(near),
            m_viewAngles(viewAngles), m_origin(position)
        {
-
        }
+
    protected:
        virtual void LookAt(const Vector3<float>& target) = 0;

@@ -49,8 +49,8 @@ namespace omath::projection
        {
            return CalcProjectionMatrix() * CalcViewMatrix();
        }
-    public:

+    public:
        [[nodiscard]] const Mat4x4Type& GetViewProjectionMatrix() const
        {
            if (!m_viewProjectionMatrix.has_value())
@@ -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
@@ -116,9 +122,19 @@ namespace omath::projection

        [[nodiscard]] std::expected<Vector3<float>, Error> WorldToScreen(const Vector3<float>& worldPosition) const
        {
-            const auto& viewProjMatrix = GetViewProjectionMatrix();
+            auto normalizedCords = WorldToViewPort(worldPosition);

-            auto projected = viewProjMatrix * MatColumnFromVector<float, Mat4x4Type::GetStoreOrdering()>(worldPosition);
+            if (!normalizedCords.has_value())
+                return std::unexpected{normalizedCords.error()};
+
+
+            return NdcToScreenPosition(*normalizedCords);
+        }
+
+        [[nodiscard]] std::expected<Vector3<float>, Error> WorldToViewPort(const Vector3<float>& worldPosition) const
+        {
+            auto projected = GetViewProjectionMatrix() *
+                                   MatColumnFromVector<float, Mat4x4Type::GetStoreOrdering()>(worldPosition);

            if (projected.At(3, 0) == 0.0f)
                return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
@@ -128,10 +144,7 @@ namespace omath::projection
            if (IsNdcOutOfBounds(projected))
                return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);

-            const auto screenPositionX = (projected.At(0,0)+1.f) / 2.f * m_viewPort.m_width;
-            const auto screenPositionY = (-projected.At(1,0)+1) / 2.f * m_viewPort.m_height;
-
-            return Vector3{screenPositionX, screenPositionY, projected.At(2,0)};
+            return Vector3<float>{projected.At(0, 0), projected.At(1, 0), projected.At(2, 0)};
        }

    protected:
@@ -152,7 +165,17 @@ namespace omath::projection
        [[nodiscard]]
        constexpr static bool IsNdcOutOfBounds(const Type& ndc)
        {
-            return std::ranges::any_of( ndc.RawArray(), [](const auto& val) { return val < -1 || val > 1; });
+            return std::ranges::any_of(ndc.RawArray(), [](const auto& val) { return val < -1 || val > 1; });
+        }
+
+        [[nodiscard]] Vector3<float> NdcToScreenPosition(const Vector3<float>& ndc) const
+        {
+            return
+            {
+                (ndc.x + 1.f) / 2.f * m_viewPort.m_width,
+                (1.f - ndc.y) / 2.f * m_viewPort.m_height,
+                ndc.z
+            };
        }
    };
 } // namespace omath::projection
--- a/include/omath/vector2.hpp
+++ b/include/omath/vector2.hpp
@@ -124,9 +124,9 @@ namespace omath
        }

 #ifndef _MSC_VER
-        [[nodiscard]] constexpr Type& Length() const
+        [[nodiscard]] constexpr Type Length() const
        {
-            return std::hypot(x, y);
+            return std::hypot(this->x, this->y);
        }

        [[nodiscard]] constexpr Vector2 Normalized() const
--- a/include/omath/vector3.hpp
+++ b/include/omath/vector3.hpp
@@ -121,12 +121,12 @@ namespace omath
 #ifndef _MSC_VER
        [[nodiscard]] constexpr Type Length() const
        {
-            return std::hypot(x, y, z);
+            return std::hypot(this->x, this->y, z);
        }

        [[nodiscard]] constexpr Type Length2D() const
        {
-            return Vector2::Length();
+            return Vector2<Type>::Length();
        }
        [[nodiscard]] Type DistTo(const Vector3& vOther) const
        {
--- a/source/3d_primitives/box.cpp
+++ b/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;
+    }
+}
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -1,10 +0,0 @@
-target_sources(omath PRIVATE
-        matrix.cpp
-        color.cpp
-)
-
-add_subdirectory(projectile_prediction)
-add_subdirectory(pathfinding)
-add_subdirectory(projection)
-add_subdirectory(collision)
-add_subdirectory(engines)
--- a/source/collision/CMakeLists.txt
+++ b/source/collision/CMakeLists.txt
@@ -1,3 +0,0 @@
-target_sources(omath PRIVATE
-        line_tracer.cpp
-)
--- a/source/collision/line_tracer.cpp
+++ b/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;
--- a/source/color.cpp
+++ b/source/color.cpp
@@ -2,7 +2,7 @@
 // Created by vlad on 2/4/24.
 //

-#include "omath/Color.hpp"
+#include "omath/color.hpp"
 #include <algorithm>
 #include <cmath>

--- a/source/engines/CMakeLists.txt
+++ b/source/engines/CMakeLists.txt
@@ -1,3 +0,0 @@
-add_subdirectory(source_engine)
-add_subdirectory(opengl_engine)
-add_subdirectory(iw_engine)
--- a/source/engines/iw_engine/CMakeLists.txt
+++ b/source/engines/iw_engine/CMakeLists.txt
@@ -1 +0,0 @@
-target_sources(omath PRIVATE camera.cpp formulas.cpp)
--- a/source/engines/iw_engine/formulas.cpp
+++ b/source/engines/iw_engine/formulas.cpp
@@ -9,39 +9,46 @@ 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)
    {
        return MatCameraView(ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
    }
+
    Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
                                           const float far)
    {
-        // NOTE: Need magic number to fix fov calculation, since source inherit Quake proj matrix calculation
+        // NOTE: Need magic number to fix fov calculation, since IW engine inherit Quake proj matrix calculation
        constexpr auto kMultiplyFactor = 0.75f;
+
        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f) * kMultiplyFactor;

        return {
                {1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
-                {0, 1.f / fovHalfTan, 0, 0},
+                {0, 1.f / (fovHalfTan), 0, 0},
                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
                {0, 0, 1, 0},
        };
-    }
+    };
 } // namespace omath::iw_engine
--- a/source/engines/opengl_engine/CMakeLists.txt
+++ b/source/engines/opengl_engine/CMakeLists.txt
@@ -1 +0,0 @@
-target_sources(omath PRIVATE camera.cpp formulas.cpp)
--- a/source/engines/opengl_engine/formulas.cpp
+++ b/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)
    {
@@ -40,7 +46,6 @@ namespace omath::opengl_engine
                {0, 1.f / (fovHalfTan), 0, 0},
                {0, 0, -(far + near) / (far - near), -(2.f * far * near) / (far - near)},
                {0, 0, -1, 0},
-
        };
    }
 } // namespace omath::opengl_engine
--- a/source/engines/source_engine/CMakeLists.txt
+++ b/source/engines/source_engine/CMakeLists.txt
@@ -1 +0,0 @@
-target_sources(omath PRIVATE camera.cpp formulas.cpp)
--- a/source/engines/source_engine/formulas.cpp
+++ b/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)};
    }
@@ -30,6 +35,7 @@ namespace omath::source_engine
    {
        return MatCameraView(ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
    }
+
    Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
                                           const float far)
    {
@@ -43,7 +49,6 @@ namespace omath::source_engine
                {0, 1.f / (fovHalfTan), 0, 0},
                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
                {0, 0, 1, 0},
-
        };
    }
 } // namespace omath::source_engine
--- a/source/engines/unity_engine/camera.cpp
+++ b/source/engines/unity_engine/camera.cpp
@@ -0,0 +1,28 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+#include <omath/engines/unity_engine/camera.hpp>
+#include <omath/engines/unity_engine/formulas.hpp>
+
+
+namespace omath::unity_engine
+{
+    Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+                   const projection::FieldOfView& fov, const float near, const float far) :
+        projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
+    {
+    }
+    void Camera::LookAt([[maybe_unused]] const Vector3<float>& target)
+    {
+        throw std::runtime_error("Not implemented");
+    }
+    Mat4x4 Camera::CalcViewMatrix() const
+    {
+        return unity_engine::CalcViewMatrix(m_viewAngles, m_origin);
+    }
+    Mat4x4 Camera::CalcProjectionMatrix() const
+    {
+        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
+                                               m_farPlaneDistance);
+    }
+} // namespace omath::unity_engine
--- a/source/engines/unity_engine/formulas.cpp
+++ b/source/engines/unity_engine/formulas.cpp
@@ -0,0 +1,51 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+#include "omath/engines/unity_engine/formulas.hpp"
+
+
+
+namespace omath::unity_engine
+{
+    Vector3<float> ForwardVector(const ViewAngles& angles)
+    {
+        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 = 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 = RotationMatrix(angles) * MatColumnFromVector(kAbsUp);
+
+        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
+    }
+    Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    {
+        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)
+    {
+        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
+
+        return {
+                {1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
+                {0, 1.f / (fovHalfTan), 0, 0},
+                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                {0, 0, -1.f, 0},
+        };
+    }
+} // namespace omath::unity_engine
--- a/source/matrix.cpp
+++ b/source/matrix.cpp
@@ -1,6 +1,6 @@
-#include "omath/Matrix.hpp"
-#include "omath/Angles.hpp"
-#include "omath/Vector3.hpp"
+#include "omath/matrix.hpp"
+#include "omath/angles.hpp"
+#include "omath/vector3.hpp"


 #include <complex>
--- a/source/pathfinding/CMakeLists.txt
+++ b/source/pathfinding/CMakeLists.txt
@@ -1 +0,0 @@
-target_sources(omath PRIVATE navigation_mesh.cpp a_star.cpp)
--- a/source/projectile_prediction/CMakeLists.txt
+++ b/source/projectile_prediction/CMakeLists.txt
@@ -1 +0,0 @@
-target_sources(omath PRIVATE proj_pred_engine_legacy.cpp projectile.cpp target.cpp proj_pred_engine_avx2.cpp proj_pred_engine.cpp)
--- a/source/projectile_prediction/proj_pred_engine_avx2.cpp
+++ b/source/projectile_prediction/proj_pred_engine_avx2.cpp
@@ -2,7 +2,14 @@
 // 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

 namespace omath::projectile_prediction
 {
@@ -10,7 +17,7 @@ namespace omath::projectile_prediction
    ProjPredEngineAVX2::MaybeCalculateAimPoint([[maybe_unused]] const Projectile& projectile,
                                               [[maybe_unused]] const Target& target) const
    {
-#ifdef OMATH_USE_AVX2
+#if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
        const float bulletGravity = m_gravityConstant * projectile.m_gravityScale;
        const float v0 = projectile.m_launchSpeed;
        const float v0Sqr = v0 * v0;
--- a/source/projection/CMakeLists.txt
+++ b/source/projection/CMakeLists.txt
@@ -1 +0,0 @@
-target_sources(omath PRIVATE camera.cpp)
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,32 +1,13 @@
 enable_testing()

-project(unit-tests)
+project(unit_tests)

 include(GoogleTest)
-add_executable(unit-tests
-        general/unit_test_prediction.cpp
-        general/unit_test_matrix.cpp
-        general/unit_test_mat.cpp
-        general/unit_test_a_star.cpp
-        general/unit_test_projection.cpp
-        general/unit_test_vector3.cpp
-        general/unit_test_vector2.cpp
-        general/unit_test_color.cpp
-        general/unit_test_vector4.cpp
-        general/unit_test_line_trace.cpp
-        general/unit_test_angles.cpp
-        general/unit_test_view_angles.cpp
-        general/unit_test_angle.cpp
-        general/unit_test_triangle.cpp

-        engines/unit_test_open_gl.cpp
-        engines/unit_test_unity_engine.cpp
-        engines/unit_test_source_engine.cpp
-        engines/unit_test_iw_engine.cpp
+file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
+add_executable(unit_tests ${UNIT_TESTS_SOURCES})

-)
-
-set_target_properties(unit-tests PROPERTIES
+set_target_properties(unit_tests PROPERTIES
        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
        UNITY_BUILD ON
@@ -35,6 +16,6 @@ set_target_properties(unit-tests PROPERTIES
        CXX_STANDARD_REQUIRED ON)


-target_link_libraries(unit-tests PRIVATE gtest gtest_main omath::omath)
+target_link_libraries(unit_tests PRIVATE gtest gtest_main omath::omath)

-gtest_discover_tests(unit-tests)
+gtest_discover_tests(unit_tests)
--- a/tests/engines/unit_test_iw_engine.cpp
+++ b/tests/engines/unit_test_iw_engine.cpp
@@ -7,30 +7,66 @@
 #include <omath/engines/iw_engine/formulas.hpp>


-TEST(UnitTestEwEngine, ForwardVector)
+TEST(UnitTestIwEngine, ForwardVector)
 {
-    const auto forward = omath::source_engine::ForwardVector({});
+    const auto forward = omath::iw_engine::ForwardVector({});

-    EXPECT_EQ(forward, omath::source_engine::kAbsForward);
+    EXPECT_EQ(forward, omath::iw_engine::kAbsForward);
 }

-TEST(UnitTestEwEngine, RightVector)
+TEST(UnitTestIwEngine, RightVector)
 {
-    const auto right = omath::source_engine::RightVector({});
+    const auto right = omath::iw_engine::RightVector({});

-    EXPECT_EQ(right, omath::source_engine::kAbsRight);
+    EXPECT_EQ(right, omath::iw_engine::kAbsRight);
 }

-TEST(UnitTestEwEngine, UpVector)
+TEST(UnitTestIwEngine, UpVector)
 {
-    const auto up = omath::source_engine::UpVector({});
-    EXPECT_EQ(up, omath::source_engine::kAbsUp);
+    const auto up = omath::iw_engine::UpVector({});
+    EXPECT_EQ(up, omath::iw_engine::kAbsUp);
 }

-TEST(UnitTestEwEngine, ProjectTargetMovedFromCamera)
+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);
-    const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+    const auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);


    for (float distance = 0.02f; distance < 1000.f; distance += 0.01f)
@@ -47,10 +83,10 @@ TEST(UnitTestEwEngine, ProjectTargetMovedFromCamera)
    }
 }

-TEST(UnitTestEwEngine, CameraSetAndGetFov)
+TEST(UnitTestIwEngine, CameraSetAndGetFov)
 {
    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
-    auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+    auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);

    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
@@ -58,9 +94,9 @@ TEST(UnitTestEwEngine, CameraSetAndGetFov)
    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
 }

-TEST(UnitTestEwEngine, CameraSetAndGetOrigin)
+TEST(UnitTestIwEngine, CameraSetAndGetOrigin)
 {
-    auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
+    auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);

    EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
--- a/tests/engines/unit_test_open_gl.cpp
+++ b/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);
--- a/tests/engines/unit_test_source_engine.cpp
+++ b/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);
@@ -47,6 +83,26 @@ TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
    }
 }

+TEST(UnitTestSourceEngine, ProjectTargetMovedUp)
+{
+    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    auto prev = 1080.f;
+    for (float distance = 0.0f; distance < 10.f; distance += 1.f)
+    {
+        const auto projected = cam.WorldToScreen({100.f, 0, distance});
+        EXPECT_TRUE(projected.has_value());
+
+        if (!projected.has_value())
+            continue;
+
+        EXPECT_TRUE(projected->y < prev);
+
+        prev = projected->y;
+    }
+}
+
 TEST(UnitTestSourceEngine, CameraSetAndGetFov)
 {
    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
--- a/tests/engines/unit_test_unity_engine.cpp
+++ b/tests/engines/unit_test_unity_engine.cpp
@@ -1,3 +1,113 @@
 //
 // Created by Orange on 11/27/2024.
 //
+#include <gtest/gtest.h>
+#include <omath/engines/unity_engine/camera.hpp>
+#include <omath/engines/unity_engine/constants.hpp>
+#include <omath/engines/unity_engine/formulas.hpp>
+#include <print>
+
+TEST(UnitTestUnityEngine, ForwardVector)
+{
+    const auto forward = omath::unity_engine::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({});
+
+    EXPECT_EQ(right, omath::unity_engine::kAbsRight);
+}
+
+TEST(UnitTestUnityEngine, UpVector)
+{
+    const auto up = omath::unity_engine::UpVector({});
+    EXPECT_EQ(up, omath::unity_engine::kAbsUp);
+}
+
+TEST(UnitTestUnityEngine, ProjectTargetMovedFromCamera)
+{
+    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(60.f);
+    const auto cam = omath::unity_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.WorldToScreen({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(UnitTestUnityEngine, Project)
+{
+    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(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.WorldToScreen({5.f, 3, 10.f});
+    std::println("{} {}", proj->x, proj->y);
+}
+
+TEST(UnitTestUnityEngine, CameraSetAndGetFov)
+{
+    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
+    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+}
+
+TEST(UnitTestUnityEngine, CameraSetAndGetOrigin)
+{
+    auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
+    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+}
--- a/tests/general/unit_test_box_primitive.cpp
+++ b/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>
+
--- a/tests/general/unit_test_color.cpp
+++ b/tests/general/unit_test_color.cpp
@@ -63,9 +63,9 @@ TEST_F(UnitTestColor, FromHSV)
 TEST_F(UnitTestColor, ToHSV)
 {
    HSV hsv = color1.ToHSV(); // Red color
-    EXPECT_FLOAT_EQ(hsv.m_hue, 0.0f);
-    EXPECT_FLOAT_EQ(hsv.m_saturation, 1.0f);
-    EXPECT_FLOAT_EQ(hsv.m_value, 1.0f);
+    EXPECT_FLOAT_EQ(hsv.hue, 0.0f);
+    EXPECT_FLOAT_EQ(hsv.saturation, 1.0f);
+    EXPECT_FLOAT_EQ(hsv.value, 1.0f);
 }

 // Test color blending
@@ -106,7 +106,7 @@ TEST_F(UnitTestColor, BlendVector3)
 {
    constexpr Color v1(1.0f, 0.0f, 0.0f, 1.f); // Red
    constexpr Color v2(0.0f, 1.0f, 0.0f, 1.f); // Green
-    constexpr Color blended = Blend(v1, v2, 0.5f);
+    constexpr Color blended = v1.Blend(v2, 0.5f);
    EXPECT_FLOAT_EQ(blended.x, 0.5f);
    EXPECT_FLOAT_EQ(blended.y, 0.5f);
    EXPECT_FLOAT_EQ(blended.z, 0.0f);
--- a/tests/general/unit_test_line_trace.cpp
+++ b/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
--- a/tests/general/unit_test_mat.cpp
+++ b/tests/general/unit_test_mat.cpp
@@ -166,8 +166,10 @@ TEST_F(UnitTestMat, StaticMethod_ToScreenMat)
 // Test exception handling in At() method
 TEST_F(UnitTestMat, Method_At_OutOfRange)
 {
+#if !defined(NDEBUG) && defined(OMATH_SUPRESS_SAFETY_CHECKS)
    EXPECT_THROW(std::ignore = m2.At(2, 0), std::out_of_range);
    EXPECT_THROW(std::ignore = m2.At(0, 2), std::out_of_range);
+#endif
 }

 // Test Determinant for 3x3 matrix
@@ -178,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);
@@ -204,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());
+}
Author	SHA1	Message	Date
Orange++	b06fd00673	Merge pull request #41 from orange-cpp/u/improved-cmake improved cmake, removed useless cmake files	2025-04-30 21:31:34 +03:00
Orange	998c8f3a43	improved cmake, removed useless cmake files	2025-04-30 21:26:25 +03:00
Orange	faeef594b9	moved installation stuff to INSTALL.md	2025-04-30 18:15:46 +03:00
Orange++	40a301186e	Merge pull request #40 from orange-cpp/u/orange/inverted-matrix U/orange/inverted matrix	2025-04-29 20:53:02 +03:00
Orange	a41526c494	style fix	2025-04-29 20:52:41 +03:00
Orange	a0d1dc4313	added test case	2025-04-29 20:49:59 +03:00
Orange	1c5c9360c8	added inverse method	2025-04-29 20:33:39 +03:00
Orange	4615769682	added additional methods	2025-04-29 20:10:17 +03:00
Orange	4ef674f7b4	fixed infinite recursion in compile time	2025-04-29 20:08:27 +03:00
Orange	69b9049fb0	fixed gimba lock for unity	2025-04-26 00:52:46 +03:00
Orange	2734b58bdd	fixed gimba lock for opengl camera	2025-04-26 00:32:53 +03:00
Orange	d7f1f49165	resetting state	2025-04-25 23:52:10 +03:00
Orange	94b1453cae	removed .idea folder	2025-04-23 02:48:45 +03:00
Orange	3e67d8a99c	added credits	2025-04-23 02:46:08 +03:00
Orange++	8c00ab3d9d	Merge pull request #38 from orange-cpp/u/orange-cpp/3d-primitives U/orange cpp/3d primitives	2025-04-18 17:00:38 +03:00
Orange	d14cb1e93e	reset to default	2025-04-18 16:55:07 +03:00
Orange	c692cf39e1	updated readme	2025-04-18 16:53:53 +03:00
Orange	9c934c5d9c	improved tests	2025-04-18 16:36:22 +03:00
Vladislav Alpatov	f8202b116d	improved line tracer	2025-04-18 16:00:23 +03:00
Orange	8bf0bb8e0d	improved line trace and box primitive	2025-04-18 13:56:08 +03:00
Orange	a340766348	switched to polygons	2025-04-18 12:34:24 +03:00
Orange	254674a62e	fixed code style	2025-04-18 12:11:43 +03:00
Orange	97c2da893b	added ratio param	2025-04-18 01:33:47 +03:00
Orange	0ce30a7038	added new build option	2025-04-18 00:51:07 +03:00
Orange	492ddfd566	added box	2025-04-18 00:43:46 +03:00
Orange	baf7ee8f88	fixed include	2025-04-16 20:35:17 +03:00
Orange++	9fde11733f	Merge pull request #37 from orange-cpp/u/engine_rotation_mats U/engine rotation mats	2025-04-16 23:21:58 +03:00
Orange	0069b8bd96	improved openg gl rotation matrix, added tests	2025-04-16 19:11:02 +03:00
Orange	127bae0b78	added tests for source	2025-04-16 18:53:31 +03:00
Orange	bed204a663	added unit tests	2025-04-16 18:35:50 +03:00
Orange	3f6ea010dc	fixed formating	2025-04-16 17:52:57 +03:00
Orange	592a98f38c	removed method from Mat added method for unity	2025-04-16 17:52:19 +03:00
Orange	7873047550	added func added rotation matrix for opengl updated unit tests	2025-04-16 17:40:00 +03:00
Orange	1601f3cbc8	added func added rotation matrix for opengl	2025-04-16 17:40:00 +03:00
Orange	2180f8ab97	removed whitespaces	2025-04-16 12:21:10 +03:00
Orange	b613ff9ef1	added missing header	2025-04-13 23:15:27 +03:00
Orange++	145eadfffa	Merge pull request #36 from orange-cpp/u/orange-cpp/small-refactoring U/orange cpp/small refactoring	2025-04-12 13:34:28 +03:00
Orange	14acebad5f	fixed tests	2025-04-12 00:04:07 +03:00
Orange	4a7a631932	added const method to mat	2025-04-11 23:57:56 +03:00
Orange	e08c22f604	added new build option	2025-04-11 23:54:56 +03:00
Orange	1b47f45af9	improved naming	2025-04-11 23:30:07 +03:00
Orange	466d8f7bec	improvement	2025-04-11 23:20:16 +03:00
Orange	3631c5d698	replaced with STL relization	2025-04-11 23:10:02 +03:00
Orange	b58956efe3	added missing header	2025-04-11 22:59:56 +03:00
Orange	fc1e0c62b8	disabled tests	2025-04-05 20:03:39 +03:00
Orange	8e861b8a85	updated read me	2025-04-05 13:28:28 +03:00
Orange	55085604fd	added include	2025-04-05 13:20:18 +03:00
Orange	7b712ed960	fixed for clang	2025-04-05 13:00:00 +03:00
Orange	138c996393	oops	2025-03-29 22:03:30 +03:00
Orange	0f2a858306	fixed in some cases confilcting with win api	2025-03-29 21:57:35 +03:00
Orange	ea6c1cc929	fix	2025-03-29 18:20:17 +03:00
Orange++	eeb6e40909	Merge pull request #35 from orange-cpp/u/orange-cpp/imrpoved-color U/orange cpp/imrpoved color	2025-03-29 17:43:36 +03:00
Orange	d72ad663cd	added new methods	2025-03-29 05:41:55 +03:00
Orange	3e75d32f59	fixed style	2025-03-29 04:00:35 +03:00
Orange	a8ce5cbaa0	added vcpkg imgui package auto link	2025-03-29 01:56:09 +03:00
Orange	79f76a0755	added new option	2025-03-29 01:53:04 +03:00
Orange	5773cc7798	improved imgui handling	2025-03-24 21:48:51 +03:00
Orange	b6b0184523	fixed for clang	2025-03-24 06:48:51 +03:00
Orange++	a797dd134a	Update README.md	2025-03-24 06:46:02 +03:00
Orange	dc43411bd2	fixed unity view matrix building	2025-03-24 06:30:09 +03:00
Orange++	8959161904	Merge pull request #34 from orange-cpp/u/orange-cpp/add-unity U/orange cpp/add unity	2025-03-23 01:20:16 +03:00
Orange	5d5bd215b2	fix	2025-03-23 01:17:05 +03:00
Orange	a48a257648	removed comment	2025-03-23 01:12:46 +03:00
Orange	ffba4e256a	name fix	2025-03-23 01:06:36 +03:00
Orange	d9219cdddb	naming fixed	2025-03-23 01:02:11 +03:00
Orange	5a1014a239	fix	2025-03-23 00:57:58 +03:00
Orange	74f2241bcf	uncommented test	2025-03-23 00:52:12 +03:00
Orange	8977557a61	fix	2025-03-22 17:41:01 +03:00
Orange	481d7b85df	improved camera	2025-03-22 17:39:40 +03:00
Orange	2b59fb6aa2	updated formulas	2025-03-22 08:36:06 +03:00
Orange	4f037a1952	added unity engine tests	2025-03-22 08:12:16 +03:00
Orange	ef11183c3f	added camera files	2025-03-22 04:26:54 +03:00
Orange++	326d8baaae	Update README.md	2025-03-21 05:31:44 +03:00
				`@@ -1 +0,0 @@`
				`target_sources(omath PRIVATE camera.cpp formulas.cpp)`
				`@@ -1 +0,0 @@`
				`target_sources(omath PRIVATE navigation_mesh.cpp a_star.cpp)`
				`@@ -1 +0,0 @@`
				`target_sources(omath PRIVATE proj_pred_engine_legacy.cpp projectile.cpp target.cpp proj_pred_engine_avx2.cpp proj_pred_engine.cpp)`