Update cmake-multi-platform.yml

switched to clang

Update cmake-multi-platform.yml
Update cmake-multi-platform.yml
Update cmake-multi-platform.yml
Update cmake-multi-platform.yml
Update cmake-multi-platform.yml
Update cmake-multi-platform.yml
Update cmake-multi-platform.yml
Update cmake-multi-platform.yml
added runtime dir

fix

.clang-format

@@ -1,62 +1,64 @@
-# Generated from CLion C/C++ Code Style settings
+# Generated by CLion for Stroustrup
----
+# The Stroustrup style, named after Bjarne Stroustrup, the creator of C++, is similar to the K&R style but differs
-Language: Cpp
+# in its treatment of the class definitions and the placement of braces in certain contexts. The opening brace is
+# placed on the same line as the control statement, and the closing brace is on its own line.
 BasedOnStyle: LLVM
+
 AccessModifierOffset: -4
-AlignConsecutiveAssignments: false
+AlignConsecutiveAssignments: None
-AlignConsecutiveDeclarations: false
+AlignConsecutiveBitFields: None
-AlignOperands: true
+AlignConsecutiveDeclarations: None
+AlignConsecutiveMacros: AcrossEmptyLinesAndComments
 AlignTrailingComments: false
-AllowShortBlocksOnASingleLine: false
+AllowShortBlocksOnASingleLine: Never
 AllowShortFunctionsOnASingleLine: None
-AlwaysBreakTemplateDeclarations: Yes
+AllowShortIfStatementsOnASingleLine: false
-BraceWrapping: 
+AllowShortLoopsOnASingleLine: false
+BreakTemplateDeclarations: Leave
+BreakBeforeBraces: Custom
+BraceWrapping:
   AfterCaseLabel: true
   AfterClass: true
-  AfterControlStatement: true
-  AfterEnum: true
   AfterFunction: true
+  AfterControlStatement: true
+  SplitEmptyFunction: true
+  AfterEnum: true
   AfterNamespace: true
   AfterStruct: true
   AfterUnion: true
   AfterExternBlock: true
-  BeforeCatch: false
+  BeforeCatch: true
-  BeforeElse: false
+  BeforeElse: true
   BeforeLambdaBody: true
-  BeforeWhile: false
+  BeforeWhile: true
-  IndentBraces: false
-  SplitEmptyFunction: true
   SplitEmptyRecord: true
   SplitEmptyNamespace: true
-BreakBeforeBraces: Custom
+BreakBeforeBinaryOperators: All
-BreakConstructorInitializers: AfterColon
+BreakBeforeConceptDeclarations: false
-BreakConstructorInitializersBeforeComma: false
 ColumnLimit: 120
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
+IncludeBlocks: Merge
-ContinuationIndentWidth: 8
+IndentExternBlock: Indent
-IncludeCategories: 
+IndentRequiresClause: false
-  - Regex: '^<.*'
-    Priority: 1
-  - Regex: '^".*'
-    Priority: 2
-  - Regex: '.*'
-    Priority: 3
-IncludeIsMainRegex: '([-_](test|unittest))?$'
-IndentCaseLabels: true
 IndentWidth: 4
-InsertNewlineAtEOF: true
+ContinuationIndentWidth: 8
-MacroBlockBegin: ''
+KeepEmptyLinesAtTheStartOfBlocks: false
-MacroBlockEnd: ''
-MaxEmptyLinesToKeep: 2
 NamespaceIndentation: All
 PointerAlignment: Left
-SpaceAfterCStyleCast: true
+SortUsingDeclarations: true
 SpaceAfterTemplateKeyword: false
+SpaceBeforeCtorInitializerColon: false
+SpaceBeforeParens: Custom
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterFunctionDeclarationName: false
+  AfterFunctionDefinitionName: false
+  AfterForeachMacros: true
+  AfterIfMacros: true
+  AfterOverloadedOperator: false
+  BeforeNonEmptyParentheses: false
 SpaceBeforeRangeBasedForLoopColon: false
 SpaceInEmptyParentheses: false
-SpacesInAngles: false
-SpacesInConditionalStatement: false
 SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
+SpacesInConditionalStatement: false
-TabWidth: 4
+SpacesInContainerLiterals: false
-...
+SpacesInParentheses: false

.github/workflows/cmake-multi-platform.yml

@@ -0,0 +1,79 @@
+name: Omath CI (Arch Linux / Windows)
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+
+##############################################################################
+# 1)  ARCH LINUX  –  Clang / Ninja
+##############################################################################
+jobs:
+  arch-build-and-test:
+    name: Arch Linux (Clang)
+    runs-on: ubuntu-latest
+    container: archlinux:latest
+
+    steps:
+      - name: Install basic tool-chain with pacman
+        shell: bash
+        run: |
+          pacman -Sy --noconfirm archlinux-keyring
+          pacman -Syu --noconfirm --needed \
+                 git base-devel clang cmake ninja
+
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: cmake --preset linux-release -DOMATH_BUILD_TESTS=ON
+
+      - name: Build
+        shell: bash
+        run: cmake --build cmake-build/build/linux-release --target all
+
+      - name: Run unit_tests
+        shell: bash
+        run: ./out/Release/unit_tests
+
+
+
+##############################################################################
+# 2)  Windows  –  MSVC / Ninja
+##############################################################################
+  windows-build-and-test:
+    name: Windows (MSVC)
+    runs-on: windows-latest
+
+    steps:
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install Ninja
+        uses: seanmiddleditch/gha-setup-ninja@v4
+
+      - name: Set up MSVC developer command-prompt
+        uses: ilammy/msvc-dev-cmd@v1
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: cmake --preset windows-release -DOMATH_BUILD_TESTS=ON
+
+      - name: Build
+        shell: bash
+        run: cmake --build cmake-build/build/windows-release --target all
+
+      - name: Run unit_tests.exe
+        shell: bash
+        run: ./out/Release/unit_tests.exe

.gitignore

@@ -1,3 +1,4 @@
 /cmake-build/
 /.idea
 /out
+*.DS_Store

.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

@@ -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)
+    add_library(omath SHARED ${OMATH_SOURCES} ${OMATH_HEADERS})
-else()
+else ()
-    add_library(omath STATIC source/Matrix.cpp)
+    add_library(omath STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
-endif()
+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

CMakePresets.json

@@ -40,8 +40,8 @@
       "binaryDir": "${sourceDir}/cmake-build/build/${presetName}",
       "installDir": "${sourceDir}/cmake-build/install/${presetName}",
       "cacheVariables": {
-        "CMAKE_C_COMPILER": "gcc",
+        "CMAKE_C_COMPILER": "clang",
-        "CMAKE_CXX_COMPILER": "g++"
+        "CMAKE_CXX_COMPILER": "clang++"
       },
       "condition": {
         "type": "equals",
@@ -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"
+      }
     }
   ]
 }

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>

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 |

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
+## Supported Render Pipelines
-### vcpkg
+| ENGINE   | SUPPORT |
-**Note**: Support vcpkg for package management
+|----------|---------|
-1. Install vcpkg (https://github.com/microsoft/vcpkg)
+| Source   | ✅YES    |
-2. Run the following command to install the orange-math package:
+| Unity    | ✅YES    |
-```
+| IWEngine | ✅YES    |
-vcpkg install orange-math
+| Unreal   | ❌NO     |
-```
+
-CMakeLists.txt
+## Supported Operating Systems
-```cmake
+
-find_package(omath CONFIG REQUIRED)
+| OS             | SUPPORT |
-target_link_libraries(main PRIVATE omath::omath)
+|----------------|---------|
-```
+| Windows 10/11  | ✅YES    |
-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)
+| Linux          | ✅YES    |
-### Build from source
+| Darwin (MacOS) | ✅YES    |
-1. Clone the repository:
+
-   ```
+## ⏬ Installation
-   git clone https://github.com/orange-cpp/omath.git
+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.
-   ```
+
-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**.
 ## ❔ 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>

examples/CMakeLists.txt

@@ -1,4 +1,4 @@
 project(examples)
 
-add_executable(ExampleProjectionMatrixBuilder ExampleProjMatBuilder.cpp)
+add_executable(ExampleProjectionMatrixBuilder example_proj_mat_builder.cpp)
 target_link_libraries(ExampleProjectionMatrixBuilder PRIVATE omath::omath)

examples/example_proj_mat_builder.cpp

@@ -1,11 +1,11 @@
 //
 // Created by Vlad on 3/19/2025.
 //
+
+
 #include <iostream>
-#include <omath/engines/opengl_engine/Camera.hpp>
-#include <omath/engines/opengl_engine/Formulas.hpp>
-#include <omath/projection/Camera.hpp>
 #include <print>
+#include <omath/engines/opengl_engine/formulas.hpp>
 
 
 int main()

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> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
+                                             const Vector3<float>& dir_forward, const Vector3<float>& dir_right,
+                                             float ratio = 4.f);
+}

include/omath/Angles.hpp

@@ -1,63 +0,0 @@
-//
-// Created by vlad on 11/6/23.
-//
-
-#pragma once
-#include <numbers>
-#include <cmath>
-
-namespace omath::angles
-{
-    template<class Type>
-    requires std::is_floating_point_v<Type>
-    [[nodiscard]] constexpr Type RadiansToDegrees(const Type& radians)
-    {
-        return radians * (Type(180) / std::numbers::pi_v<Type>);
-    }
-
-    template<class Type>
-    requires std::is_floating_point_v<Type>
-    [[nodiscard]] constexpr Type DegreesToRadians(const Type& degrees)
-    {
-        return degrees * (std::numbers::pi_v<Type> / Type(180));
-    }
-
-    template<class type>
-    requires std::is_floating_point_v<type>
-    [[nodiscard]] type HorizontalFovToVertical(const type& horFov, const type& aspect)
-    {
-        const auto fovRad = DegreesToRadians(horFov);
-
-        const auto vertFov = type(2) * std::atan(std::tan(fovRad / type(2)) / aspect);
-
-        return RadiansToDegrees(vertFov);
-    }
-
-    template<class Type>
-    requires std::is_floating_point_v<Type>
-    [[nodiscard]] Type VerticalFovToHorizontal(const Type& vertFov, const Type& aspect)
-    {
-        const auto fovRad = DegreesToRadians(vertFov);
-
-        const auto horFov = Type(2) * std::atan(std::tan(fovRad / Type(2)) * aspect);
-
-        return RadiansToDegrees(horFov);
-    }
-
-    template<class Type>
-    requires std::is_arithmetic_v<Type>
-    [[nodiscard]] Type WrapAngle(const Type& angle, const Type& min, const Type& max)
-    {
-        if (angle <= max && angle >= min)
-            return angle;
-
-        const Type range = max - min;
-
-        Type wrappedAngle = std::fmod(angle - min, range);
-
-        if (wrappedAngle < 0)
-            wrappedAngle += range;
-
-        return wrappedAngle + min;
-    }
-}

include/omath/Color.hpp

@@ -1,122 +0,0 @@
-//
-// Created by vlad on 2/4/24.
-//
-
-#pragma once
-
-#include "omath/Vector3.hpp"
-#include <cstdint>
-#include "omath/Vector4.hpp"
-
-namespace omath
-{
-    struct HSV
-    {
-        float m_hue{};
-        float m_saturation{};
-        float m_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)
-            {
-                Clamp(0.f, 1.f);
-            }
-
-            constexpr explicit Color() : Vector4()
-            {
-
-            }
-            [[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(float hue, float saturation, 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)
-                {
-                    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;
-
-
-                if (delta == 0.f)
-                    hsvData.m_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);
-
-                if (hsvData.m_hue < 0.f)
-                    hsvData.m_hue += 360.f;
-
-                hsvData.m_hue /= 360.f;
-                hsvData.m_saturation = max == 0.f ? 0.f : delta / max;
-                hsvData.m_value = max;
-
-                return hsvData;
-            }
-
-            constexpr explicit Color(const Vector4& vec) : Vector4(vec)
-            {
-                Clamp(0.f, 1.f);
-            }
-
-            [[nodiscard]]
-            constexpr Color Blend(const Color& other, float ratio) const
-            {
-                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};
-    }
-}

include/omath/Triangle.hpp

@@ -1,84 +0,0 @@
-//
-// Created by Orange on 11/13/2024.
-//
-#pragma once
-#include "omath/Vector3.hpp"
-
-namespace omath
-{
-        /*
-        |\
-        | \
-      a |  \ hypot
-        |   \
-        -----
-          b
-        */
-
-
-    template<class Vector>
-    class Triangle final
-    {
-    public:
-        constexpr Triangle() = default;
-        constexpr Triangle(const Vector& vertex1, const Vector& vertex2, const Vector& vertex3)
-            : m_vertex1(vertex1), m_vertex2(vertex2), m_vertex3(vertex3)
-        {
-        }
-
-        Vector3<float> m_vertex1;
-        Vector3<float> m_vertex2;
-        Vector3<float> m_vertex3;
-
-        [[nodiscard]]
-        constexpr Vector3<float> CalculateNormal() const
-        {
-            const auto b = SideBVector();
-            const auto a = SideAVector();
-            return b.Cross(a).Normalized();
-        }
-
-        [[nodiscard]]
-        float SideALength() const
-        {
-            return m_vertex1.DistTo(m_vertex2);
-        }
-
-        [[nodiscard]]
-        float SideBLength() const
-        {
-            return m_vertex3.DistTo(m_vertex2);
-        }
-
-        [[nodiscard]]
-        constexpr Vector3<float> SideAVector() const
-        {
-            return m_vertex1 - m_vertex2;
-        }
-
-        [[nodiscard]]
-        constexpr float Hypot() const
-        {
-            return m_vertex1.DistTo(m_vertex3);
-        }
-        [[nodiscard]]
-        constexpr bool IsRectangular() const
-        {
-            const auto sideA = SideALength();
-            const auto sideB = SideBLength();
-            const auto hypot = Hypot();
-
-            return std::abs(sideA*sideA + sideB*sideB - hypot*hypot) <= 0.0001f;
-        }
-        [[nodiscard]]
-        constexpr Vector3<float> SideBVector() const
-        {
-            return m_vertex3 - m_vertex2;
-        }
-        [[nodiscard]]
-        constexpr Vector3<float> MidPoint() const
-        {
-            return (m_vertex1 + m_vertex2 + m_vertex3) / 3;
-        }
-    };
-} // namespace omath

include/omath/angle.hpp

@@ -3,8 +3,9 @@
 //
 
 #pragma once
-#include "omath/Angles.hpp"
+#include "omath/angles.hpp"
 #include <algorithm>
+#include <utility>
 
 namespace omath
 {
@@ -22,7 +23,7 @@ namespace omath
         constexpr explicit Angle(const Type& degrees)
         {
             if constexpr (flags == AngleFlags::Normalized)
-                m_angle = angles::WrapAngle(degrees, min, max);
+                m_angle = angles::wrap_angle(degrees, min, max);
 
             else if constexpr (flags == AngleFlags::Clamped)
                 m_angle = std::clamp(degrees, min, max);
@@ -32,20 +33,20 @@ namespace omath
                 std::unreachable();
             }
         }
+
     public:
         [[nodiscard]]
-        constexpr static Angle FromDegrees(const Type& degrees)
+        constexpr static Angle from_degrees(const Type& degrees)
         {
             return Angle{degrees};
         }
-        constexpr Angle() : m_angle(0)
+        constexpr Angle(): m_angle(0)
         {
-
         }
         [[nodiscard]]
-        constexpr static Angle FromRadians(const Type& degrees)
+        constexpr static Angle from_radians(const Type& degrees)
         {
-            return Angle{angles::RadiansToDegrees<Type>(degrees)};
+            return Angle{angles::radians_to_degrees<Type>(degrees)};
         }
 
         [[nodiscard]]
@@ -55,51 +56,51 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Type AsDegrees() const
+        constexpr Type as_degrees() const
         {
             return m_angle;
         }
 
         [[nodiscard]]
-        constexpr Type AsRadians() const
+        constexpr Type as_radians() const
         {
-            return angles::DegreesToRadians(m_angle);
+            return angles::degrees_to_radians(m_angle);
         }
 
         [[nodiscard]]
-        Type Sin() const
+        Type sin() const
         {
-            return std::sin(AsRadians());
+            return std::sin(as_radians());
         }
 
         [[nodiscard]]
-        Type Cos() const
+        Type cos() const
         {
-            return std::cos(AsRadians());
+            return std::cos(as_radians());
         }
 
         [[nodiscard]]
-        Type Tan() const
+        Type tan() const
         {
-            return std::tan(AsRadians());
+            return std::tan(as_radians());
         }
 
         [[nodiscard]]
-        Type Atan() const
+        Type atan() const
         {
-            return std::atan(AsRadians());
+            return std::atan(as_radians());
         }
 
         [[nodiscard]]
-        Type Cot() const
+        Type cot() const
         {
-            return Cos() / Sin();
+            return cos() / sin();
         }
 
         constexpr Angle& operator+=(const Angle& other)
         {
             if constexpr (flags == AngleFlags::Normalized)
-                m_angle = angles::WrapAngle(m_angle + other.m_angle, min, max);
+                m_angle = angles::wrap_angle(m_angle + other.m_angle, min, max);
 
             else if constexpr (flags == AngleFlags::Clamped)
                 m_angle = std::clamp(m_angle + other.m_angle, min, max);
@@ -113,7 +114,8 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr std::partial_ordering operator<=>(const Angle& other) const = default;
+        constexpr std::partial_ordering operator<=>(const Angle& other) const
+                = default;
 
         constexpr Angle& operator-=(const Angle& other)
         {
@@ -124,7 +126,7 @@ namespace omath
         constexpr Angle& operator+(const Angle& other)
         {
             if constexpr (flags == AngleFlags::Normalized)
-                return {angles::WrapAngle(m_angle + other.m_angle, min, max)};
+                return {angles::wrap_angle(m_angle + other.m_angle, min, max)};
 
             else if constexpr (flags == AngleFlags::Clamped)
                 return {std::clamp(m_angle + other.m_angle, min, max)};
@@ -147,4 +149,4 @@ namespace omath
             return Angle{-m_angle};
         }
     };
-}
+} // namespace omath

include/omath/angles.hpp

@@ -0,0 +1,64 @@
+//
+// Created by vlad on 11/6/23.
+//
+
+#pragma once
+#include <cmath>
+#include <numbers>
+
+namespace omath::angles
+{
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] constexpr Type radians_to_degrees(const Type& radians)
+    {
+        return radians * (static_cast<Type>(180) / std::numbers::pi_v<Type>);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] constexpr Type degrees_to_radians(const Type& degrees)
+    {
+        return degrees * (std::numbers::pi_v<Type> / static_cast<Type>(180));
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect)
+    {
+        const auto fov_rad = degrees_to_radians(horizontal_fov);
+
+        const auto vert_fov = static_cast<Type>(2) * std::atan(std::tan(fov_rad / static_cast<Type>(2)) / aspect);
+
+        return radians_to_degrees(vert_fov);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect)
+    {
+        const auto fov_as_radians = degrees_to_radians(vertical_fov);
+
+        const auto horizontal_fov
+                = static_cast<Type>(2) * std::atan(std::tan(fov_as_radians / static_cast<Type>(2)) * aspect);
+
+        return radians_to_degrees(horizontal_fov);
+    }
+
+    template<class Type>
+    requires std::is_arithmetic_v<Type>
+    [[nodiscard]] Type wrap_angle(const Type& angle, const Type& min, const Type& max)
+    {
+        if (angle <= max && angle >= min)
+            return angle;
+
+        const Type range = max - min;
+
+        Type wrapped_angle = std::fmod(angle - min, range);
+
+        if (wrapped_angle < 0)
+            wrapped_angle += range;
+
+        return wrapped_angle + min;
+    }
+} // namespace omath::angles

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,26 +13,25 @@ namespace omath::collision
     public:
         Vector3<float> start;
         Vector3<float> end;
+        bool infinite_length = false;
 
         [[nodiscard]]
-        Vector3<float> DirectionVector() const;
+        Vector3<float> direction_vector() const;
 
         [[nodiscard]]
-        Vector3<float> DirectionVectorNormalized() const;
+        Vector3<float> direction_vector_normalized() const;
     };
     class LineTracer
     {
     public:
         LineTracer() = delete;
 
-
         [[nodiscard]]
-        static bool CanTraceLine(const Ray& ray, const Triangle<Vector3<float>>& triangle);
+        static bool can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle);
-
 
         // Realization of Möller–Trumbore intersection algorithm
         // https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
         [[nodiscard]]
-        static Vector3<float> GetRayHitPoint(const Ray& ray, const Triangle<Vector3<float>>& triangle);
+        static Vector3<float> get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle);
     };
-}
+} // namespace omath::collision

include/omath/color.hpp

@@ -0,0 +1,170 @@
+//
+// Created by vlad on 2/4/24.
+//
+
+#pragma once
+
+#include "omath/vector3.hpp"
+#include "omath/vector4.hpp"
+#include <cstdint>
+
+#ifdef max
+#undef max
+#endif
+
+#ifdef min
+#undef min
+#endif
+
+namespace omath
+{
+    struct Hsv
+    {
+        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)
+        {
+            clamp(0.f, 1.f);
+        }
+
+        constexpr explicit Color() = default;
+        [[nodiscard]]
+        constexpr static Color from_rgba(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 from_hsv(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.f - static_cast<float>(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 static Color from_hsv(const Hsv& hsv)
+        {
+            return from_hsv(hsv.hue, hsv.saturation, hsv.value);
+        }
+
+        [[nodiscard]]
+        constexpr Hsv to_hsv() const
+        {
+            Hsv hsv_data;
+
+            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;
+
+            if (delta == 0.f)
+                hsv_data.hue = 0.f;
+
+            else if (max == red)
+                hsv_data.hue = 60.f * (std::fmodf(((green - blue) / delta), 6.f));
+            else if (max == green)
+                hsv_data.hue = 60.f * (((blue - red) / delta) + 2.f);
+            else if (max == blue)
+                hsv_data.hue = 60.f * (((red - green) / delta) + 4.f);
+
+            if (hsv_data.hue < 0.f)
+                hsv_data.hue += 360.f;
+
+            hsv_data.hue /= 360.f;
+            hsv_data.saturation = max == 0.f ? 0.f : delta / max;
+            hsv_data.value = max;
+
+            return hsv_data;
+        }
+
+        constexpr explicit Color(const Vector4& vec): Vector4(vec)
+        {
+            clamp(0.f, 1.f);
+        }
+        constexpr void set_hue(const float hue)
+        {
+            auto hsv = to_hsv();
+            hsv.hue = hue;
+
+            *this = from_hsv(hsv);
+        }
+
+        constexpr void set_saturation(const float saturation)
+        {
+            auto hsv = to_hsv();
+            hsv.saturation = saturation;
+
+            *this = from_hsv(hsv);
+        }
+
+        constexpr void set_value(const float value)
+        {
+            auto hsv = to_hsv();
+            hsv.value = value;
+
+            *this = from_hsv(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};
+        }
+    };
+} // namespace omath

include/omath/engines/iw_engine/Camera.hpp

@@ -1,21 +0,0 @@
-//
-// Created by Vlad on 3/17/2025.
-//
-
-#pragma once
-#include "Constants.hpp"
-#include "omath/projection/Camera.hpp"
-
-namespace omath::iw_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;
-    };
-}

include/omath/engines/iw_engine/Constants.hpp

@@ -1,25 +0,0 @@
-//
-// Created by Vlad on 3/17/2025.
-//
-
-#pragma once
-#include <omath/Vector3.hpp>
-#include <omath/Mat.hpp>
-#include <omath/Angle.hpp>
-#include <omath/ViewAngles.hpp>
-
-namespace omath::iw_engine
-{
-    constexpr Vector3<float> kAbsUp = {0, 0, 1};
-    constexpr Vector3<float> kAbsRight = {0, -1, 0};
-    constexpr Vector3<float> kAbsForward = {1, 0, 0};
-
-    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 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/iw_engine/Formulas.hpp

@@ -1,24 +0,0 @@
-//
-// Created by Vlad on 3/17/2025.
-//
-
-#pragma once
-#include "Constants.hpp"
-
-namespace omath::iw_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 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
-} // namespace omath::source

include/omath/engines/iw_engine/camera.hpp

@@ -0,0 +1,22 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+
+#pragma once
+#include "omath/engines/iw_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+
+namespace omath::iw_engine
+{
+    class Camera final : public projection::Camera<Mat4X4, ViewAngles>
+    {
+    public:
+        Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
+               const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
+        void look_at(const Vector3<float>& target) override;
+
+    protected:
+        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
+    };
+} // namespace omath::iw_engine

include/omath/engines/iw_engine/constants.hpp

@@ -0,0 +1,25 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+
+#pragma once
+#include <omath/angle.hpp>
+#include <omath/mat.hpp>
+#include <omath/vector3.hpp>
+#include <omath/view_angles.hpp>
+
+namespace omath::iw_engine
+{
+    constexpr Vector3<float> k_abs_up = {0, 0, 1};
+    constexpr Vector3<float> k_abs_right = {0, -1, 0};
+    constexpr Vector3<float> k_abs_forward = {1, 0, 0};
+
+    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 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::iw_engine

include/omath/engines/iw_engine/formulas.hpp

@@ -0,0 +1,26 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+
+#pragma once
+#include "omath/engines/iw_engine/constants.hpp"
+
+namespace omath::iw_engine
+{
+    [[nodiscard]]
+    Vector3<float> forward_vector(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Vector3<float> right_vector(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Vector3<float> up_vector(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles);
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
+
+    [[nodiscard]]
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
+} // namespace omath::iw_engine

include/omath/engines/opengl_engine/Camera.hpp

@@ -1,19 +0,0 @@
-//
-// Created by Orange on 12/23/2024.
-//
-#pragma once
-#include "Constants.hpp"
-#include "omath/projection/Camera.hpp"
-
-namespace omath::opengl_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;
-        [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
-        [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
-    };
-}

include/omath/engines/opengl_engine/Constants.hpp

@@ -1,25 +0,0 @@
-//
-// Created by Orange on 12/23/2024.
-//
-#pragma once
-
-#include <omath/Vector3.hpp>
-#include <omath/Mat.hpp>
-#include <omath/Angle.hpp>
-#include <omath/ViewAngles.hpp>
-
-namespace omath::opengl_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::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 ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
-}

include/omath/engines/opengl_engine/Formulas.hpp

@@ -1,24 +0,0 @@
-//
-// Created by Orange on 12/23/2024.
-//
-#pragma once
-#include "Constants.hpp"
-
-
-namespace omath::opengl_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 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
-} // namespace omath::opengl_engine

include/omath/engines/opengl_engine/camera.hpp

@@ -0,0 +1,19 @@
+//
+// Created by Orange on 12/23/2024.
+//
+#pragma once
+#include "omath/engines/opengl_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+
+namespace omath::opengl_engine
+{
+    class Camera final : public projection::Camera<Mat4X4, ViewAngles>
+    {
+    public:
+        Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
+               const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
+        void look_at(const Vector3<float>& target) override;
+        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
+    };
+} // namespace omath::opengl_engine

include/omath/engines/opengl_engine/constants.hpp

@@ -0,0 +1,25 @@
+//
+// Created by Orange on 12/23/2024.
+//
+#pragma once
+
+#include <omath/angle.hpp>
+#include <omath/mat.hpp>
+#include <omath/vector3.hpp>
+#include <omath/view_angles.hpp>
+
+namespace omath::opengl_engine
+{
+    constexpr Vector3<float> k_abs_up = {0, 1, 0};
+    constexpr Vector3<float> k_abs_right = {1, 0, 0};
+    constexpr Vector3<float> k_abs_forward = {0, 0, -1};
+
+    using Mat4X4 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
+    using Mat3X3 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
+    using Mat1X3 = Mat<1, 3, float, MatStoreType::COLUMN_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::opengl_engine

include/omath/engines/opengl_engine/formulas.hpp

@@ -0,0 +1,26 @@
+//
+// Created by Orange on 12/23/2024.
+//
+#pragma once
+#include "omath/engines/opengl_engine/constants.hpp"
+
+
+namespace omath::opengl_engine
+{
+    [[nodiscard]]
+    Vector3<float> forward_vector(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Vector3<float> right_vector(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Vector3<float> up_vector(const ViewAngles& angles);
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
+
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
+} // namespace omath::opengl_engine

include/omath/engines/source_engine/Camera.hpp

@@ -1,20 +0,0 @@
-//
-// Created by Orange on 12/4/2024.
-//
-#pragma once
-#include "Constants.hpp"
-#include "omath/projection/Camera.hpp"
-
-namespace omath::source_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;
-    };
-}

include/omath/engines/source_engine/Constants.hpp

@@ -1,25 +0,0 @@
-//
-// Created by Orange on 12/4/2024.
-//
-#pragma once
-
-#include <omath/Vector3.hpp>
-#include <omath/Mat.hpp>
-#include <omath/Angle.hpp>
-#include <omath/ViewAngles.hpp>
-
-namespace omath::source_engine
-{
-    constexpr Vector3<float> kAbsUp = {0, 0, 1};
-    constexpr Vector3<float> kAbsRight = {0, -1, 0};
-    constexpr Vector3<float> kAbsForward = {1, 0, 0};
-
-    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 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

include/omath/engines/source_engine/Formulas.hpp

@@ -1,23 +0,0 @@
-//
-// Created by Orange on 12/4/2024.
-//
-#pragma once
-#include "Constants.hpp"
-
-namespace omath::source_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 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
-} // namespace omath::source

include/omath/engines/source_engine/camera.hpp

@@ -0,0 +1,21 @@
+//
+// Created by Orange on 12/4/2024.
+//
+#pragma once
+#include "omath/engines/source_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+
+namespace omath::source_engine
+{
+    class Camera final : public projection::Camera<Mat4X4, ViewAngles>
+    {
+    public:
+        Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
+               const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
+        void look_at(const Vector3<float>& target) override;
+
+    protected:
+        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
+    };
+} // namespace omath::source_engine

include/omath/engines/source_engine/constants.hpp

@@ -0,0 +1,25 @@
+//
+// Created by Orange on 12/4/2024.
+//
+#pragma once
+
+#include <omath/angle.hpp>
+#include <omath/mat.hpp>
+#include <omath/vector3.hpp>
+#include <omath/view_angles.hpp>
+
+namespace omath::source_engine
+{
+    constexpr Vector3<float> k_abs_up = {0, 0, 1};
+    constexpr Vector3<float> k_abs_right = {0, -1, 0};
+    constexpr Vector3<float> k_abs_forward = {1, 0, 0};
+
+    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 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_engine

include/omath/engines/source_engine/formulas.hpp

@@ -0,0 +1,25 @@
+//
+// Created by Orange on 12/4/2024.
+//
+#pragma once
+#include "omath/engines/source_engine/constants.hpp"
+
+namespace omath::source_engine
+{
+    [[nodiscard]]
+    Vector3<float> forward_vector(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Vector3<float> right_vector(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Vector3<float> up_vector(const ViewAngles& angles);
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
+
+    [[nodiscard]]
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
+} // namespace omath::source_engine

include/omath/engines/unity_engine/camera.hpp

@@ -0,0 +1,22 @@
+//
+// 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& view_angles, const projection::ViewPort& view_port,
+               const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
+        void look_at(const Vector3<float>& target) override;
+
+    protected:
+        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
+    };
+} // namespace omath::unity_engine

include/omath/engines/unity_engine/constants.hpp

@@ -0,0 +1,26 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+
+#pragma once
+
+#include <omath/angle.hpp>
+#include <omath/mat.hpp>
+#include <omath/vector3.hpp>
+#include <omath/view_angles.hpp>
+
+namespace omath::unity_engine
+{
+    constexpr Vector3<float> k_abs_up = {0, 1, 0};
+    constexpr Vector3<float> k_abs_right = {1, 0, 0};
+    constexpr Vector3<float> k_abs_forward = {0, 0, 1};
+
+    using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3X3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat1X3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
+    using PitchAngle = Angle<float, -90.f, 90.f, AngleFlags::Clamped>;
+    using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+    using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+
+    using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
+} // namespace omath::unity_engine

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> forward_vector(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Vector3<float> right_vector(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Vector3<float> up_vector(const ViewAngles& angles);
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
+
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles);
+
+    [[nodiscard]]
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
+} // namespace omath::unity_engine

include/omath/mat.hpp

@@ -2,13 +2,22 @@
 // Created by vlad on 9/29/2024.
 //
 #pragma once
+#include "omath/vector3.hpp"
 #include <algorithm>
 #include <array>
+#include <iomanip>
+#include <numeric>
 #include <sstream>
 #include <stdexcept>
 #include <utility>
-#include "Vector3.hpp"
+
-#include <iomanip>
+#ifdef near
+#undef near
+#endif
+
+#ifdef far
+#undef far
+#endif
 
 namespace omath
 {
@@ -23,25 +32,22 @@ namespace omath
         COLUMN_MAJOR
     };
 
-
+    template<typename M1, typename M2> concept MatTemplateEqual
-    template<typename M1, typename M2>
+            = (M1::rows == M2::rows) && (M1::columns == M2::columns)
-    concept MatTemplateEqual =
+              && std::is_same_v<typename M1::value_type, typename M2::value_type> && (M1::store_type == M2::store_type);
-            (M1::rows == M2::rows) && (M1::columns == M2::columns) &&
-            std::is_same_v<typename M1::value_type, typename M2::value_type> &&
-            (M1::store_type == M2::store_type);
 
     template<size_t Rows = 0, size_t Columns = 0, class Type = float, MatStoreType StoreType = MatStoreType::ROW_MAJOR>
-        requires std::is_arithmetic_v<Type>
+    requires std::is_arithmetic_v<Type>
     class Mat final
     {
     public:
         constexpr Mat() noexcept
         {
-            Clear();
+            clear();
         }
 
         [[nodiscard]]
-        constexpr static MatStoreType GetStoreOrdering() noexcept
+        constexpr static MatStoreType get_store_ordering() noexcept
         {
             return StoreType;
         }
@@ -50,24 +56,24 @@ namespace omath
             if (rows.size() != Rows)
                 throw std::invalid_argument("Initializer list rows size does not match template parameter Rows");
 
-            auto rowIt = rows.begin();
+            auto row_it = rows.begin();
-            for (size_t i = 0; i < Rows; ++i, ++rowIt)
+            for (size_t i = 0; i < Rows; ++i, ++row_it)
             {
-                if (rowIt->size() != Columns)
+                if (row_it->size() != Columns)
                     throw std::invalid_argument(
                             "All rows must have the same number of columns as template parameter Columns");
 
-                auto colIt = rowIt->begin();
+                auto col_it = row_it->begin();
-                for (size_t j = 0; j < Columns; ++j, ++colIt)
+                for (size_t j = 0; j < Columns; ++j, ++col_it)
                 {
-                    At(i, j) = std::move(*colIt);
+                    at(i, j) = std::move(*col_it);
                 }
             }
         }
 
-        constexpr explicit Mat(const Type* rawData)
+        constexpr explicit Mat(const Type* raw_data)
         {
-            std::copy_n(rawData, Rows * Columns, m_data.begin());
+            std::copy_n(raw_data, Rows * Columns, m_data.begin());
         }
 
         constexpr Mat(const Mat& other) noexcept
@@ -78,7 +84,13 @@ namespace omath
         [[nodiscard]]
         constexpr Type& operator[](const size_t row, const size_t col)
         {
-            return At(row, col);
+            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
@@ -87,34 +99,35 @@ namespace omath
         }
 
         [[nodiscard]]
-        static constexpr size_t RowCount() noexcept
+        static constexpr size_t row_count() noexcept
         {
             return Rows;
         }
 
         [[nodiscard]]
-        static constexpr size_t ColumnsCount() noexcept
+        static constexpr size_t columns_count() noexcept
         {
             return Columns;
         }
 
         [[nodiscard]]
-        static consteval MatSize Size() noexcept
+        static consteval MatSize size() noexcept
         {
             return {Rows, Columns};
         }
 
         [[nodiscard]]
-        constexpr const Type& At(const size_t rowIndex, const size_t columnIndex) const
+        constexpr const Type& at(const size_t row_index, const size_t column_index) const
         {
-            if (rowIndex >= Rows || columnIndex >= Columns)
+#if !defined(NDEBUG) && defined(OMATH_SUPRESS_SAFETY_CHECKS)
+            if (row_index >= Rows || column_index >= Columns)
                 throw std::out_of_range("Index out of range");
-
+#endif
             if constexpr (StoreType == MatStoreType::ROW_MAJOR)
-                return m_data[rowIndex * Columns + columnIndex];
+                return m_data[row_index * Columns + column_index];
 
             else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
-                return m_data[rowIndex + columnIndex * Rows];
+                return m_data[row_index + column_index * Rows];
 
             else
             {
@@ -123,34 +136,29 @@ namespace omath
             }
         }
 
-        [[nodiscard]] constexpr Type& At(const size_t rowIndex, const size_t columnIndex)
+        [[nodiscard]] constexpr Type& at(const size_t row_index, const size_t column_index)
         {
-            return const_cast<Type&>(std::as_const(*this).At(rowIndex, columnIndex));
+            return const_cast<Type&>(std::as_const(*this).at(row_index, column_index));
         }
 
         [[nodiscard]]
-        constexpr Type Sum() const noexcept
+        constexpr Type sum() const noexcept
         {
-            Type sum = 0;
+            return std::accumulate(m_data.begin(), m_data.end(), static_cast<Type>(0));
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    sum += At(i, j);
-
-            return sum;
         }
 
-        constexpr void Clear() noexcept
+        constexpr void clear() noexcept
         {
-            Set(0);
+            set(static_cast<Type>(0));
         }
 
-        constexpr void Set(const Type& value) noexcept
+        constexpr void set(const Type& value) noexcept
         {
             std::ranges::fill(m_data, value);
         }
 
         // Operator overloading for multiplication with another Mat
-        template<size_t OtherColumns>
+        template<size_t OtherColumns> [[nodiscard]]
         constexpr Mat<Rows, OtherColumns, Type, StoreType>
         operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
         {
@@ -161,109 +169,101 @@ namespace omath
                 {
                     Type sum = 0;
                     for (size_t k = 0; k < Columns; ++k)
-                        sum += At(i, k) * other.At(k, j);
+                        sum += at(i, k) * other.at(k, j);
-                    result.At(i, j) = sum;
+                    result.at(i, j) = sum;
                 }
             return result;
         }
 
         constexpr Mat& operator*=(const Type& f) noexcept
         {
-            for (size_t i = 0; i < Rows; ++i)
+            std::ranges::for_each(m_data, [&f](auto& val) { val *= f; });
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) *= f;
             return *this;
         }
 
-        template<size_t OtherColumns>
+        template<size_t OtherColumns> constexpr Mat<Rows, OtherColumns, Type, StoreType>
-        constexpr Mat<Rows, OtherColumns, Type, StoreType>
         operator*=(const Mat<Columns, OtherColumns, Type, StoreType>& other)
         {
             return *this = *this * other;
         }
 
         [[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)
+            std::ranges::for_each(m_data, [&value](auto& val) { val /= value; });
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) /= f;
             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)
+            if (this != &other)
-                return *this;
+                m_data = other.m_data;
-            for (size_t i = 0; i < Rows; ++i)
+
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) = other.At(i, j);
             return *this;
         }
 
         constexpr Mat& operator=(Mat&& other) noexcept
         {
-            if (this == &other)
+            if (this != &other)
-                return *this;
+                m_data = std::move(other.m_data);
-
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) = other.At(i, j);
 
             return *this;
         }
 
         [[nodiscard]]
-        constexpr Mat<Columns, Rows, Type, StoreType> Transposed() const noexcept
+        constexpr Mat<Columns, Rows, Type, StoreType> transposed() const noexcept
         {
             Mat<Columns, Rows, Type, StoreType> transposed;
             for (size_t i = 0; i < Rows; ++i)
                 for (size_t j = 0; j < Columns; ++j)
-                    transposed.At(j, i) = At(i, j);
+                    transposed.at(j, i) = at(i, j);
 
             return transposed;
         }
 
         [[nodiscard]]
-        constexpr Type Determinant() const
+        constexpr Type determinant() const
         {
             static_assert(Rows == Columns, "Determinant is only defined for square matrices.");
 
             if constexpr (Rows == 1)
-                return At(0, 0);
+                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);
+                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) * alg_complement(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)
             {
@@ -273,7 +273,7 @@ namespace omath
                 {
                     if (j == column)
                         continue;
-                    result.At(m, n) = At(i, j);
+                    result.at(m, n) = at(i, j);
                     ++n;
                 }
                 ++m;
@@ -282,19 +282,32 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr const std::array<Type, Rows * Columns>& RawArray() const
+        constexpr Type minor(const size_t row, const size_t column) const
+        {
+            return strip(row, column).determinant();
+        }
+
+        [[nodiscard]]
+        constexpr Type alg_complement(const size_t row, const size_t column) const
+        {
+            const auto minor_value = minor(row, column);
+            return (row + column + 2) % 2 == 0 ? minor_value : -minor_value;
+        }
+
+        [[nodiscard]]
+        constexpr const std::array<Type, Rows * Columns>& raw_array() const
         {
             return m_data;
         }
 
         [[nodiscard]]
-        constexpr std::array<Type, Rows * Columns>& RawArray()
+        constexpr std::array<Type, Rows * Columns>& raw_array()
         {
-            return const_cast<std::array<Type, Rows * Columns>>(std::as_const(*this).RawArray());
+            return m_data;
         }
 
         [[nodiscard]]
-        std::string ToString() const noexcept
+        std::string to_string() const noexcept
         {
             std::ostringstream oss;
             oss << "[[";
@@ -306,7 +319,7 @@ namespace omath
 
                 for (size_t j = 0; j < Columns; ++j)
                 {
-                    oss << std::setw(9) << std::fixed << std::setprecision(3) << At(i, j);
+                    oss << std::setw(9) << std::fixed << std::setprecision(3) << at(i, j);
                     if (j != Columns - 1)
                         oss << ", ";
                 }
@@ -329,37 +342,55 @@ namespace omath
 
         // Static methods that return fixed-size matrices
         [[nodiscard]]
-        constexpr static Mat<4, 4> ToScreenMat(const Type& screenWidth, const Type& screenHeight) noexcept
+        constexpr static Mat<4, 4> to_screen_mat(const Type& screen_width, const Type& screen_height) noexcept
         {
             return {
-                    {screenWidth / 2, 0, 0, 0},
+                    {screen_width / 2, 0, 0, 0},
-                    {0, -screenHeight / 2, 0, 0},
+                    {0, -screen_height / 2, 0, 0},
                     {0, 0, 1, 0},
-                    {screenWidth / 2, screenHeight / 2, 0, 1},
+                    {screen_width / 2, screen_height / 2, 0, 1},
             };
         }
 
+        [[nodiscard]]
+        constexpr std::optional<Mat> inverted() const
+        {
+            const auto det = determinant();
+
+            if (det == 0)
+                return std::nullopt;
+
+            const auto transposed_mat = 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_mat.alg_complement(row, column);
+
+            result /= det;
+
+            return {result};
+        }
+
     private:
         std::array<Type, Rows * Columns> m_data;
     };
 
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard]]
-    [[nodiscard]]
+    constexpr static Mat<1, 4, Type, St> mat_row_from_vector(const Vector3<Type>& vector) noexcept
-    constexpr static Mat<1, 4, Type, St> MatRowFromVector(const Vector3<Type>& vector) noexcept
     {
         return {{vector.x, vector.y, vector.z, 1}};
     }
 
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard]]
-    [[nodiscard]]
+    constexpr static Mat<4, 1, Type, St> mat_column_from_vector(const Vector3<Type>& vector) noexcept
-    constexpr static Mat<4, 1, Type, St> MatColumnFromVector(const Vector3<Type>& vector) noexcept
     {
         return {{vector.x}, {vector.y}, {vector.z}, {1}};
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
-    constexpr Mat<4, 4, Type, St> MatTranslation(const Vector3<Type>& diff) noexcept
+    constexpr Mat<4, 4, Type, St> mat_translation(const Vector3<Type>& diff) noexcept
     {
         return
         {
@@ -372,38 +403,38 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard]]
-    Mat<4, 4, Type, St> MatRotationAxisX(const Angle& angle) noexcept
+    Mat<4, 4, Type, St> mat_rotation_axis_x(const Angle& angle) noexcept
     {
         return
         {
             {1, 0,           0,            0},
-            {0, angle.Cos(), -angle.Sin(), 0},
+            {0, angle.cos(), -angle.sin(), 0},
-            {0, angle.Sin(), angle.Cos(),  0},
+            {0, angle.sin(), angle.cos(),  0},
             {0, 0,           0,            1}
         };
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard]]
-    Mat<4, 4, Type, St> MatRotationAxisY(const Angle& angle) noexcept
+    Mat<4, 4, Type, St> mat_rotation_axis_y(const Angle& angle) noexcept
     {
         return
         {
-            {angle.Cos(),  0, angle.Sin(), 0},
+            {angle.cos(),  0, angle.sin(), 0},
             {0           , 1,           0, 0},
-            {-angle.Sin(), 0, angle.Cos(), 0},
+            {-angle.sin(), 0, angle.cos(), 0},
             {0           , 0,           0, 1}
         };
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard]]
-    Mat<4, 4, Type, St> MatRotationAxisZ(const Angle& angle) noexcept
+    Mat<4, 4, Type, St> mat_rotation_axis_z(const Angle& angle) noexcept
     {
         return
         {
-            {angle.Cos(), -angle.Sin(), 0, 0},
+            {angle.cos(), -angle.sin(), 0, 0},
-            {angle.Sin(),  angle.Cos(), 0, 0},
+            {angle.sin(),  angle.cos(), 0, 0},
             {          0,        0,     1, 0},
             {          0,        0,     0, 1},
         };
@@ -411,8 +442,8 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
-    static Mat<4, 4, Type, St> MatCameraView(const Vector3<Type>& forward, const Vector3<Type>& right,
+    static Mat<4, 4, Type, St> mat_camera_view(const Vector3<Type>& forward, const Vector3<Type>& right,
-                                             const Vector3<Type>& up, const Vector3<Type>& cameraOrigin) noexcept
+                                               const Vector3<Type>& up, const Vector3<Type>& camera_origin) noexcept
     {
         return  Mat<4, 4, Type, St>
         {
@@ -421,13 +452,32 @@ namespace omath
             {forward.x, forward.y, forward.z, 0},
             {0,         0,         0,         1},
 
-        } * MatTranslation<Type, St>(-cameraOrigin);
+        } * mat_translation<Type, St>(-camera_origin);
     }
 
-    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> mat_perspective_left_handed(const float field_of_view, const float aspect_ratio,
+                                                    const float near, const float far) noexcept
     {
-        return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+
+        return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
+                {0.f, 1.f / fov_half_tan, 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> mat_perspective_right_handed(const float field_of_view, const float aspect_ratio,
+                                                     const float near, const float far) noexcept
+    {
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+
+        return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
+                {0.f, 1.f / fov_half_tan, 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

include/omath/matrix.hpp

@@ -1,8 +1,8 @@
 #pragma once
+#include "omath/vector3.hpp"
 #include <initializer_list>
 #include <memory>
 #include <string>
-#include "Vector3.hpp"
 
 namespace omath
 {
@@ -16,51 +16,51 @@ namespace omath
         Matrix(const std::initializer_list<std::initializer_list<float>>& rows);
 
         [[nodiscard]]
-        static Matrix ToScreenMatrix(float screenWidth, float screenHeight);
+        static Matrix to_screen_matrix(float screen_width, float screen_height);
 
         [[nodiscard]]
-        static Matrix TranslationMatrix(const Vector3<float>& diff);
+        static Matrix translation_matrix(const Vector3<float>& diff);
 
         [[nodiscard]]
-        static Matrix OrientationMatrix(const Vector3<float>& forward, const Vector3<float>& right, const Vector3<float>& up);
+        static Matrix orientation_matrix(const Vector3<float>& forward, const Vector3<float>& right,
+                                         const Vector3<float>& up);
 
         [[nodiscard]]
-        static Matrix ProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
+        static Matrix projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
 
         Matrix(const Matrix& other);
 
-        Matrix(size_t rows, size_t columns, const float* pRaw);
+        Matrix(size_t rows, size_t columns, const float* raw_data);
 
         Matrix(Matrix&& other) noexcept;
 
         [[nodiscard]]
-        size_t RowCount() const noexcept;
+        size_t row_count() const noexcept;
-
 
         [[nodiscard]]
         float& operator[](size_t row, size_t column);
 
         [[nodiscard]]
-        size_t ColumnsCount() const noexcept;
+        size_t columns_count() const noexcept;
 
         [[nodiscard]]
-        std::pair<size_t, size_t> Size() const noexcept;
+        std::pair<size_t, size_t> size() const noexcept;
 
         [[nodiscard]]
-        float& At(size_t iRow, size_t iCol);
+        float& at(size_t row, size_t col);
 
         [[nodiscard]]
-        float Sum();
+        float sum();
 
-        void SetDataFromRaw(const float* pRawMatrix);
+        void set_data_from_raw(const float* raw_matrix);
 
         [[nodiscard]]
-        Matrix Transpose() const;
+        Matrix transpose() const;
 
-        void Set(float val);
+        void set(float val);
 
         [[nodiscard]]
-        const float& At(size_t iRow, size_t iCol) const;
+        const float& at(size_t row, size_t col) const;
 
         Matrix operator*(const Matrix& other) const;
 
@@ -72,22 +72,22 @@ namespace omath
 
         Matrix& operator/=(float f);
 
-        void Clear();
+        void clear();
 
         [[nodiscard]]
-        Matrix Strip(size_t row, size_t column) const;
+        Matrix strip(size_t row, size_t column) const;
 
         [[nodiscard]]
-        float Minor(size_t i, size_t j) const;
+        float minor(size_t i, size_t j) const;
 
         [[nodiscard]]
-        float AlgComplement(size_t i, size_t j) const;
+        float alg_complement(size_t i, size_t j) const;
 
         [[nodiscard]]
-        float Determinant() const;
+        float determinant() const;
 
         [[nodiscard]]
-        const float* Raw() const;
+        const float* raw() const;
 
         Matrix& operator=(const Matrix& other);
 
@@ -96,7 +96,7 @@ namespace omath
         Matrix operator/(float f) const;
 
         [[nodiscard]]
-        std::string ToString() const;
+        std::string to_string() const;
 
         ~Matrix();
 

include/omath/pathfinding/Astar.hpp

@@ -1,30 +0,0 @@
-//
-// Created by Vlad on 28.07.2024.
-//
-
-#pragma once
-#include <vector>
-#include "NavigationMesh.hpp"
-#include "omath/Vector3.hpp"
-
-namespace omath::pathfinding
-{
-    struct PathNode;
-    class Astar final
-    {
-    public:
-        [[nodiscard]]
-        static std::vector<Vector3<float>> FindPath(const Vector3<float>& start, const Vector3<float>& end,
-                                                    const NavigationMesh& navMesh);
-
-    private:
-        [[nodiscard]]
-        static std::vector<Vector3<float>>
-        ReconstructFinalPath(const std::unordered_map<Vector3<float>, PathNode>& closedList,
-                             const Vector3<float>& current);
-
-        [[nodiscard]]
-        static auto GetPerfectNode(const std::unordered_map<Vector3<float>, PathNode>& openList,
-                                   const Vector3<float>& endVertex);
-    };
-} // namespace omath::pathfinding

include/omath/pathfinding/NavigationMesh.hpp

@@ -1,38 +0,0 @@
-//
-// Created by Vlad on 28.07.2024.
-//
-
-#pragma once
-
-#include "omath/Vector3.hpp"
-#include <expected>
-#include <vector>
-#include <string>
-
-namespace omath::pathfinding
-{
-
-    enum Error
-    {
-        
-    };
-
-    class NavigationMesh final
-    {
-    public:
-
-        [[nodiscard]]
-        std::expected<Vector3<float>, std::string> GetClosestVertex(const Vector3<float>& point) const;
-
-
-        [[nodiscard]]
-        const std::vector<Vector3<float>>& GetNeighbors(const Vector3<float>& vertex) const;
-
-        [[nodiscard]]
-        bool Empty() const;
-        [[nodiscard]] std::vector<uint8_t> Serialize() const;
-        void Deserialize(const std::vector<uint8_t>& raw);
-
-        std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_verTextMap;
-    };
-}

include/omath/pathfinding/a_star.hpp

@@ -0,0 +1,30 @@
+//
+// Created by Vlad on 28.07.2024.
+//
+
+#pragma once
+#include "omath/pathfinding/navigation_mesh.hpp"
+#include "omath/vector3.hpp"
+#include <vector>
+
+namespace omath::pathfinding
+{
+    struct PathNode;
+    class Astar final
+    {
+    public:
+        [[nodiscard]]
+        static std::vector<Vector3<float>> find_path(const Vector3<float>& start, const Vector3<float>& end,
+                                                     const NavigationMesh& nav_mesh);
+
+    private:
+        [[nodiscard]]
+        static std::vector<Vector3<float>>
+        reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
+                               const Vector3<float>& current);
+
+        [[nodiscard]]
+        static auto get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
+                                     const Vector3<float>& end_vertex);
+    };
+} // namespace omath::pathfinding

include/omath/pathfinding/navigation_mesh.hpp

@@ -0,0 +1,38 @@
+//
+// Created by Vlad on 28.07.2024.
+//
+
+#pragma once
+
+#include "omath/vector3.hpp"
+#include <expected>
+#include <string>
+#include <vector>
+
+namespace omath::pathfinding
+{
+
+    enum Error
+    {
+
+    };
+
+    class NavigationMesh final
+    {
+    public:
+        [[nodiscard]]
+        std::expected<Vector3<float>, std::string> get_closest_vertex(const Vector3<float>& point) const;
+
+        [[nodiscard]]
+        const std::vector<Vector3<float>>& get_neighbors(const Vector3<float>& vertex) const;
+
+        [[nodiscard]]
+        bool empty() const;
+
+        [[nodiscard]] std::vector<uint8_t> serialize() const;
+
+        void deserialize(const std::vector<uint8_t>& raw);
+
+        std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_vertex_map;
+    };
+} // namespace omath::pathfinding

include/omath/projectile_prediction/ProjPredEngine.hpp

@@ -1,20 +0,0 @@
-//
-// Created by Vlad on 2/23/2025.
-//
-#pragma once
-#include "Projectile.hpp"
-#include "Target.hpp"
-#include "omath/Vector3.hpp"
-
-
-namespace omath::projectile_prediction
-{
-    class ProjPredEngine
-    {
-    public:
-        [[nodiscard]]
-        virtual std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
-                                                              const Target& target) const = 0;
-        virtual ~ProjPredEngine() = default;
-    };
-} // namespace omath::projectile_prediction

include/omath/projectile_prediction/ProjPredEngineAVX2.hpp

@@ -1,26 +0,0 @@
-//
-// Created by Vlad on 2/23/2025.
-//
-#pragma once
-#include "ProjPredEngine.hpp"
-
-namespace omath::projectile_prediction
-{
-    class ProjPredEngineAVX2 final : public ProjPredEngine
-    {
-    public:
-        [[nodiscard]] std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
-                                                                    const Target& target) const override;
-
-
-        ProjPredEngineAVX2(float gravityConstant, float simulationTimeStep, float maximumSimulationTime);
-        ~ProjPredEngineAVX2() override = default;
-
-    private:
-        [[nodiscard]] static std::optional<float> CalculatePitch(const Vector3<float>& projOrigin, const Vector3<float>& targetPos,
-                                                                 float bulletGravity, float v0, float time);
-        const float m_gravityConstant;
-        const float m_simulationTimeStep;
-        const float m_maximumSimulationTime;
-    };
-} // namespace omath::projectile_prediction

include/omath/projectile_prediction/ProjPredEngineLegacy.hpp

@@ -1,41 +0,0 @@
-//
-// Created by Vlad on 6/9/2024.
-//
-
-#pragma once
-
-#include <optional>
-#include "omath/Vector3.hpp"
-#include "omath/projectile_prediction/ProjPredEngine.hpp"
-#include "omath/projectile_prediction/Projectile.hpp"
-#include "omath/projectile_prediction/Target.hpp"
-
-
-namespace omath::projectile_prediction
-{
-    class ProjPredEngineLegacy final : public ProjPredEngine
-    {
-    public:
-        explicit ProjPredEngineLegacy(float gravityConstant, float simulationTimeStep, float maximumSimulationTime,
-                                      float distanceTolerance);
-
-        [[nodiscard]]
-        std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
-                                                      const Target& target) const override;
-
-    private:
-        const float m_gravityConstant;
-        const float m_simulationTimeStep;
-        const float m_maximumSimulationTime;
-        const float m_distanceTolerance;
-
-        [[nodiscard]]
-        std::optional<float> MaybeCalculateProjectileLaunchPitchAngle(const Projectile& projectile,
-                                                                      const Vector3<float>& targetPosition) const;
-
-
-        [[nodiscard]]
-        bool IsProjectileReachedTarget(const Vector3<float>& targetPosition, const Projectile& projectile, float pitch,
-                                       float time) const;
-    };
-} // namespace omath::projectile_prediction

include/omath/projectile_prediction/Projectile.hpp

@@ -1,21 +0,0 @@
-//
-// Created by Vlad on 6/9/2024.
-//
-
-#pragma once
-#include "omath/Vector3.hpp"
-
-namespace omath::projectile_prediction
-{
-    class Projectile final
-    {
-    public:
-
-        [[nodiscard]]
-        Vector3<float> PredictPosition(float pitch, float yaw, float time, float gravity) const;
-
-        Vector3<float> m_origin;
-        float m_launchSpeed{};
-        float m_gravityScale{};
-    };
-}

include/omath/projectile_prediction/proj_pred_engine.hpp

@@ -0,0 +1,19 @@
+//
+// Created by Vlad on 2/23/2025.
+//
+#pragma once
+#include "omath/projectile_prediction/projectile.hpp"
+#include "omath/projectile_prediction/target.hpp"
+#include "omath/vector3.hpp"
+
+namespace omath::projectile_prediction
+{
+    class ProjPredEngine
+    {
+    public:
+        [[nodiscard]]
+        virtual std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
+                                                                        const Target& target) const = 0;
+        virtual ~ProjPredEngine() = default;
+    };
+} // namespace omath::projectile_prediction

include/omath/projectile_prediction/proj_pred_engine_avx2.hpp

@@ -0,0 +1,28 @@
+//
+// Created by Vlad on 2/23/2025.
+//
+#pragma once
+#include "omath/projectile_prediction/proj_pred_engine.hpp"
+
+namespace omath::projectile_prediction
+{
+    class ProjPredEngineAvx2 final : public ProjPredEngine
+    {
+    public:
+        [[nodiscard]] std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
+                                                                              const Target& target) const override;
+
+        ProjPredEngineAvx2(float gravity_constant, float simulation_time_step, float maximum_simulation_time);
+        ~ProjPredEngineAvx2() override = default;
+
+    private:
+        [[nodiscard]] static std::optional<float> calculate_pitch(const Vector3<float>& proj_origin,
+                                                                  const Vector3<float>& target_pos,
+                                                                  float bullet_gravity, float v0, float time);
+
+        // We use [[maybe_unused]] here since AVX2 is not available for ARM and ARM64 CPU
+        [[maybe_unused]] const float m_gravity_constant;
+        [[maybe_unused]] const float m_simulation_time_step;
+        [[maybe_unused]] const float m_maximum_simulation_time;
+    };
+} // namespace omath::projectile_prediction

include/omath/projectile_prediction/proj_pred_engine_legacy.hpp

@@ -0,0 +1,39 @@
+//
+// Created by Vlad on 6/9/2024.
+//
+
+#pragma once
+
+#include "omath/projectile_prediction/proj_pred_engine.hpp"
+#include "omath/projectile_prediction/projectile.hpp"
+#include "omath/projectile_prediction/target.hpp"
+#include "omath/vector3.hpp"
+#include <optional>
+
+namespace omath::projectile_prediction
+{
+    class ProjPredEngineLegacy final : public ProjPredEngine
+    {
+    public:
+        explicit ProjPredEngineLegacy(float gravity_constant, float simulation_time_step, float maximum_simulation_time,
+                                      float distance_tolerance);
+
+        [[nodiscard]]
+        std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
+                                                                const Target& target) const override;
+
+    private:
+        const float m_gravity_constant;
+        const float m_simulation_time_step;
+        const float m_maximum_simulation_time;
+        const float m_distance_tolerance;
+
+        [[nodiscard]]
+        std::optional<float> maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
+                                                                           const Vector3<float>& target_position) const;
+
+        [[nodiscard]]
+        bool is_projectile_reached_target(const Vector3<float>& target_position, const Projectile& projectile,
+                                          float pitch, float time) const;
+    };
+} // namespace omath::projectile_prediction

include/omath/projectile_prediction/projectile.hpp

@@ -0,0 +1,20 @@
+//
+// Created by Vlad on 6/9/2024.
+//
+
+#pragma once
+#include "omath/vector3.hpp"
+
+namespace omath::projectile_prediction
+{
+    class Projectile final
+    {
+    public:
+        [[nodiscard]]
+        Vector3<float> predict_position(float pitch, float yaw, float time, float gravity) const;
+
+        Vector3<float> m_origin;
+        float m_launch_speed{};
+        float m_gravity_scale{};
+    };
+} // namespace omath::projectile_prediction

include/omath/projectile_prediction/target.hpp

@@ -3,20 +3,19 @@
 //
 
 #pragma once
-#include "omath/Vector3.hpp"
+#include "omath/vector3.hpp"
 
 namespace omath::projectile_prediction
 {
     class Target final
     {
     public:
-
         [[nodiscard]]
-        constexpr Vector3<float> PredictPosition(const float time, const float gravity) const
+        constexpr Vector3<float> predict_position(const float time, const float gravity) const
         {
             auto predicted = m_origin + m_velocity * time;
 
-            if (m_isAirborne)
+            if (m_is_airborne)
                 predicted.z -= gravity * std::pow(time, 2.f) * 0.5f;
 
             return predicted;
@@ -24,6 +23,6 @@ namespace omath::projectile_prediction
 
         Vector3<float> m_origin;
         Vector3<float> m_velocity;
-        bool m_isAirborne{};
+        bool m_is_airborne{};
     };
-}
+} // namespace omath::projectile_prediction

include/omath/projection/Camera.hpp

@@ -1,158 +0,0 @@
-//
-// Created by Vlad on 27.08.2024.
-//
-
-#pragma once
-
-#include <expected>
-#include <omath/Mat.hpp>
-#include <omath/Vector3.hpp>
-#include "ErrorCodes.hpp"
-#include <omath/Angle.hpp>
-#include <type_traits>
-
-namespace omath::projection
-{
-    class ViewPort final
-    {
-    public:
-        float m_width;
-        float m_height;
-
-        [[nodiscard]] constexpr float AspectRatio() const
-        {
-            return m_width / m_height;
-        }
-    };
-    using FieldOfView = Angle<float, 0.f, 180.f, AngleFlags::Clamped>;
-
-    template<class Mat4x4Type, class ViewAnglesType>
-    class Camera
-    {
-    public:
-        virtual ~Camera() = default;
-        Camera(const Vector3<float>& position, const ViewAnglesType& viewAngles, const ViewPort& viewPort,
-               const FieldOfView& fov, const float near, const float far) :
-            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;
-
-        [[nodiscard]] virtual Mat4x4Type CalcViewMatrix() const = 0;
-
-        [[nodiscard]] virtual Mat4x4Type CalcProjectionMatrix() const = 0;
-
-        [[nodiscard]] Mat4x4Type CalcViewProjectionMatrix() const
-        {
-            return CalcProjectionMatrix() * CalcViewMatrix();
-        }
-    public:
-
-        [[nodiscard]] const Mat4x4Type& GetViewProjectionMatrix() const
-        {
-            if (!m_viewProjectionMatrix.has_value())
-                m_viewProjectionMatrix = CalcViewProjectionMatrix();
-
-            return m_viewProjectionMatrix.value();
-        }
-
-        void SetFieldOfView(const FieldOfView& fov)
-        {
-            m_fieldOfView = fov;
-        }
-
-        void SetNearPlane(const float near)
-        {
-            m_nearPlaneDistance = near;
-        }
-
-        void SetFarPlane(const float far)
-        {
-            m_farPlaneDistance = far;
-        }
-
-        void SetViewAngles(const ViewAnglesType& viewAngles)
-        {
-            m_viewAngles = viewAngles;
-        }
-
-        void SetOrigin(const Vector3<float>& origin)
-        {
-            m_origin = origin;
-        }
-
-        void SetViewPort(const ViewPort& viewPort)
-        {
-            m_viewPort = viewPort;
-        }
-
-        [[nodiscard]] const FieldOfView& GetFieldOfView() const
-        {
-            return m_fieldOfView;
-        }
-
-        [[nodiscard]] const float& GetNearPlane() const
-        {
-            return m_nearPlaneDistance;
-        }
-
-        [[nodiscard]] const float& GetFarPlane() const
-        {
-            return m_farPlaneDistance;
-        }
-
-        [[nodiscard]] const ViewAnglesType& GetViewAngles() const
-        {
-            return m_viewAngles;
-        }
-
-        [[nodiscard]] const Vector3<float>& GetOrigin() const
-        {
-            return m_origin;
-        }
-
-        [[nodiscard]] std::expected<Vector3<float>, Error> WorldToScreen(const Vector3<float>& worldPosition) const
-        {
-            const auto& viewProjMatrix = GetViewProjectionMatrix();
-
-            auto projected = viewProjMatrix * MatColumnFromVector<float, Mat4x4Type::GetStoreOrdering()>(worldPosition);
-
-            if (projected.At(3, 0) == 0.0f)
-                return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
-
-            projected /= projected.At(3, 0);
-
-            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)};
-        }
-
-    protected:
-        ViewPort m_viewPort{};
-        Angle<float, 0.f, 180.f, AngleFlags::Clamped> m_fieldOfView;
-
-        mutable std::optional<Mat4x4Type> m_viewProjectionMatrix;
-
-        float m_farPlaneDistance;
-        float m_nearPlaneDistance;
-
-
-        ViewAnglesType m_viewAngles;
-        Vector3<float> m_origin;
-
-    private:
-        template<class Type>
-        [[nodiscard]]
-        constexpr static bool IsNdcOutOfBounds(const Type& ndc)
-        {
-            return std::ranges::any_of( ndc.RawArray(), [](const auto& val) { return val < -1 || val > 1; });
-        }
-    };
-} // namespace omath::projection

include/omath/projection/camera.hpp

@@ -0,0 +1,174 @@
+//
+// Created by Vlad on 27.08.2024.
+//
+
+#pragma once
+
+#include "omath/projection/error_codes.hpp"
+#include <expected>
+#include <omath/angle.hpp>
+#include <omath/mat.hpp>
+#include <omath/vector3.hpp>
+#include <type_traits>
+
+namespace omath::projection
+{
+    class ViewPort final
+    {
+    public:
+        float m_width;
+        float m_height;
+
+        [[nodiscard]] constexpr float aspect_ratio() const
+        {
+            return m_width / m_height;
+        }
+    };
+    using FieldOfView = Angle<float, 0.f, 180.f, AngleFlags::Clamped>;
+
+    template<class Mat4X4Type, class ViewAnglesType>
+    class Camera
+    {
+    public:
+        virtual ~Camera() = default;
+        Camera(const Vector3<float>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
+               const FieldOfView& fov, const float near, const float far)
+            : m_view_port(view_port), m_field_of_view(fov), m_far_plane_distance(far), m_near_plane_distance(near),
+              m_view_angles(view_angles), m_origin(position)
+        {
+        }
+
+    protected:
+        virtual void look_at(const Vector3<float>& target) = 0;
+
+        [[nodiscard]] virtual Mat4X4Type calc_view_matrix() const = 0;
+
+        [[nodiscard]] virtual Mat4X4Type calc_projection_matrix() const = 0;
+
+        [[nodiscard]] Mat4X4Type calc_view_projection_matrix() const
+        {
+            return calc_projection_matrix() * calc_view_matrix();
+        }
+
+    public:
+        [[nodiscard]] const Mat4X4Type& get_view_projection_matrix() const
+        {
+            if (!m_view_projection_matrix.has_value())
+                m_view_projection_matrix = calc_view_projection_matrix();
+
+            return m_view_projection_matrix.value();
+        }
+
+        void set_field_of_view(const FieldOfView& fov)
+        {
+            m_field_of_view = fov;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        void set_near_plane(const float near)
+        {
+            m_near_plane_distance = near;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        void set_far_plane(const float far)
+        {
+            m_far_plane_distance = far;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        void set_view_angles(const ViewAnglesType& view_angles)
+        {
+            m_view_angles = view_angles;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        void set_origin(const Vector3<float>& origin)
+        {
+            m_origin = origin;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        void set_view_port(const ViewPort& view_port)
+        {
+            m_view_port = view_port;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        [[nodiscard]] const FieldOfView& get_field_of_view() const
+        {
+            return m_field_of_view;
+        }
+
+        [[nodiscard]] const float& get_near_plane() const
+        {
+            return m_near_plane_distance;
+        }
+
+        [[nodiscard]] const float& get_far_plane() const
+        {
+            return m_far_plane_distance;
+        }
+
+        [[nodiscard]] const ViewAnglesType& get_view_angles() const
+        {
+            return m_view_angles;
+        }
+
+        [[nodiscard]] const Vector3<float>& get_origin() const
+        {
+            return m_origin;
+        }
+
+        [[nodiscard]] std::expected<Vector3<float>, Error> world_to_screen(const Vector3<float>& world_position) const
+        {
+            auto normalized_cords = world_to_view_port(world_position);
+
+            if (!normalized_cords.has_value())
+                return std::unexpected{normalized_cords.error()};
+
+            return ndc_to_screen_position(*normalized_cords);
+        }
+
+        [[nodiscard]] std::expected<Vector3<float>, Error>
+        world_to_view_port(const Vector3<float>& world_position) const
+        {
+            auto projected = get_view_projection_matrix()
+                             * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(world_position);
+
+            if (projected.at(3, 0) == 0.0f)
+                return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
+
+            projected /= projected.at(3, 0);
+
+            if (is_ndc_out_of_bounds(projected))
+                return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
+
+            return Vector3<float>{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)};
+        }
+
+    protected:
+        ViewPort m_view_port{};
+        Angle<float, 0.f, 180.f, AngleFlags::Clamped> m_field_of_view;
+
+        mutable std::optional<Mat4X4Type> m_view_projection_matrix;
+
+        float m_far_plane_distance;
+        float m_near_plane_distance;
+
+        ViewAnglesType m_view_angles;
+        Vector3<float> m_origin;
+
+    private:
+        template<class Type> [[nodiscard]]
+        constexpr static bool is_ndc_out_of_bounds(const Type& ndc)
+        {
+            return std::ranges::any_of(ndc.raw_array(), [](const auto& val) { return val < -1 || val > 1; });
+        }
+
+        [[nodiscard]] Vector3<float> ndc_to_screen_position(const Vector3<float>& ndc) const
+        {
+            return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (1.f - ndc.y) / 2.f * m_view_port.m_height, ndc.z};
+        }
+    };
+} // namespace omath::projection

include/omath/projection/error_codes.hpp

@@ -5,7 +5,6 @@
 #pragma once
 #include <cstdint>
 
-
 namespace omath::projection
 {
     enum class Error : uint16_t

include/omath/triangle.hpp

@@ -0,0 +1,84 @@
+//
+// Created by Orange on 11/13/2024.
+//
+#pragma once
+#include "omath/vector3.hpp"
+
+namespace omath
+{
+    /*
+    |\
+    | \
+  a |  \ hypot
+    |   \
+    -----
+      b
+    */
+
+    template<class Vector>
+    class Triangle final
+    {
+    public:
+        constexpr Triangle() = default;
+        constexpr Triangle(const Vector& vertex1, const Vector& vertex2, const Vector& vertex3)
+            : m_vertex1(vertex1), m_vertex2(vertex2), m_vertex3(vertex3)
+        {
+        }
+
+        Vector3<float> m_vertex1;
+        Vector3<float> m_vertex2;
+        Vector3<float> m_vertex3;
+
+        [[nodiscard]]
+        constexpr Vector3<float> calculate_normal() const
+        {
+            const auto b = side_b_vector();
+            const auto a = side_a_vector();
+
+            return b.cross(a).normalized();
+        }
+
+        [[nodiscard]]
+        float side_a_length() const
+        {
+            return m_vertex1.distance_to(m_vertex2);
+        }
+
+        [[nodiscard]]
+        float side_b_length() const
+        {
+            return m_vertex3.distance_to(m_vertex2);
+        }
+
+        [[nodiscard]]
+        constexpr Vector3<float> side_a_vector() const
+        {
+            return m_vertex1 - m_vertex2;
+        }
+
+        [[nodiscard]]
+        constexpr float hypot() const
+        {
+            return m_vertex1.distance_to(m_vertex3);
+        }
+        [[nodiscard]]
+        constexpr bool is_rectangular() const
+        {
+            const auto side_a = side_a_length();
+            const auto side_b = side_b_length();
+            const auto hypot_value = hypot();
+
+            return std::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f;
+        }
+        [[nodiscard]]
+        constexpr Vector3<float> side_b_vector() const
+        {
+            return m_vertex3 - m_vertex2;
+        }
+        [[nodiscard]]
+        constexpr Vector3<float> mid_point() const
+        {
+            return (m_vertex1 + m_vertex2 + m_vertex3) / 3;
+        }
+    };
+} // namespace omath

include/omath/vector2.hpp

@@ -10,12 +10,11 @@
 #include <imgui.h>
 #endif
 
-
 namespace omath
 {
 
     template<class Type>
-        requires std::is_arithmetic_v<Type>
+    requires std::is_arithmetic_v<Type>
     class Vector2
     {
     public:
@@ -25,7 +24,7 @@ namespace omath
         // Constructors
         constexpr Vector2() = default;
 
-        constexpr Vector2(const Type& x, const Type& y) : x(x), y(y)
+        constexpr Vector2(const Type& x, const Type& y): x(x), y(y)
         {
         }
 
@@ -108,50 +107,50 @@ namespace omath
         }
 
         // Basic vector operations
-        [[nodiscard]] Type DistTo(const Vector2& vOther) const
+        [[nodiscard]] Type distance_to(const Vector2& other) const
         {
-            return std::sqrt(DistToSqr(vOther));
+            return std::sqrt(distance_to_sqr(other));
         }
 
-        [[nodiscard]] constexpr Type DistToSqr(const Vector2& vOther) const
+        [[nodiscard]] constexpr Type distance_to_sqr(const Vector2& other) const
         {
-            return (x - vOther.x) * (x - vOther.x) + (y - vOther.y) * (y - vOther.y);
+            return (x - other.x) * (x - other.x) + (y - other.y) * (y - other.y);
         }
 
-        [[nodiscard]] constexpr Type Dot(const Vector2& vOther) const
+        [[nodiscard]] constexpr Type dot(const Vector2& other) const
         {
-            return x * vOther.x + y * vOther.y;
+            return x * other.x + y * other.y;
         }
 
 #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
+        [[nodiscard]] constexpr Vector2 normalized() const
         {
-            const Type len = Length();
+            const Type len = length();
             return len > 0.f ? *this / len : *this;
         }
 #else
-        [[nodiscard]] Type Length() const
+        [[nodiscard]] Type length() const
         {
             return std::hypot(x, y);
         }
 
-        [[nodiscard]] Vector2 Normalized() const
+        [[nodiscard]] Vector2 normalized() const
         {
-            const Type len = Length();
+            const Type len = length();
             return len > 0.f ? *this / len : *this;
         }
 #endif
-        [[nodiscard]] constexpr Type LengthSqr() const
+        [[nodiscard]] constexpr Type length_sqr() const
         {
             return x * x + y * y;
         }
 
-        constexpr Vector2& Abs()
+        constexpr Vector2& abs()
         {
             // FIXME: Replace with std::abs, if it will become constexprable
             x = x < 0 ? -x : x;
@@ -186,20 +185,20 @@ namespace omath
         }
 
         // Sum of elements
-        [[nodiscard]] constexpr Type Sum() const
+        [[nodiscard]] constexpr Type sum() const
         {
             return x + y;
         }
 
         [[nodiscard]]
-        constexpr std::tuple<Type, Type> AsTuple() const
+        constexpr std::tuple<Type, Type> as_tuple() const
         {
             return std::make_tuple(x, y);
         }
 
 #ifdef OMATH_IMGUI_INTEGRATION
         [[nodiscard]]
-        ImVec2 ToImVec2() const
+        ImVec2 to_im_vec2() const
         {
             return {static_cast<float>(this->x), static_cast<float>(this->y)};
         }

include/omath/vector3.hpp

@@ -4,12 +4,11 @@
 
 #pragma once
 
-#include "Vector2.hpp"
+#include "omath/angle.hpp"
+#include "omath/vector2.hpp"
 #include <cstdint>
 #include <expected>
 #include <functional>
-#include "omath/Angle.hpp"
-#include "omath/Vector2.hpp"
 
 namespace omath
 {
@@ -19,13 +18,16 @@ namespace omath
         IMPOSSIBLE_BETWEEN_ANGLE,
     };
 
-    template<class Type> requires std::is_arithmetic_v<Type>
+    template<class Type>
+    requires std::is_arithmetic_v<Type>
     class Vector3 : public Vector2<Type>
     {
     public:
         Type z = static_cast<Type>(0);
-        constexpr Vector3(const Type& x, const Type& y, const Type& z) : Vector2<Type>(x, y), z(z) { }
+        constexpr Vector3(const Type& x, const Type& y, const Type& z): Vector2<Type>(x, y), z(z)
-        constexpr Vector3() : Vector2<Type>() {};
+        {
+        }
+        constexpr Vector3(): Vector2<Type>() {};
 
         [[nodiscard]] constexpr bool operator==(const Vector3& src) const
         {
@@ -101,72 +103,71 @@ namespace omath
             return *this;
         }
 
-        constexpr Vector3& Abs()
+        constexpr Vector3& abs()
         {
-            Vector2<Type>::Abs();
+            Vector2<Type>::abs();
             z = z < 0.f ? -z : z;
 
             return *this;
         }
 
-        [[nodiscard]] constexpr Type DistToSqr(const Vector3& vOther) const
+        [[nodiscard]] constexpr Type distance_to_sqr(const Vector3& other) const
         {
-            return (*this - vOther).LengthSqr();
+            return (*this - other).length_sqr();
         }
 
-        [[nodiscard]] constexpr Type Dot(const Vector3& vOther) const
+        [[nodiscard]] constexpr Type dot(const Vector3& other) const
         {
-            return Vector2<Type>::Dot(vOther) + z * vOther.z;
+            return Vector2<Type>::dot(other) + z * other.z;
         }
 
 #ifndef _MSC_VER
-        [[nodiscard]] constexpr Type Length() const
+        [[nodiscard]] constexpr Type length() const
-        {
-            return std::hypot(x, y, z);
-        }
-
-        [[nodiscard]] constexpr Type Length2D() const
-        {
-            return Vector2::Length();
-        }
-        [[nodiscard]] Type DistTo(const Vector3& vOther) const
-        {
-            return (*this - vOther).Length();
-        }
-        [[nodiscard]] constexpr Vector3 Normalized() const
-        {
-            const Type length = this->Length();
-
-            return length != 0 ? *this / length : *this;
-        }
-#else
-        [[nodiscard]] Type Length() const
         {
             return std::hypot(this->x, this->y, z);
         }
 
-        [[nodiscard]] Vector3 Normalized() const
+        [[nodiscard]] constexpr Type length_2d() const
         {
-            const Type length = this->Length();
+            return Vector2<Type>::length();
+        }
+        [[nodiscard]] Type distance_to(const Vector3& other) const
+        {
+            return (*this - other).length();
+        }
+        [[nodiscard]] constexpr Vector3 normalized() const
+        {
+            const Type length_value = this->length();
 
-            return length != 0 ? *this / length : *this;
+            return length_value != 0 ? *this / length_value : *this;
+        }
+#else
+        [[nodiscard]] Type length() const
+        {
+            return std::hypot(this->x, this->y, z);
         }
 
-        [[nodiscard]] Type Length2D() const
+        [[nodiscard]] Vector3 normalized() const
         {
-            return Vector2<Type>::Length();
+            const Type len = this->length();
+
+            return len != 0 ? *this / len : *this;
         }
 
-        [[nodiscard]] Type DistTo(const Vector3& vOther) const
+        [[nodiscard]] Type length_2d() const
         {
-            return (*this - vOther).Length();
+            return Vector2<Type>::length();
+        }
+
+        [[nodiscard]] Type distance_to(const Vector3& vOther) const
+        {
+            return (*this - vOther).length();
         }
 #endif
 
-
+        [[nodiscard]] constexpr Type length_sqr() const
-        [[nodiscard]] constexpr Type LengthSqr() const
         {
-            return Vector2<Type>::LengthSqr() + z * z;
+            return Vector2<Type>::length_sqr() + z * z;
         }
 
         [[nodiscard]] constexpr Vector3 operator-() const
@@ -204,79 +205,69 @@ namespace omath
             return {this->x / v.x, this->y / v.y, z / v.z};
         }
 
-        [[nodiscard]] constexpr Vector3 Cross(const Vector3 &v) const
+        [[nodiscard]] constexpr Vector3 cross(const Vector3& v) const
         {
-            return
+            return {this->y * v.z - z * v.y, z * v.x - this->x * v.z, this->x * v.y - this->y * v.x};
-            {
-                this->y * v.z - z * v.y,
-                z * v.x - this->x * v.z,
-                this->x * v.y - this->y * v.x
-            };
         }
-        [[nodiscard]] constexpr Type Sum() const
+        [[nodiscard]] constexpr Type sum() const
         {
-            return Sum2D() + z;
+            return sum_2d() + z;
         }
 
         [[nodiscard]] std::expected<Angle<float, 0.f, 180.f, AngleFlags::Clamped>, Vector3Error>
-        AngleBetween(const Vector3& other) const
+        angle_between(const Vector3& other) const
         {
-            const auto bottom = Length() * other.Length();
+            const auto bottom = length() * other.length();
 
             if (bottom == 0.f)
                 return std::unexpected(Vector3Error::IMPOSSIBLE_BETWEEN_ANGLE);
 
-            return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::FromRadians(std::acos(Dot(other) / bottom));
+            return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::from_radians(std::acos(dot(other) / bottom));
         }
 
-        [[nodiscard]] bool IsPerpendicular(const Vector3& other) const
+        [[nodiscard]] bool is_perpendicular(const Vector3& other) const
         {
-            if (const auto angle = AngleBetween(other))
+            if (const auto angle = angle_between(other))
-                return angle->AsDegrees() == 90.f;
+                return angle->as_degrees() == 90.f;
 
             return false;
         }
 
-        [[nodiscard]] constexpr Type Sum2D() const
+        [[nodiscard]] constexpr Type sum_2d() const
         {
-            return Vector2<Type>::Sum();
+            return Vector2<Type>::sum();
         }
 
-        [[nodiscard]] constexpr std::tuple<Type, Type, Type> AsTuple() const
+        [[nodiscard]] constexpr std::tuple<Type, Type, Type> as_tuple() const
         {
             return std::make_tuple(this->x, this->y, z);
         }
 
-        [[nodiscard]] Vector3 ViewAngleTo(const Vector3 &other) const
+        [[nodiscard]] Vector3 view_angle_to(const Vector3& other) const
         {
-            const float distance = DistTo(other);
+            const float distance = distance_to(other);
             const auto delta = other - *this;
 
-            return
+            return {angles::radians_to_degrees(std::asin(delta.z / distance)),
-            {
+                    angles::radians_to_degrees(std::atan2(delta.y, delta.x)), 0};
-                angles::RadiansToDegrees(std::asin(delta.z / distance)),
-                angles::RadiansToDegrees(std::atan2(delta.y, delta.x)),
-                0
-            };
         }
     };
-}
+} // namespace omath
 // ReSharper disable once CppRedundantNamespaceDefinition
 namespace std
 {
-    template<>
+    template<> struct hash<omath::Vector3<float>>
-    struct hash<omath::Vector3<float>>
     {
         std::size_t operator()(const omath::Vector3<float>& vec) const noexcept
         {
             std::size_t hash = 0;
             constexpr std::hash<float> hasher;
 
-            hash ^= hasher(vec.x) + 0x9e3779b9 + (hash<<6) + (hash>>2);
+            hash ^= hasher(vec.x) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
-            hash ^= hasher(vec.y) + 0x9e3779b9 + (hash<<6) + (hash>>2);
+            hash ^= hasher(vec.y) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
-            hash ^= hasher(vec.z) + 0x9e3779b9 + (hash<<6) + (hash>>2);
+            hash ^= hasher(vec.z) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
 
             return hash;
         }
     };
-}
+} // namespace std

include/omath/vector4.hpp

@@ -3,20 +3,21 @@
 //
 #pragma once
 
-#include <omath/Vector3.hpp>
 #include <algorithm>
-
+#include <omath/vector3.hpp>
 
 namespace omath
 {
-    template <class Type>
+    template<class Type>
     class Vector4 : public Vector3<Type>
     {
     public:
         Type w;
 
-        constexpr Vector4(const Type& x, const Type& y, const Type& z, const Type& w) : Vector3<Type>(x, y, z), w(w) {}
+        constexpr Vector4(const Type& x, const Type& y, const Type& z, const Type& w): Vector3<Type>(x, y, z), w(w)
-        constexpr Vector4() : Vector3<Type>(), w(0) {};
+        {
+        }
+        constexpr Vector4(): Vector3<Type>(), w(0) {};
 
         [[nodiscard]]
         constexpr bool operator==(const Vector4& src) const
@@ -77,29 +78,29 @@ namespace omath
             return *this;
         }
 
-        [[nodiscard]] constexpr Type LengthSqr() const
+        [[nodiscard]] constexpr Type length_sqr() const
         {
-            return Vector3<Type>::LengthSqr() + w * w;
+            return Vector3<Type>::length_sqr() + w * w;
         }
 
-        [[nodiscard]] constexpr Type Dot(const Vector4& vOther) const
+        [[nodiscard]] constexpr Type dot(const Vector4& other) const
         {
-            return Vector3<Type>::Dot(vOther) + w * vOther.w;
+            return Vector3<Type>::dot(other) + w * other.w;
         }
 
-        [[nodiscard]] Vector3<Type> Length() const
+        [[nodiscard]] Vector3<Type> length() const
         {
-            return std::sqrt(LengthSqr());
+            return std::sqrt(length_sqr());
         }
 
-        constexpr Vector4& Abs()
+        constexpr Vector4& abs()
         {
-            Vector3<Type>::Abs();
+            Vector3<Type>::abs();
             w = w < 0.f ? -w : w;
 
             return *this;
         }
-        constexpr Vector4& Clamp(const Type& min, const Type& max)
+        constexpr Vector4& clamp(const Type& min, const Type& max)
         {
             this->x = std::clamp(this->x, min, max);
             this->y = std::clamp(this->y, min, max);
@@ -151,23 +152,22 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Type Sum() const
+        constexpr Type sum() const
         {
-            return Vector3<Type>::Sum() + w;
+            return Vector3<Type>::sum() + w;
         }
 
 #ifdef OMATH_IMGUI_INTEGRATION
         [[nodiscard]]
-        ImVec4 ToImVec4() const
+        ImVec4 to_im_vec4() const
         {
-            return
+            return {
-            {
+                    static_cast<float>(this->x),
-                static_cast<float>(this->x),
+                    static_cast<float>(this->y),
-                static_cast<float>(this->y),
+                    static_cast<float>(this->z),
-                static_cast<float>(this->z),
+                    static_cast<float>(w),
-                static_cast<float>(w),
             };
         }
 #endif
     };
-}
+} // namespace omath

include/omath/view_angles.hpp

@@ -12,4 +12,4 @@ namespace omath
         YawType yaw;
         RollType roll;
     };
-}
+} // namespace omath

source/3d_primitives/box.cpp

@@ -0,0 +1,54 @@
+//
+// Created by Vlad on 4/18/2025.
+//
+#include "omath/3d_primitives/box.hpp"
+
+namespace omath::primitives
+{
+    std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
+                                                        const Vector3<float>& dir_forward,
+                                                        const Vector3<float>& dir_right, const float ratio)
+    {
+        const auto height = top.distance_to(bottom);
+        const auto side_size = height / ratio;
+
+        // corner layout (0‑3 bottom, 4‑7 top)
+        std::array<Vector3<float>, 8> p;
+        p[0] = bottom + (dir_forward + dir_right) * side_size; // front‑right‑bottom
+        p[1] = bottom + (dir_forward - dir_right) * side_size; // front‑left‑bottom
+        p[2] = bottom + (-dir_forward + dir_right) * side_size; // back‑right‑bottom
+        p[3] = bottom + (-dir_forward - dir_right) * side_size; // back‑left‑bottom
+        p[4] = top + (dir_forward + dir_right) * side_size; // front‑right‑top
+        p[5] = top + (dir_forward - dir_right) * side_size; // front‑left‑top
+        p[6] = top + (-dir_forward + dir_right) * side_size; // back‑right‑top
+        p[7] = top + (-dir_forward - dir_right) * side_size; // 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;
+    }
+} // namespace omath::primitives

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)

source/collision/CMakeLists.txt

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

source/collision/LineTracer.cpp

@@ -1,62 +0,0 @@
-//
-// Created by Orange on 11/13/2024.
-//
-#include "omath/collision/LineTracer.hpp"
-
-namespace omath::collision
-{
-    bool LineTracer::CanTraceLine(const Ray& ray, const Triangle<Vector3<float>>& triangle)
-    {
-        return GetRayHitPoint(ray, triangle) == ray.end;
-    }
-    Vector3<float> Ray::DirectionVector() const
-    {
-        return end - start;
-    }
-
-    Vector3<float> Ray::DirectionVectorNormalized() const
-    {
-        return DirectionVector().Normalized();
-    }
-
-    Vector3<float> LineTracer::GetRayHitPoint(const Ray& ray, const Triangle<Vector3<float>>& triangle)
-    {
-        constexpr float kEpsilon = std::numeric_limits<float>::epsilon();
-
-        const auto sideA = triangle.SideAVector();
-        const auto sideB = triangle.SideBVector();
-
-
-        const auto rayDir = ray.DirectionVector();
-
-        const auto p = rayDir.Cross(sideB);
-        const auto det = sideA.Dot(p);
-
-
-        if (std::abs(det) < kEpsilon)
-            return ray.end;
-
-        const auto invDet = 1.0f / det;
-        const auto t = ray.start - triangle.m_vertex2;
-        const auto u = t.Dot(p) * invDet;
-
-
-        if ((u < 0 && std::abs(u) > kEpsilon) || (u > 1 && std::abs(u - 1) > kEpsilon))
-            return ray.end;
-
-        const auto q = t.Cross(sideA);
-        const auto v = rayDir.Dot(q) * invDet;
-
-
-        if ((v < 0 && std::abs(v) > kEpsilon) || (u + v > 1 && std::abs(u + v - 1) > kEpsilon))
-            return ray.end;
-
-        const auto tHit = sideB.Dot(q) * invDet;
-
-
-        if (tHit <= kEpsilon)
-            return ray.end;
-
-        return ray.start + rayDir * tHit;
-    }
-} // namespace omath::collision

source/collision/line_tracer.cpp

@@ -0,0 +1,63 @@
+//
+// Created by Orange on 11/13/2024.
+//
+#include "omath/collision/line_tracer.hpp"
+
+namespace omath::collision
+{
+    bool LineTracer::can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle)
+    {
+        return get_ray_hit_point(ray, triangle) == ray.end;
+    }
+    Vector3<float> Ray::direction_vector() const
+    {
+        return end - start;
+    }
+
+    Vector3<float> Ray::direction_vector_normalized() const
+    {
+        return direction_vector().normalized();
+    }
+
+    Vector3<float> LineTracer::get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle)
+    {
+        constexpr float k_epsilon = std::numeric_limits<float>::epsilon();
+
+        const auto side_a = triangle.side_a_vector();
+        const auto side_b = triangle.side_b_vector();
+
+        const auto ray_dir = ray.direction_vector();
+
+        const auto p = ray_dir.cross(side_b);
+        const auto det = side_a.dot(p);
+
+        if (std::abs(det) < k_epsilon)
+            return ray.end;
+
+        const auto inv_det = 1.0f / det;
+        const auto t = ray.start - triangle.m_vertex2;
+        const auto u = t.dot(p) * inv_det;
+
+        if ((u < 0 && std::abs(u) > k_epsilon) || (u > 1 && std::abs(u - 1) > k_epsilon))
+            return ray.end;
+
+        const auto q = t.cross(side_a);
+        // ReSharper disable once CppTooWideScopeInitStatement
+        const auto v = ray_dir.dot(q) * inv_det;
+
+        if ((v < 0 && std::abs(v) > k_epsilon) || (u + v > 1 && std::abs(u + v - 1) > k_epsilon))
+            return ray.end;
+
+        const auto t_hit = side_b.dot(q) * inv_det;
+
+        if (ray.infinite_length)
+        {
+            if (t_hit <= k_epsilon)
+                return ray.end;
+        }
+        else if (t_hit <= k_epsilon || t_hit > 1.0f - k_epsilon)
+            return ray.end;
+
+        return ray.start + ray_dir * t_hit;
+    }
+} // namespace omath::collision

source/color.cpp

@@ -2,11 +2,10 @@
 // Created by vlad on 2/4/24.
 //
 
-#include "omath/Color.hpp"
+#include "omath/color.hpp"
 #include <algorithm>
 #include <cmath>
 
-
 namespace omath
 {
 

source/engines/CMakeLists.txt

@@ -1,3 +0,0 @@
-add_subdirectory(source_engine)
-add_subdirectory(opengl_engine)
-add_subdirectory(iw_engine)

source/engines/iw_engine/CMakeLists.txt

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

source/engines/iw_engine/Camera.cpp

@@ -1,34 +0,0 @@
-//
-// Created by Vlad on 3/17/2025.
-//
-#include "omath/engines/iw_engine/Camera.hpp"
-#include "omath/engines/iw_engine/Formulas.hpp"
-
-namespace omath::iw_engine
-{
-
-    Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
-                   const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& 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)
-    {
-        const float distance = m_origin.DistTo(target);
-        const auto delta = target - m_origin;
-
-
-        m_viewAngles.pitch = PitchAngle::FromRadians(std::asin(delta.z / distance));
-        m_viewAngles.yaw = -YawAngle::FromRadians(std::atan2(delta.y, delta.x));
-        m_viewAngles.roll = RollAngle::FromRadians(0.f);
-    }
-    Mat4x4 Camera::CalcViewMatrix() const
-    {
-        return iw_engine::CalcViewMatrix(m_viewAngles, m_origin);
-    }
-    Mat4x4 Camera::CalcProjectionMatrix() const
-    {
-        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
-                                               m_farPlaneDistance);
-    }
-} // namespace omath::openg

source/engines/iw_engine/Formulas.cpp

@@ -1,47 +0,0 @@
-//
-// Created by Vlad on 3/19/2025.
-//
-#include "omath/engines/iw_engine/Formulas.hpp"
-
-
-namespace omath::iw_engine
-{
-
-    Vector3<float> ForwardVector(const ViewAngles& angles)
-    {
-        const auto vec = MatRotation(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);
-
-        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);
-
-        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(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
-        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, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
-                {0, 0, 1, 0},
-        };
-    }
-} // namespace omath::iw_engine

source/engines/iw_engine/camera.cpp

@@ -0,0 +1,33 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+#include "omath/engines/iw_engine/camera.hpp"
+#include "omath/engines/iw_engine/formulas.hpp"
+
+namespace omath::iw_engine
+{
+
+    Camera::Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
+                   const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far)
+        : projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
+    {
+    }
+    void Camera::look_at([[maybe_unused]] const Vector3<float>& target)
+    {
+        const float distance = m_origin.distance_to(target);
+        const auto delta = target - m_origin;
+
+        m_view_angles.pitch = PitchAngle::from_radians(std::asin(delta.z / distance));
+        m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
+        m_view_angles.roll = RollAngle::from_radians(0.f);
+    }
+    Mat4X4 Camera::calc_view_matrix() const
+    {
+        return iw_engine::calc_view_matrix(m_view_angles, m_origin);
+    }
+    Mat4X4 Camera::calc_projection_matrix() const
+    {
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
+                                                  m_near_plane_distance, m_far_plane_distance);
+    }
+} // namespace omath::iw_engine

source/engines/iw_engine/formulas.cpp

@@ -0,0 +1,53 @@
+//
+// Created by Vlad on 3/19/2025.
+//
+#include "omath/engines/iw_engine/formulas.hpp"
+
+namespace omath::iw_engine
+{
+
+    Vector3<float> forward_vector(const ViewAngles& angles)
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+
+    Vector3<float> right_vector(const ViewAngles& angles)
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> up_vector(const ViewAngles& angles)
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Mat4X4 rotation_matrix(const ViewAngles& angles)
+    {
+        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
+    }
+
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    {
+        return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
+    }
+
+    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
+                                              const float far)
+    {
+        // NOTE: Need magic number to fix fov calculation, since IW engine inherit Quake proj matrix calculation
+        constexpr auto k_multiply_factor = 0.75f;
+
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
+
+        return {
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
+                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                {0, 0, 1, 0},
+        };
+    };
+} // namespace omath::iw_engine

source/engines/opengl_engine/CMakeLists.txt

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

source/engines/opengl_engine/Camera.cpp

@@ -1,35 +0,0 @@
-//
-// Created by Orange on 12/23/2024.
-//
-#include "omath/engines/opengl_engine/Camera.hpp"
-#include "omath/engines/opengl_engine/Formulas.hpp"
-
-
-namespace omath::opengl_engine
-{
-
-    Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
-                   const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& 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)
-    {
-        const float distance = m_origin.DistTo(target);
-        const auto delta = target - m_origin;
-
-
-        m_viewAngles.pitch = PitchAngle::FromRadians(std::asin(delta.z / distance));
-        m_viewAngles.yaw = -YawAngle::FromRadians(std::atan2(delta.y, delta.x));
-        m_viewAngles.roll = RollAngle::FromRadians(0.f);
-    }
-    Mat4x4 Camera::CalcViewMatrix() const
-    {
-        return opengl_engine::CalcViewMatrix(m_viewAngles, m_origin);
-    }
-    Mat4x4 Camera::CalcProjectionMatrix() const
-    {
-        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
-                                               m_farPlaneDistance);
-    }
-} // namespace omath::opengl

source/engines/opengl_engine/Formulas.cpp

@@ -1,46 +0,0 @@
-//
-// Created by Vlad on 3/19/2025.
-//
-#include "omath/engines/opengl_engine/Formulas.hpp"
-
-
-namespace omath::opengl_engine
-{
-
-    Vector3<float> ForwardVector(const ViewAngles& angles)
-    {
-        const auto vec = MatRotation(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);
-
-        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);
-
-        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::COLUMN_MAJOR>(-ForwardVector(angles), RightVector(angles),
-                                                                UpVector(angles), cam_origin);
-    }
-    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, 0},
-
-        };
-    }
-} // namespace omath::opengl_engine

source/engines/opengl_engine/camera.cpp

@@ -0,0 +1,33 @@
+//
+// Created by Orange on 12/23/2024.
+//
+#include "omath/engines/opengl_engine/camera.hpp"
+#include "omath/engines/opengl_engine/formulas.hpp"
+
+namespace omath::opengl_engine
+{
+
+    Camera::Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
+                   const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far)
+        : projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
+    {
+    }
+    void Camera::look_at([[maybe_unused]] const Vector3<float>& target)
+    {
+        const float distance = m_origin.distance_to(target);
+        const auto delta = target - m_origin;
+
+        m_view_angles.pitch = PitchAngle::from_radians(std::asin(delta.z / distance));
+        m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
+        m_view_angles.roll = RollAngle::from_radians(0.f);
+    }
+    Mat4X4 Camera::calc_view_matrix() const
+    {
+        return opengl_engine::calc_view_matrix(m_view_angles, m_origin);
+    }
+    Mat4X4 Camera::calc_projection_matrix() const
+    {
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
+                                                  m_near_plane_distance, m_far_plane_distance);
+    }
+} // namespace omath::opengl_engine

source/engines/opengl_engine/formulas.cpp

@@ -0,0 +1,52 @@
+//
+// Created by Vlad on 3/19/2025.
+//
+#include "omath/engines/opengl_engine/formulas.hpp"
+
+namespace omath::opengl_engine
+{
+
+    Vector3<float> forward_vector(const ViewAngles& angles)
+    {
+        const auto vec
+                = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_forward);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> right_vector(const ViewAngles& angles)
+    {
+        const auto vec
+                = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_right);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> up_vector(const ViewAngles& angles)
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_up);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    {
+        return mat_camera_view<float, MatStoreType::COLUMN_MAJOR>(-forward_vector(angles), right_vector(angles),
+                                                                  up_vector(angles), cam_origin);
+    }
+    Mat4X4 rotation_matrix(const ViewAngles& angles)
+    {
+        return mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch)
+               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw)
+               * mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
+    }
+    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
+                                              const float far)
+    {
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+
+        return {
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
+                {0, 0, -(far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                {0, 0, -1, 0},
+        };
+    }
+} // namespace omath::opengl_engine

source/engines/source_engine/CMakeLists.txt

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

source/engines/source_engine/Camera.cpp

@@ -1,37 +0,0 @@
-//
-// Created by Orange on 12/4/2024.
-//
-#include "omath/engines/source_engine/Camera.hpp"
-#include "omath/engines/source_engine/Formulas.hpp"
-
-
-namespace omath::source_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(const Vector3<float>& target)
-    {
-        const float distance = m_origin.DistTo(target);
-        const auto delta = target - m_origin;
-
-
-        m_viewAngles.pitch = PitchAngle::FromRadians(std::asin(delta.z / distance));
-        m_viewAngles.yaw = -YawAngle::FromRadians(std::atan2(delta.y, delta.x));
-        m_viewAngles.roll = RollAngle::FromRadians(0.f);
-    }
-
-    Mat4x4 Camera::CalcViewMatrix() const
-    {
-        return source_engine::CalcViewMatrix(m_viewAngles, m_origin);
-    }
-
-    Mat4x4 Camera::CalcProjectionMatrix() const
-    {
-        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
-                                               m_farPlaneDistance);
-    }
-} // namespace omath::source

source/engines/source_engine/Formulas.cpp

@@ -1,49 +0,0 @@
-//
-// Created by Vlad on 3/19/2025.
-//
-#include <omath/engines/source_engine/Formulas.hpp>
-
-
-namespace omath::source_engine
-{
-    Vector3<float> ForwardVector(const ViewAngles& angles)
-    {
-        const auto vec = MatRotation(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);
-
-        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);
-
-        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(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
-        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, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
-                {0, 0, 1, 0},
-
-        };
-    }
-} // namespace omath::source_engine

source/engines/source_engine/camera.cpp

@@ -0,0 +1,35 @@
+//
+// Created by Orange on 12/4/2024.
+//
+#include "omath/engines/source_engine/camera.hpp"
+#include "omath/engines/source_engine/formulas.hpp"
+
+namespace omath::source_engine
+{
+
+    Camera::Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
+                   const projection::FieldOfView& fov, const float near, const float far)
+        : projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
+    {
+    }
+    void Camera::look_at(const Vector3<float>& target)
+    {
+        const float distance = m_origin.distance_to(target);
+        const auto delta = target - m_origin;
+
+        m_view_angles.pitch = PitchAngle::from_radians(std::asin(delta.z / distance));
+        m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
+        m_view_angles.roll = RollAngle::from_radians(0.f);
+    }
+
+    Mat4X4 Camera::calc_view_matrix() const
+    {
+        return source_engine::calc_view_matrix(m_view_angles, m_origin);
+    }
+
+    Mat4X4 Camera::calc_projection_matrix() const
+    {
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
+                                                  m_near_plane_distance, m_far_plane_distance);
+    }
+} // namespace omath::source_engine

source/engines/source_engine/formulas.cpp

@@ -0,0 +1,53 @@
+//
+// Created by Vlad on 3/19/2025.
+//
+#include <omath/engines/source_engine/formulas.hpp>
+
+namespace omath::source_engine
+{
+    Vector3<float> forward_vector(const ViewAngles& angles)
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+
+    Mat4X4 rotation_matrix(const ViewAngles& angles)
+    {
+        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
+    }
+
+    Vector3<float> right_vector(const ViewAngles& angles)
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> up_vector(const ViewAngles& angles)
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    {
+        return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
+    }
+
+    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
+                                              const float far)
+    {
+        // NOTE: Need magic number to fix fov calculation, since source inherit Quake proj matrix calculation
+        constexpr auto k_multiply_factor = 0.75f;
+
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
+
+        return {
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
+                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                {0, 0, 1, 0},
+        };
+    }
+} // namespace omath::source_engine

source/engines/unity_engine/camera.cpp

@@ -0,0 +1,27 @@
+//
+// 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& view_angles, const projection::ViewPort& view_port,
+                   const projection::FieldOfView& fov, const float near, const float far)
+        : projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
+    {
+    }
+    void Camera::look_at([[maybe_unused]] const Vector3<float>& target)
+    {
+        throw std::runtime_error("Not implemented");
+    }
+    Mat4X4 Camera::calc_view_matrix() const
+    {
+        return unity_engine::calc_view_matrix(m_view_angles, m_origin);
+    }
+    Mat4X4 Camera::calc_projection_matrix() const
+    {
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
+                                                  m_near_plane_distance, m_far_plane_distance);
+    }
+} // namespace omath::unity_engine

source/engines/unity_engine/formulas.cpp

@@ -0,0 +1,49 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+#include "omath/engines/unity_engine/formulas.hpp"
+
+namespace omath::unity_engine
+{
+    Vector3<float> forward_vector(const ViewAngles& angles)
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> right_vector(const ViewAngles& angles)
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> up_vector(const ViewAngles& angles)
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    {
+        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), -right_vector(angles),
+                                                               up_vector(angles), cam_origin);
+    }
+    Mat4X4 rotation_matrix(const ViewAngles& angles)
+    {
+        return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll);
+    }
+    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
+                                              const float far)
+    {
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+
+        return {
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
+                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                {0, 0, -1.f, 0},
+        };
+    }
+} // namespace omath::unity_engine

source/matrix.cpp

@@ -1,14 +1,11 @@
-#include "omath/Matrix.hpp"
+#include "omath/matrix.hpp"
-#include "omath/Angles.hpp"
+#include "omath/angles.hpp"
-#include "omath/Vector3.hpp"
+#include "omath/vector3.hpp"
-
-
 #include <complex>
 #include <format>
 #include <stdexcept>
 #include <utility>
 
-
 namespace omath
 {
     Matrix::Matrix(const size_t rows, const size_t columns)
@@ -21,7 +18,7 @@ namespace omath
 
         m_data = std::make_unique<float[]>(m_rows * m_columns);
 
-        Set(0.f);
+        set(0.f);
     }
 
     Matrix::Matrix(const std::initializer_list<std::initializer_list<float>>& rows)
@@ -29,7 +26,6 @@ namespace omath
         m_rows = rows.size();
         m_columns = rows.begin()->size();
 
-
         for (const auto& row: rows)
             if (row.size() != m_columns)
                 throw std::invalid_argument("All rows must have the same number of columns.");
@@ -41,7 +37,7 @@ namespace omath
         {
             size_t j = 0;
             for (const auto& value: row)
-                At(i, j++) = value;
+                at(i, j++) = value;
             ++i;
         }
     }
@@ -55,29 +51,28 @@ namespace omath
 
         for (size_t i = 0; i < m_rows; ++i)
             for (size_t j = 0; j < m_columns; ++j)
-                At(i, j) = other.At(i, j);
+                at(i, j) = other.at(i, j);
     }
 
-    Matrix::Matrix(const size_t rows, const size_t columns, const float* pRaw)
+    Matrix::Matrix(const size_t rows, const size_t columns, const float* raw_data)
     {
         m_rows = rows;
         m_columns = columns;
 
-
         m_data = std::make_unique<float[]>(m_rows * m_columns);
 
         for (size_t i = 0; i < rows * columns; ++i)
-            At(i / rows, i % columns) = pRaw[i];
+            at(i / rows, i % columns) = raw_data[i];
     }
 
-    size_t Matrix::RowCount() const noexcept
+    size_t Matrix::row_count() const noexcept
     {
         return m_rows;
     }
-    
+
     float& Matrix::operator[](const size_t row, const size_t column)
     {
-        return At(row, column);
+        return at(row, column);
     }
 
     Matrix::Matrix(Matrix&& other) noexcept
@@ -92,35 +87,35 @@ namespace omath
         other.m_data = nullptr;
     }
 
-    size_t Matrix::ColumnsCount() const noexcept
+    size_t Matrix::columns_count() const noexcept
     {
         return m_columns;
     }
 
-    std::pair<size_t, size_t> Matrix::Size() const noexcept
+    std::pair<size_t, size_t> Matrix::size() const noexcept
     {
-        return {RowCount(), ColumnsCount()};
+        return {row_count(), columns_count()};
     }
 
-    float& Matrix::At(const size_t iRow, const size_t iCol)
+    float& Matrix::at(const size_t row, const size_t col)
     {
-        return const_cast<float&>(std::as_const(*this).At(iRow, iCol));
+        return const_cast<float&>(std::as_const(*this).at(row, col));
     }
 
-    float Matrix::Sum()
+    float Matrix::sum()
     {
         float sum = 0;
 
-        for (size_t i = 0; i < RowCount(); i++)
+        for (size_t i = 0; i < row_count(); i++)
-            for (size_t j = 0; j < ColumnsCount(); j++)
+            for (size_t j = 0; j < columns_count(); j++)
-                sum += At(i, j);
+                sum += at(i, j);
 
         return sum;
     }
 
-    const float& Matrix::At(const size_t iRow, const size_t iCol) const
+    const float& Matrix::at(const size_t row, const size_t col) const
     {
-        return m_data[iRow * m_columns + iCol];
+        return m_data[row * m_columns + col];
     }
 
     Matrix Matrix::operator*(const Matrix& other) const
@@ -128,15 +123,14 @@ namespace omath
         if (m_columns != other.m_rows)
             throw std::runtime_error("n != m");
 
-        auto outMat = Matrix(m_rows, other.m_columns);
+        auto out_mat = Matrix(m_rows, other.m_columns);
 
         for (size_t d = 0; d < m_rows; ++d)
             for (size_t i = 0; i < other.m_columns; ++i)
                 for (size_t j = 0; j < other.m_rows; ++j)
-                    outMat.At(d, i) += At(d, j) * other.At(j, i);
+                    out_mat.at(d, i) += at(d, j) * other.at(j, i);
 
-
+        return out_mat;
-        return outMat;
     }
 
     Matrix& Matrix::operator*=(const Matrix& other)
@@ -150,22 +144,22 @@ namespace omath
         auto out = *this;
         for (size_t i = 0; i < m_rows; ++i)
             for (size_t j = 0; j < m_columns; ++j)
-                out.At(i, j) *= f;
+                out.at(i, j) *= f;
 
         return out;
     }
 
     Matrix& Matrix::operator*=(const float f)
     {
-        for (size_t i = 0; i < RowCount(); i++)
+        for (size_t i = 0; i < row_count(); i++)
-            for (size_t j = 0; j < ColumnsCount(); j++)
+            for (size_t j = 0; j < columns_count(); j++)
-                At(i, j) *= f;
+                at(i, j) *= f;
         return *this;
     }
 
-    void Matrix::Clear()
+    void Matrix::clear()
     {
-        Set(0.f);
+        set(0.f);
     }
 
     Matrix& Matrix::operator=(const Matrix& other)
@@ -175,7 +169,7 @@ namespace omath
 
         for (size_t i = 0; i < m_rows; ++i)
             for (size_t j = 0; j < m_columns; ++j)
-                At(i, j) = other.At(i, j);
+                at(i, j) = other.at(i, j);
 
         return *this;
     }
@@ -199,7 +193,7 @@ namespace omath
     {
         for (size_t i = 0; i < m_rows; ++i)
             for (size_t j = 0; j < m_columns; ++j)
-                At(i, j) /= f;
+                at(i, j) /= f;
 
         return *this;
     }
@@ -209,12 +203,12 @@ namespace omath
         auto out = *this;
         for (size_t i = 0; i < m_rows; ++i)
             for (size_t j = 0; j < m_columns; ++j)
-                out.At(i, j) /= f;
+                out.at(i, j) /= f;
 
         return out;
     }
 
-    std::string Matrix::ToString() const
+    std::string Matrix::to_string() const
     {
         std::string str;
 
@@ -222,7 +216,7 @@ namespace omath
         {
             for (size_t j = 0; j < m_columns; ++j)
             {
-                str += std::format("{:.1f}", At(i, j));
+                str += std::format("{:.1f}", at(i, j));
 
                 if (j == m_columns - 1)
                     str += '\n';
@@ -233,89 +227,89 @@ namespace omath
         return str;
     }
 
-    float Matrix::Determinant() const
+    float Matrix::determinant() const // NOLINT(*-no-recursion)
     {
         if (m_rows + m_columns == 2)
-            return At(0, 0);
+            return at(0, 0);
 
         if (m_rows == 2 and m_columns == 2)
-            return At(0, 0) * At(1, 1) - At(0, 1) * At(1, 0);
+            return at(0, 0) * at(1, 1) - at(0, 1) * at(1, 0);
 
-        float fDet = 0;
+        float det = 0;
         for (size_t i = 0; i < m_columns; i++)
-            fDet += AlgComplement(0, i) * At(0, i);
+            det += alg_complement(0, i) * at(0, i);
 
-        return fDet;
+        return det;
     }
 
-    float Matrix::AlgComplement(const size_t i, const size_t j) const
+    float Matrix::alg_complement(const size_t i, const size_t j) const // NOLINT(*-no-recursion)
     {
-        const auto tmp = Minor(i, j);
+        const auto tmp = minor(i, j);
         return ((i + j + 2) % 2 == 0) ? tmp : -tmp;
     }
 
-    Matrix Matrix::Transpose() const
+    Matrix Matrix::transpose() const
     {
         Matrix transposed = {m_columns, m_rows};
 
         for (size_t i = 0; i < m_rows; ++i)
             for (size_t j = 0; j < m_columns; ++j)
-                transposed.At(j, i) = At(i, j);
+                transposed.at(j, i) = at(i, j);
 
         return transposed;
     }
 
     Matrix::~Matrix() = default;
 
-    void Matrix::Set(const float val)
+    void Matrix::set(const float val)
     {
         for (size_t i = 0; i < m_rows; ++i)
             for (size_t j = 0; j < m_columns; ++j)
-                At(i, j) = val;
+                at(i, j) = val;
     }
 
-    Matrix Matrix::Strip(const size_t row, const size_t column) const
+    Matrix Matrix::strip(const size_t row, const size_t column) const
     {
         Matrix stripped = {m_rows - 1, m_columns - 1};
-        size_t iStripRowIndex = 0;
+        size_t strip_row_index = 0;
 
         for (size_t i = 0; i < m_rows; i++)
         {
             if (i == row)
                 continue;
 
-            size_t iStripColumnIndex = 0;
+            size_t strip_column_index = 0;
             for (size_t j = 0; j < m_columns; ++j)
             {
                 if (j == column)
                     continue;
 
-                stripped.At(iStripRowIndex, iStripColumnIndex) = At(i, j);
+                stripped.at(strip_row_index, strip_column_index) = at(i, j);
-                iStripColumnIndex++;
+                strip_column_index++;
             }
 
-            iStripRowIndex++;
+            strip_row_index++;
         }
 
         return stripped;
     }
 
-    float Matrix::Minor(const size_t i, const size_t j) const
+    float Matrix::minor(const size_t i, const size_t j) const // NOLINT(*-no-recursion)
     {
-        return Strip(i, j).Determinant();
+        return strip(i, j).determinant();
     }
 
-    Matrix Matrix::ToScreenMatrix(const float screenWidth, const float screenHeight)
+    Matrix Matrix::to_screen_matrix(const float screen_width, const float screen_height)
     {
         return {
-                {screenWidth / 2.f, 0.f, 0.f, 0.f},
+                {screen_width / 2.f, 0.f, 0.f, 0.f},
-                {0.f, -screenHeight / 2.f, 0.f, 0.f},
+                {0.f, -screen_height / 2.f, 0.f, 0.f},
                 {0.f, 0.f, 1.f, 0.f},
-                {screenWidth / 2.f, screenHeight / 2.f, 0.f, 1.f},
+                {screen_width / 2.f, screen_height / 2.f, 0.f, 1.f},
         };
     }
 
-    Matrix Matrix::TranslationMatrix(const Vector3<float>& diff)
+    Matrix Matrix::translation_matrix(const Vector3<float>& diff)
     {
         return {
                 {1.f, 0.f, 0.f, 0.f},
@@ -325,7 +319,8 @@ namespace omath
         };
     }
 
-    Matrix Matrix::OrientationMatrix(const Vector3<float>& forward, const Vector3<float>& right, const Vector3<float>& up)
+    Matrix Matrix::orientation_matrix(const Vector3<float>& forward, const Vector3<float>& right,
+                                      const Vector3<float>& up)
     {
         return {
                 {right.x, up.x, forward.x, 0.f},
@@ -335,25 +330,26 @@ namespace omath
         };
     }
 
-    Matrix Matrix::ProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near, const float far)
+    Matrix Matrix::projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
+                                     const float far)
     {
-        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
 
-        return {{1.f / (aspectRatio * fovHalfTan), 0.f, 0.f, 0.f},
+        return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
-                {0.f, 1.f / fovHalfTan, 0.f, 0.f},
+                {0.f, 1.f / fov_half_tan, 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}};
     }
 
-    const float* Matrix::Raw() const
+    const float* Matrix::raw() const
     {
         return m_data.get();
     }
 
-    void Matrix::SetDataFromRaw(const float* pRawMatrix)
+    void Matrix::set_data_from_raw(const float* raw_matrix)
     {
         for (size_t i = 0; i < m_columns * m_rows; ++i)
-            At(i / m_rows, i % m_columns) = pRawMatrix[i];
+            at(i / m_rows, i % m_columns) = raw_matrix[i];
     }
 
     Matrix::Matrix()

source/pathfinding/Astar.cpp

@@ -1,100 +0,0 @@
-//
-// Created by Vlad on 28.07.2024.
-//
-#include "omath/pathfinding/Astar.hpp"
-
-#include <algorithm>
-#include <optional>
-#include <unordered_map>
-#include <unordered_set>
-
-
-namespace omath::pathfinding
-{
-    struct PathNode final
-    {
-        std::optional<Vector3<float>> cameFrom;
-        float gCost = 0.f;
-    };
-
-
-    std::vector<Vector3<float>> Astar::ReconstructFinalPath(const std::unordered_map<Vector3<float>, PathNode>& closedList,
-                                                     const Vector3<float>& current)
-    {
-        std::vector<Vector3<float>> path;
-        std::optional currentOpt = current;
-
-        while (currentOpt)
-        {
-            path.push_back(*currentOpt);
-
-            auto it = closedList.find(*currentOpt);
-
-            if (it == closedList.end())
-                break;
-
-            currentOpt = it->second.cameFrom;
-        }
-
-        std::ranges::reverse(path);
-        return path;
-    }
-    auto Astar::GetPerfectNode(const std::unordered_map<Vector3<float>, PathNode>& openList, const Vector3<float>& endVertex)
-    {
-        return std::ranges::min_element(openList,
-                                        [&endVertex](const auto& a, const auto& b)
-                                        {
-                                            const float fA = a.second.gCost + a.first.DistTo(endVertex);
-                                            const float fB = b.second.gCost + b.first.DistTo(endVertex);
-                                            return fA < fB;
-                                        });
-    }
-
-    std::vector<Vector3<float>> Astar::FindPath(const Vector3<float>& start, const Vector3<float>& end, const NavigationMesh& navMesh)
-    {
-        std::unordered_map<Vector3<float>, PathNode> closedList;
-        std::unordered_map<Vector3<float>, PathNode> openList;
-
-        auto maybeStartVertex = navMesh.GetClosestVertex(start);
-        auto maybeEndVertex = navMesh.GetClosestVertex(end);
-
-        if (!maybeStartVertex || !maybeEndVertex)
-            return {};
-
-        const auto startVertex = maybeStartVertex.value();
-        const auto endVertex = maybeEndVertex.value();
-
-
-        openList.emplace(startVertex, PathNode{std::nullopt, 0.f});
-
-        while (!openList.empty())
-        {
-            auto currentIt = GetPerfectNode(openList, endVertex);
-
-            const auto current = currentIt->first;
-            const auto currentNode = currentIt->second;
-
-            if (current == endVertex)
-                return ReconstructFinalPath(closedList, current);
-
-
-            closedList.emplace(current, currentNode);
-            openList.erase(currentIt);
-
-            for (const auto& neighbor: navMesh.GetNeighbors(current))
-            {
-                if (closedList.contains(neighbor))
-                    continue;
-
-                const float tentativeGCost = currentNode.gCost + neighbor.DistTo(current);
-
-                const auto openIt = openList.find(neighbor);
-
-                if (openIt == openList.end() || tentativeGCost < openIt->second.gCost)
-                    openList[neighbor] = PathNode{current, tentativeGCost};
-            }
-        }
-
-        return {};
-    }
-} // namespace omath::pathfinding

source/pathfinding/CMakeLists.txt

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

source/pathfinding/NavigationMesh.cpp

@@ -1,95 +0,0 @@
-//
-// Created by Vlad on 28.07.2024.
-//
-#include "omath/pathfinding/NavigationMesh.hpp"
-
-#include <stdexcept>
-#include <algorithm>
-namespace omath::pathfinding
-{
-    std::expected<Vector3<float>, std::string> NavigationMesh::GetClosestVertex(const Vector3<float> &point) const
-    {
-        const auto res = std::ranges::min_element(m_verTextMap,
-            [&point](const auto& a, const auto& b)
-            {
-                return a.first.DistTo(point) < b.first.DistTo(point);
-            });
-
-        if (res == m_verTextMap.cend())
-            return std::unexpected("Failed to get clossest point");
-
-        return res->first;
-    }
-
-    const std::vector<Vector3<float>>& NavigationMesh::GetNeighbors(const Vector3<float> &vertex) const
-    {
-        return m_verTextMap.at(vertex);
-    }
-
-    bool NavigationMesh::Empty() const
-    {
-        return m_verTextMap.empty();
-    }
-
-    std::vector<uint8_t> NavigationMesh::Serialize() const
-    {
-        auto dumpToVector =[]<typename T>(const T& t, std::vector<uint8_t>& vec){
-            for (size_t i = 0; i < sizeof(t); i++)
-                vec.push_back(*(reinterpret_cast<const uint8_t*>(&t)+i));
-        };
-
-        std::vector<uint8_t> raw;
-
-
-        for (const auto& [vertex, neighbors] : m_verTextMap)
-        {
-            const auto neighborsCount = neighbors.size();
-
-            dumpToVector(vertex, raw);
-            dumpToVector(neighborsCount, raw);
-
-            for (const auto& neighbor : neighbors)
-                dumpToVector(neighbor, raw);
-        }
-        return raw;
-
-    }
-
-    void NavigationMesh::Deserialize(const std::vector<uint8_t> &raw)
-    {
-        auto loadFromVector = [](const std::vector<uint8_t>& vec, size_t& offset, auto& value)
-        {
-            if (offset + sizeof(value) > vec.size())
-            {
-                throw std::runtime_error("Deserialize: Invalid input data size.");
-            }
-            std::copy_n(vec.data() + offset, sizeof(value), (uint8_t*)&value);
-            offset += sizeof(value);
-        };
-
-        m_verTextMap.clear();
-
-        size_t offset = 0;
-
-        while (offset < raw.size())
-        {
-            Vector3<float> vertex;
-            loadFromVector(raw, offset, vertex);
-
-            uint16_t neighborsCount;
-            loadFromVector(raw, offset, neighborsCount);
-
-            std::vector<Vector3<float>> neighbors;
-            neighbors.reserve(neighborsCount);
-
-            for (size_t i = 0; i < neighborsCount; ++i)
-            {
-                Vector3<float> neighbor;
-                loadFromVector(raw, offset, neighbor);
-                neighbors.push_back(neighbor);
-            }
-
-            m_verTextMap.emplace(vertex, std::move(neighbors));
-        }
-    }
-}

source/pathfinding/a_star.cpp

@@ -0,0 +1,99 @@
+//
+// Created by Vlad on 28.07.2024.
+//
+#include "omath/pathfinding/a_star.hpp"
+#include <algorithm>
+#include <optional>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace omath::pathfinding
+{
+    struct PathNode final
+    {
+        std::optional<Vector3<float>> came_from;
+        float g_cost = 0.f;
+    };
+
+    std::vector<Vector3<float>>
+    Astar::reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
+                                  const Vector3<float>& current)
+    {
+        std::vector<Vector3<float>> path;
+        std::optional current_opt = current;
+
+        while (current_opt)
+        {
+            path.push_back(*current_opt);
+
+            auto it = closed_list.find(*current_opt);
+
+            if (it == closed_list.end())
+                break;
+
+            current_opt = it->second.came_from;
+        }
+
+        std::ranges::reverse(path);
+        return path;
+    }
+    auto Astar::get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
+                                 const Vector3<float>& end_vertex)
+    {
+        return std::ranges::min_element(open_list,
+                                        [&end_vertex](const auto& a, const auto& b)
+                                        {
+                                            const float fa = a.second.g_cost + a.first.distance_to(end_vertex);
+                                            const float fb = b.second.g_cost + b.first.distance_to(end_vertex);
+                                            return fa < fb;
+                                        });
+    }
+
+    std::vector<Vector3<float>> Astar::find_path(const Vector3<float>& start, const Vector3<float>& end,
+                                                 const NavigationMesh& nav_mesh)
+    {
+        std::unordered_map<Vector3<float>, PathNode> closed_list;
+        std::unordered_map<Vector3<float>, PathNode> open_list;
+
+        auto maybe_start_vertex = nav_mesh.get_closest_vertex(start);
+        auto maybe_end_vertex = nav_mesh.get_closest_vertex(end);
+
+        if (!maybe_start_vertex || !maybe_end_vertex)
+            return {};
+
+        const auto start_vertex = maybe_start_vertex.value();
+        const auto end_vertex = maybe_end_vertex.value();
+
+        open_list.emplace(start_vertex, PathNode{std::nullopt, 0.f});
+
+        while (!open_list.empty())
+        {
+            auto current_it = get_perfect_node(open_list, end_vertex);
+
+            const auto current = current_it->first;
+            const auto current_node = current_it->second;
+
+            if (current == end_vertex)
+                return reconstruct_final_path(closed_list, current);
+
+            closed_list.emplace(current, current_node);
+            open_list.erase(current_it);
+
+            for (const auto& neighbor: nav_mesh.get_neighbors(current))
+            {
+                if (closed_list.contains(neighbor))
+                    continue;
+
+                const float tentative_g_cost = current_node.g_cost + neighbor.distance_to(current);
+
+                // ReSharper disable once CppTooWideScopeInitStatement
+                const auto open_it = open_list.find(neighbor);
+
+                if (open_it == open_list.end() || tentative_g_cost < open_it->second.g_cost)
+                    open_list[neighbor] = PathNode{current, tentative_g_cost};
+            }
+        }
+
+        return {};
+    }
+} // namespace omath::pathfinding

source/pathfinding/navigation_mesh.cpp

@@ -0,0 +1,90 @@
+//
+// Created by Vlad on 28.07.2024.
+//
+#include "omath/pathfinding/navigation_mesh.hpp"
+#include <algorithm>
+#include <stdexcept>
+namespace omath::pathfinding
+{
+    std::expected<Vector3<float>, std::string> NavigationMesh::get_closest_vertex(const Vector3<float>& point) const
+    {
+        const auto res = std::ranges::min_element(m_vertex_map, [&point](const auto& a, const auto& b)
+                                                  { return a.first.distance_to(point) < b.first.distance_to(point); });
+
+        if (res == m_vertex_map.cend())
+            return std::unexpected("Failed to get clossest point");
+
+        return res->first;
+    }
+
+    const std::vector<Vector3<float>>& NavigationMesh::get_neighbors(const Vector3<float>& vertex) const
+    {
+        return m_vertex_map.at(vertex);
+    }
+
+    bool NavigationMesh::empty() const
+    {
+        return m_vertex_map.empty();
+    }
+
+    std::vector<uint8_t> NavigationMesh::serialize() const
+    {
+        auto dump_to_vector = []<typename T>(const T& t, std::vector<uint8_t>& vec)
+        {
+            for (size_t i = 0; i < sizeof(t); i++)
+                vec.push_back(*(reinterpret_cast<const uint8_t*>(&t) + i));
+        };
+
+        std::vector<uint8_t> raw;
+
+        for (const auto& [vertex, neighbors]: m_vertex_map)
+        {
+            const auto neighbors_count = neighbors.size();
+
+            dump_to_vector(vertex, raw);
+            dump_to_vector(neighbors_count, raw);
+
+            for (const auto& neighbor: neighbors)
+                dump_to_vector(neighbor, raw);
+        }
+        return raw;
+    }
+
+    void NavigationMesh::deserialize(const std::vector<uint8_t>& raw)
+    {
+        auto load_from_vector = [](const std::vector<uint8_t>& vec, size_t& offset, auto& value)
+        {
+            if (offset + sizeof(value) > vec.size())
+            {
+                throw std::runtime_error("Deserialize: Invalid input data size.");
+            }
+            std::copy_n(vec.data() + offset, sizeof(value), reinterpret_cast<uint8_t*>(&value));
+            offset += sizeof(value);
+        };
+
+        m_vertex_map.clear();
+
+        size_t offset = 0;
+
+        while (offset < raw.size())
+        {
+            Vector3<float> vertex;
+            load_from_vector(raw, offset, vertex);
+
+            uint16_t neighbors_count;
+            load_from_vector(raw, offset, neighbors_count);
+
+            std::vector<Vector3<float>> neighbors;
+            neighbors.reserve(neighbors_count);
+
+            for (size_t i = 0; i < neighbors_count; ++i)
+            {
+                Vector3<float> neighbor;
+                load_from_vector(raw, offset, neighbor);
+                neighbors.push_back(neighbor);
+            }
+
+            m_vertex_map.emplace(vertex, std::move(neighbors));
+        }
+    }
+} // namespace omath::pathfinding

source/projectile_prediction/CMakeLists.txt

@@ -1 +0,0 @@
-target_sources(omath PRIVATE ProjPredEngineLegacy.cpp Projectile.cpp Target.cpp ProjPredEngineAVX2.cpp ProjPredEngine.cpp)

source/projectile_prediction/ProjPredEngineLegacy.cpp

@@ -1,68 +0,0 @@
-#include "omath/projectile_prediction/ProjPredEngineLegacy.hpp"
-#include <cmath>
-#include <omath/Angles.hpp>
-
-namespace omath::projectile_prediction
-{
-    ProjPredEngineLegacy::ProjPredEngineLegacy(const float gravityConstant, const float simulationTimeStep,
-                                               const float maximumSimulationTime, const float distanceTolerance) :
-        m_gravityConstant(gravityConstant), m_simulationTimeStep(simulationTimeStep),
-        m_maximumSimulationTime(maximumSimulationTime), m_distanceTolerance(distanceTolerance)
-    {
-    }
-
-    std::optional<Vector3<float>> ProjPredEngineLegacy::MaybeCalculateAimPoint(const Projectile& projectile,
-                                                                        const Target& target) const
-    {
-        for (float time = 0.f; time < m_maximumSimulationTime; time += m_simulationTimeStep)
-        {
-            const auto predictedTargetPosition = target.PredictPosition(time, m_gravityConstant);
-
-            const auto projectilePitch = MaybeCalculateProjectileLaunchPitchAngle(projectile, predictedTargetPosition);
-
-            if (!projectilePitch.has_value()) [[unlikely]]
-                continue;
-
-            if (!IsProjectileReachedTarget(predictedTargetPosition, projectile, projectilePitch.value(), time))
-                continue;
-
-            const auto delta2d = (predictedTargetPosition - projectile.m_origin).Length2D();
-            const auto height = delta2d * std::tan(angles::DegreesToRadians(projectilePitch.value()));
-
-            return Vector3(predictedTargetPosition.x, predictedTargetPosition.y, projectile.m_origin.z + height);
-        }
-        return std::nullopt;
-    }
-
-    std::optional<float>
-    ProjPredEngineLegacy::MaybeCalculateProjectileLaunchPitchAngle(const Projectile& projectile,
-                                                                   const Vector3<float>& targetPosition) const
-    {
-        const auto bulletGravity = m_gravityConstant * projectile.m_gravityScale;
-        const auto delta = targetPosition - projectile.m_origin;
-
-        const auto distance2d = delta.Length2D();
-        const auto distance2dSqr = distance2d * distance2d;
-        const auto launchSpeedSqr = projectile.m_launchSpeed * projectile.m_launchSpeed;
-
-        float root = launchSpeedSqr * launchSpeedSqr -
-                     bulletGravity * (bulletGravity * distance2dSqr + 2.0f * delta.z * launchSpeedSqr);
-
-        if (root < 0.0f) [[unlikely]]
-            return std::nullopt;
-
-        root = std::sqrt(root);
-        const float angle = std::atan((launchSpeedSqr - root) / (bulletGravity * distance2d));
-
-        return angles::RadiansToDegrees(angle);
-    }
-
-    bool ProjPredEngineLegacy::IsProjectileReachedTarget(const Vector3<float>& targetPosition, const Projectile& projectile,
-                                                         const float pitch, const float time) const
-    {
-        const auto yaw = projectile.m_origin.ViewAngleTo(targetPosition).y;
-        const auto projectilePosition = projectile.PredictPosition(pitch, yaw, time, m_gravityConstant);
-
-        return projectilePosition.DistTo(targetPosition) <= m_distanceTolerance;
-    }
-} // namespace omath::projectile_prediction

source/projectile_prediction/Projectile.cpp

@@ -1,21 +0,0 @@
-//
-// Created by Vlad on 6/9/2024.
-//
-
-#include "omath/projectile_prediction/Projectile.hpp"
-
-#include <omath/engines/source_engine/Formulas.hpp>
-
-namespace omath::projectile_prediction
-{
-    Vector3<float> Projectile::PredictPosition(const float pitch, const float yaw, const float time, const float gravity) const
-    {
-        auto currentPos = m_origin + source_engine::ForwardVector({source_engine::PitchAngle::FromDegrees(-pitch),
-                                                            source_engine::YawAngle::FromDegrees(yaw),
-                                                            source_engine::RollAngle::FromDegrees(0)}) *
-                                             m_launchSpeed * time;
-        currentPos.z -= (gravity * m_gravityScale) * (time * time) * 0.5f;
-
-        return currentPos;
-    }
-} // namespace omath::prediction

source/projectile_prediction/proj_pred_engine.cpp

@@ -1,8 +1,7 @@
 //
 // Created by Vlad on 2/23/2025.
 //
-#include "omath/projectile_prediction/ProjPredEngine.hpp"
+#include "omath/projectile_prediction/proj_pred_engine.hpp"
-
 
 namespace omath::projectile_prediction
 {

source/projectile_prediction/proj_pred_engine_avx2.cpp

@@ -1,16 +1,23 @@
 //
 // Created by Vlad on 2/23/2025.
 //
-#include "omath/projectile_prediction/ProjPredEngineAVX2.hpp"
+#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
 {
     std::optional<Vector3<float>>
-    ProjPredEngineAVX2::MaybeCalculateAimPoint([[maybe_unused]] const Projectile& projectile,
+    ProjPredEngineAvx2::maybe_calculate_aim_point([[maybe_unused]] const Projectile& projectile,
-                                               [[maybe_unused]] const Target& target) const
+                                                  [[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;
@@ -21,16 +28,16 @@ namespace omath::projectile_prediction
 
         for (; currentTime <= m_maximumSimulationTime; currentTime += m_simulationTimeStep * SIMD_FACTOR)
         {
-            const __m256 times =
+            const __m256 times
-                    _mm256_setr_ps(currentTime, currentTime + m_simulationTimeStep,
+                    = _mm256_setr_ps(currentTime, currentTime + m_simulationTimeStep,
-                                   currentTime + m_simulationTimeStep * 2, currentTime + m_simulationTimeStep * 3,
+                                     currentTime + m_simulationTimeStep * 2, currentTime + m_simulationTimeStep * 3,
-                                   currentTime + m_simulationTimeStep * 4, currentTime + m_simulationTimeStep * 5,
+                                     currentTime + m_simulationTimeStep * 4, currentTime + m_simulationTimeStep * 5,
-                                   currentTime + m_simulationTimeStep * 6, currentTime + m_simulationTimeStep * 7);
+                                     currentTime + m_simulationTimeStep * 6, currentTime + m_simulationTimeStep * 7);
 
-            const __m256 targetX =
+            const __m256 targetX
-                    _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.x), times, _mm256_set1_ps(target.m_origin.x));
+                    = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.x), times, _mm256_set1_ps(target.m_origin.x));
-            const __m256 targetY =
+            const __m256 targetY
-                    _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.y), times, _mm256_set1_ps(target.m_origin.y));
+                    = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.y), times, _mm256_set1_ps(target.m_origin.y));
             const __m256 timesSq = _mm256_mul_ps(times, times);
             const __m256 targetZ = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.z), times,
                                                    _mm256_fnmadd_ps(_mm256_set1_ps(0.5f * m_gravityConstant), timesSq,
@@ -105,25 +112,32 @@ namespace omath::projectile_prediction
         }
 
         return std::nullopt;
+#else
+        throw std::runtime_error(
+                std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
+#endif
     }
-    ProjPredEngineAVX2::ProjPredEngineAVX2(const float gravityConstant, const float simulationTimeStep,
+    ProjPredEngineAvx2::ProjPredEngineAvx2(const float gravity_constant, const float simulation_time_step,
-                                           const float maximumSimulationTime) :
+                                           const float maximum_simulation_time)
-        m_gravityConstant(gravityConstant), m_simulationTimeStep(simulationTimeStep),
+        : m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),
-        m_maximumSimulationTime(maximumSimulationTime)
+          m_maximum_simulation_time(maximum_simulation_time)
     {
     }
-    std::optional<float> ProjPredEngineAVX2::CalculatePitch(const Vector3<float>& projOrigin,
+    std::optional<float> ProjPredEngineAvx2::calculate_pitch([[maybe_unused]] const Vector3<float>& proj_origin,
-                                                            const Vector3<float>& targetPos, const float bulletGravity,
+                                                             [[maybe_unused]] const Vector3<float>& target_pos,
-                                                            const float v0, const float time)
+                                                             [[maybe_unused]] const float bullet_gravity,
+                                                             [[maybe_unused]] const float v0,
+                                                             [[maybe_unused]] const float time)
     {
+#if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
         if (time <= 0.0f)
             return std::nullopt;
 
-        const Vector3 delta = targetPos - projOrigin;
+        const Vector3 delta = target_pos - proj_origin;
         const float dSqr = delta.x * delta.x + delta.y * delta.y;
         const float h = delta.z;
 
-        const float term = h + 0.5f * bulletGravity * time * time;
+        const float term = h + 0.5f * bullet_gravity * time * time;
         const float requiredV0Sqr = (dSqr + term * term) / (time * time);
         const float v0Sqr = v0 * v0;
 
@@ -133,7 +147,6 @@ namespace omath::projectile_prediction
         if (dSqr == 0.0f)
             return term >= 0.0f ? 90.0f : -90.0f;
 
-
         const float d = std::sqrt(dSqr);
         const float tanTheta = term / d;
         return angles::RadiansToDegrees(std::atan(tanTheta));