Merge pull request #53 from orange-cpp/u/camera_type_traits

Refactors camera and prediction using traits

.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: NonAssignment
-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,5 @@
 /cmake-build/
 /.idea
 /out
+*.DS_Store
+/extlibs/vcpkg

.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

@@ -1,47 +1,108 @@
 cmake_minimum_required(VERSION 3.26)
 
-project(omath VERSION 1.0.1)
+project(omath VERSION 3.0.4.1 LANGUAGES CXX)
 
 include(CMakePackageConfigHelpers)
 
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
 
-option(OMATH_BUILD_TESTS "Build unit tests" ON)
+option(OMATH_BUILD_TESTS "Build unit tests" ${PROJECT_IS_TOP_LEVEL})
 option(OMATH_THREAT_WARNING_AS_ERROR "Set highest level of warnings and force compiler to treat them as errors" ON)
 option(OMATH_BUILD_AS_SHARED_LIBRARY "Build Omath as .so or .dll" OFF)
+option(OMATH_USE_AVX2 "Omath will use AVX2 to boost performance" 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)
+option(OMATH_ENABLE_LEGACY "Will enable legacy classes that MUST be used ONLY for backward compatibility" OFF)
+
+
+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/Vector3.cpp)
+    add_library(${PROJECT_NAME} SHARED ${OMATH_SOURCES} ${OMATH_HEADERS})
-else()
+else ()
-    add_library(omath STATIC source/Vector3.cpp
+    add_library(${PROJECT_NAME} STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
-            include/omath/engines/OpenGL/Constants.hpp
+endif ()
-            include/omath/engines/OpenGL/Formulas.hpp
-            include/omath/engines/OpenGL/Camera.hpp)
-endif()
 
-set_target_properties(omath PROPERTIES
+message(STATUS "[OMATH]: Building on ${CMAKE_HOST_SYSTEM_NAME}")
+
+add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
+
+if (OMATH_IMGUI_INTEGRATION)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_IMGUI_INTEGRATION)
+
+    # IMGUI is being linked as submodule
+    if (TARGET imgui)
+        target_link_libraries(${PROJECT_NAME} 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(${PROJECT_NAME} PUBLIC imgui::imgui)
+    endif ()
+
+endif ()
+
+if (OMATH_USE_AVX2)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_USE_AVX2)
+endif ()
+
+if (OMATH_SUPRESS_SAFETY_CHECKS)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_SUPRESS_SAFETY_CHECKS)
+endif ()
+
+if (OMATH_ENABLE_LEGACY)
+    target_compile_options(${PROJECT_NAME} PUBLIC OMATH_ENABLE_LEGACY)
+endif ()
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
         CXX_STANDARD 23
         CXX_STANDARD_REQUIRED ON)
-target_compile_features(omath PUBLIC cxx_std_23)
 
-target_compile_definitions(omath PUBLIC OMATH_EXPORT)
+if (OMATH_USE_UNITY_BUILD)
+    set_target_properties(${PROJECT_NAME} PROPERTIES
+            UNITY_BUILD ON
+            UNITY_BUILD_BATCH_SIZE 20)
+endif ()
 
-add_subdirectory(source)
+if (OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
+    set_target_properties(${PROJECT_NAME} PROPERTIES
+            MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
+    )
+endif ()
 
-if(OMATH_BUILD_TESTS)
+if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    target_compile_options(${PROJECT_NAME} PRIVATE -mavx2 -mfma)
+endif ()
+
+target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_23)
+
+
+if (OMATH_BUILD_TESTS)
     add_subdirectory(extlibs)
     add_subdirectory(tests)
-endif()
+endif ()
+
+if (OMATH_BUILD_EXAMPLES)
+    add_subdirectory(examples)
+endif ()
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND OMATH_THREAT_WARNING_AS_ERROR)
-    target_compile_options(omath PRIVATE /W4 /WX)
+    target_compile_options(${PROJECT_NAME} PRIVATE /W4 /WX)
-elseif(OMATH_THREAT_WARNING_AS_ERROR)
+elseif (OMATH_THREAT_WARNING_AS_ERROR)
-    target_compile_options(omath PRIVATE -Wall -Wextra -Wpedantic -Werror)
+    target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Wextra -Wpedantic -Werror)
-endif()
+endif ()
 
-target_include_directories(omath
+target_include_directories(${PROJECT_NAME}
         PUBLIC
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>   # Use this path when building the project
         $<INSTALL_INTERFACE:include>                             # Use this path when the project is installed
@@ -51,21 +112,21 @@ target_include_directories(omath
 # Installation rules
 
 # Install the library
-install(TARGETS omath
+install(TARGETS ${PROJECT_NAME}
-        EXPORT omathTargets
+        EXPORT ${PROJECT_NAME}Targets
-        ARCHIVE DESTINATION lib COMPONENT omath   # For static libraries
+        ARCHIVE DESTINATION lib COMPONENT ${PROJECT_NAME}   # For static libraries
-        LIBRARY DESTINATION lib COMPONENT omath   # For shared libraries
+        LIBRARY DESTINATION lib COMPONENT ${PROJECT_NAME}   # For shared libraries
-        RUNTIME DESTINATION bin COMPONENT omath   # For executables (on Windows)
+        RUNTIME DESTINATION bin COMPONENT ${PROJECT_NAME}   # For executables (on Windows)
 )
 
 # Install headers as part of omath_component
-install(DIRECTORY include/ DESTINATION include COMPONENT omath)
+install(DIRECTORY include/ DESTINATION include COMPONENT ${PROJECT_NAME})
 
 # Export omath target for CMake find_package support, also under omath_component
-install(EXPORT omathTargets
+install(EXPORT ${PROJECT_NAME}Targets
-        FILE omathTargets.cmake
+        FILE ${PROJECT_NAME}Targets.cmake
-        NAMESPACE omath::
+        NAMESPACE ${PROJECT_NAME}::
-        DESTINATION lib/cmake/omath COMPONENT omath
+        DESTINATION lib/cmake/${PROJECT_NAME} COMPONENT ${PROJECT_NAME}
 )
 
 
@@ -80,12 +141,12 @@ write_basic_package_version_file(
 configure_package_config_file(
         "${CMAKE_CURRENT_SOURCE_DIR}/cmake/omathConfig.cmake.in"  # Path to the .in file
         "${CMAKE_CURRENT_BINARY_DIR}/omathConfig.cmake"           # Output path for the generated file
-        INSTALL_DESTINATION lib/cmake/omath
+        INSTALL_DESTINATION lib/cmake/${PROJECT_NAME}
 )
 
 # Install the generated config files
 install(FILES
         "${CMAKE_CURRENT_BINARY_DIR}/omathConfig.cmake"
         "${CMAKE_CURRENT_BINARY_DIR}/omathConfigVersion.cmake"
-        DESTINATION lib/cmake/omath
+        DESTINATION lib/cmake/${PROJECT_NAME}
 )

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"
+      }
     }
   ]
 }

CONTRIBUTING.md

@@ -0,0 +1,32 @@
+## 🤝 Contributing to OMath or other Orange's Projects
+
+### ❕ Prerequisites
+
+- A working up-to-date OMath installation
+- C++ knowledge
+- Git knowledge
+- Ability to ask for help (Feel free to create empty pull-request or PM a maintainer
+  in [Telegram](https://t.me/orange_cpp))
+
+### ⏬ Setting up OMath
+
+Please read INSTALL.md file in repository
+
+### 🔀 Pull requests and Branches
+
+In order to send code back to the official OMath repository, you must first create a copy of OMath on your github
+account ([fork](https://help.github.com/articles/creating-a-pull-request-from-a-fork/)) and
+then [create a pull request](https://help.github.com/articles/creating-a-pull-request-from-a-fork/) back to OMath.
+
+OMath developement is performed on multiple branches. Changes are then pull requested into master. By default, changes
+merged into master will not roll out to stable build users unless the `stable` tag is updated.
+
+### 📜 Code-Style
+
+The orange code-style can be found in `.clang-format`.
+
+### 📦 Building
+
+OMath has already created the  `cmake-build` and `out` directories where cmake/bin files are located. By default, you
+can build OMath by running `cmake --build cmake-build/build/windows-release --target omath -j 6` in the source
+directory.

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,68 @@
+# 📥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://xmake.io/assets/img/logo.svg" /> Using xrepo
+**Note**: Support xrepo for package management
+1. Install [xmake](https://xmake.io/)
+2. Run the following command to install the omath package:
+```
+xrepo install omath
+```
+xmake.lua
+```xmake
+add_requires("omath")
+target("...")
+    add_packages("omath")
+```
+
+## <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 |

LICENSE

@@ -1,9 +1,17 @@
-The MIT License (MIT)
+Copyright (C) 2024-2025 Orange++ <orange-cpp@yandex.ru>
 
-Copyright (c) 2024 Orange++
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
 
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+1. The origin of this software must not be misrepresented; you must not
-
+   claim that you wrote the original software. If you use this software
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.

README.md

@@ -1,59 +1,60 @@
 <div align = center>
 
-![banner](https://i.imgur.com/sjtpKi8.png)
+![banner](https://github.com/orange-cpp/omath/blob/main/.github/images/banner.png?raw=true)
 
 ![GitHub License](https://img.shields.io/github/license/orange-cpp/omath)
 ![GitHub contributors](https://img.shields.io/github/contributors/orange-cpp/omath)
 ![GitHub top language](https://img.shields.io/github/languages/top/orange-cpp/omath)
 [![CodeFactor](https://www.codefactor.io/repository/github/orange-cpp/omath/badge)](https://www.codefactor.io/repository/github/orange-cpp/omath)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/orange-cpp/omath/cmake-multi-platform.yml)
+[![Vcpkg package](https://repology.org/badge/version-for-repo/vcpkg/orange-math.svg)](https://repology.org/project/orange-math/versions)
 ![GitHub forks](https://img.shields.io/github/forks/orange-cpp/omath)
+[![discord badge](https://dcbadge.limes.pink/api/server/https://discord.gg/eDgdaWbqwZ?style=flat)](https://discord.gg/eDgdaWbqwZ)
+[![telegram badge](https://img.shields.io/badge/Telegram-2CA5E0?style=flat-squeare&logo=telegram&logoColor=white)](https://t.me/orangennotes)
+
 </div>
 
 Oranges's Math Library (omath) is a comprehensive, open-source library aimed at providing efficient, reliable, and versatile mathematical functions and algorithms. Developed primarily in C++, this library is designed to cater to a wide range of mathematical operations essential in scientific computing, engineering, and academic research.
 
+<div align = center>
+ <a href="https://www.star-history.com/#orange-cpp/omath&Date">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=orange-cpp/omath&type=Date&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=orange-cpp/omath&type=Date" />
+    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=orange-cpp/omath&type=Date" />
+  </picture>
+ </a>
+</div>
+
 ## 👁‍🗨 Features
-- **Efficiency**: Optimized for performance, ensuring quick computations.
+- **Efficiency**: Optimized for performance, ensuring quick computations using AVX2.
 - **Versatility**: Includes a wide array of mathematical functions and algorithms.
 - **Ease of Use**: Simplified interface for convenient integration into various projects.
 - **Projectile Prediction**: Projectile prediction engine with O(N) algo complexity, that can power you projectile aim-bot.
 - **3D Projection**: No need to find view-projection matrix anymore you can make your own projection pipeline.
 - **Collision Detection**: Production ready code to handle collision detection by using simple interfaces.
 - **No Additional Dependencies**: No additional dependencies need to use OMath except unit test execution
+- **Ready for meta-programming**: Omath use templates for common types like Vectors, Matrixes etc, to handle all types!
 
-## ⏬ Getting Started
+## Supported Render Pipelines
-### Prerequisites
+| ENGINE   | SUPPORT |
-- C++ Compiler
+|----------|---------|
-- CMake (for building the project)
+| Source   | ✅YES    |
+| Unity    | ✅YES    |
+| IWEngine | ✅YES    |
+| Unreal   | ❌NO     |
+
+## Supported Operating Systems
+
+| OS             | SUPPORT |
+|----------------|---------|
+| Windows 10/11  | ✅YES    |
+| Linux          | ✅YES    |
+| Darwin (MacOS) | ✅YES    |
+
+## ⏬ Installation
+Please read our [installation guide](https://github.com/orange-cpp/omath/blob/main/INSTALL.md). If this link doesn't work check out INSTALL.md file.
 
-### Installation
-### vcpkg
-**Note**: Support vcpkg for package management
-1. Install vcpkg (https://github.com/microsoft/vcpkg)
-2. Run the following command to install the orange-math package:
-```
-vcpkg install orange-math
-```
-CMakeLists.txt
-```cmake
-find_package(omath CONFIG REQUIRED)
-target_link_libraries(main PRIVATE omath::omath)
-```
-For detailed commands on installing different versions and more information, please refer to Microsoft's official instructions (https://learn.microsoft.com/en-us/vcpkg/get_started/overview)
-### Build from source
-1. Clone the repository:
-   ```
-   git clone https://github.com/orange-cpp/omath.git
-   ```
-2. Navigate to the project directory:
-   ```
-   cd omath
-   ```
-3. Build the project using CMake:
-   ```
-   cmake --preset windows-release -S .
-   cmake --build cmake-build/build/windows-release --target server -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,22 +66,26 @@ 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)
-![Watch Video](https://youtu.be/lM_NJ1yCunw?si=5E87OrQMeypxSJ3E)
+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>
 
 ## 🫵🏻 Contributing
 Contributions to `omath` are welcome! Please read `CONTRIBUTING.md` for details on our code of conduct and the process for submitting pull requests.
 
 ## 📜 License
-This project is licensed under the MIT - see the `LICENSE` file for details.
+This project is licensed under the ZLIB - see the `LICENSE` file for details.
 
 ## 💘 Acknowledgments
 -  [All contributors](https://github.com/orange-cpp/omath/graphs/contributors)

cmake/omathConfig.cmake.in

@@ -2,6 +2,10 @@
 
 include(CMakeFindDependencyMacro)
 
+if (@OMATH_IMGUI_INTEGRATION@)
+    find_dependency(imgui CONFIG)
+endif()
+
 # Load the targets for the omath library
 include("${CMAKE_CURRENT_LIST_DIR}/omathTargets.cmake")
 check_required_components(omath)

examples/CMakeLists.txt

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

examples/example_proj_mat_builder.cpp

@@ -0,0 +1,40 @@
+//
+// Created by Vlad on 3/19/2025.
+//
+
+
+#include <iostream>
+#include <print>
+#include <omath/engines/opengl_engine/formulas.hpp>
+
+
+int main()
+{
+    std::println("OMATH Projection Matrix Builder");
+
+    float fov = 0;
+    float near = 0;
+    float far = 0;
+    float view_port_width = 0;
+    float view_port_height = 0;
+
+    std::print("Enter camera fov: ");
+    std::cin >> fov;
+
+    std::print("Enter camera z near: ");
+    std::cin >> near;
+
+    std::print("Enter camera z far: ");
+    std::cin >> far;
+
+    std::print("Enter camera screen width: ");
+    std::cin >> view_port_width;
+
+    std::print("Enter camera screen height: ");
+    std::cin >> view_port_height;
+
+    const auto mat =
+            omath::opengl_engine::calc_perspective_projection_matrix(fov, view_port_width / view_port_height, near, far);
+
+    std::print("{}", mat.to_string());
+};

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

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
-    {
-        public:
-            constexpr Color(float r, float g, float b, 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/Mat.hpp

@@ -1,421 +0,0 @@
-//
-// Created by vlad on 9/29/2024.
-//
-#pragma once
-#include <algorithm>
-#include <array>
-#include <sstream>
-#include <stdexcept>
-#include <utility>
-#include "Vector3.hpp"
-
-namespace omath
-{
-    struct MatSize
-    {
-        size_t rows, columns;
-    };
-
-    enum class MatStoreType : uint8_t
-    {
-        ROW_MAJOR = 0,
-        COLUMN_MAJOR
-    };
-
-
-    template<typename M1, typename M2>
-    concept MatTemplateEqual =
-            (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>
-    class Mat final
-    {
-    public:
-        constexpr Mat()
-        {
-            Clear();
-        }
-        constexpr static MatStoreType GetStoreOrdering()
-        {
-            return StoreType;
-        }
-        constexpr Mat(const std::initializer_list<std::initializer_list<Type>>& rows)
-        {
-            if (rows.size() != Rows)
-                throw std::invalid_argument("Initializer list rows size does not match template parameter Rows");
-
-            auto rowIt = rows.begin();
-            for (size_t i = 0; i < Rows; ++i, ++rowIt)
-            {
-                if (rowIt->size() != Columns)
-                    throw std::invalid_argument(
-                            "All rows must have the same number of columns as template parameter Columns");
-
-                auto colIt = rowIt->begin();
-                for (size_t j = 0; j < Columns; ++j, ++colIt)
-                {
-                    At(i, j) = std::move(*colIt);
-                }
-            }
-        }
-
-        constexpr explicit Mat(const Type* rawData)
-        {
-            std::copy_n(rawData, Rows * Columns, m_data.begin());
-        }
-
-        constexpr Mat(const Mat& other) noexcept
-        {
-            m_data = other.m_data;
-        }
-
-        constexpr Type& operator[](const size_t row, const size_t col)
-        {
-            return At(row, col);
-        }
-
-        constexpr Mat(Mat&& other) noexcept
-        {
-            m_data = std::move(other.m_data);
-        }
-
-        [[nodiscard]]
-        static constexpr size_t RowCount() noexcept
-        {
-            return Rows;
-        }
-
-        [[nodiscard]]
-        static constexpr size_t ColumnsCount() noexcept
-        {
-            return Columns;
-        }
-
-        [[nodiscard]]
-        static consteval MatSize Size() noexcept
-        {
-            return {Rows, Columns};
-        }
-
-        [[nodiscard]] constexpr const Type& At(const size_t rowIndex, const size_t columnIndex) const
-        {
-            if (rowIndex >= Rows || columnIndex >= Columns)
-                throw std::out_of_range("Index out of range");
-
-            if constexpr (StoreType == MatStoreType::ROW_MAJOR)
-                return m_data[rowIndex * Columns + columnIndex];
-
-            else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
-                return m_data[rowIndex + columnIndex * Rows];
-
-            else
-            {
-                static_assert(false, "Invalid matrix access convention");
-                std::unreachable();
-            }
-        }
-
-        [[nodiscard]] constexpr Type& At(const size_t rowIndex, const size_t columnIndex)
-        {
-            return const_cast<Type&>(std::as_const(*this).At(rowIndex, columnIndex));
-        }
-
-        [[nodiscard]]
-        constexpr Type Sum() const noexcept
-        {
-            Type sum = 0;
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    sum += At(i, j);
-
-            return sum;
-        }
-
-        constexpr void Clear() noexcept
-        {
-            Set(0);
-        }
-
-        constexpr void Set(const Type& value) noexcept
-        {
-            std::ranges::fill(m_data, value);
-        }
-
-        // Operator overloading for multiplication with another Mat
-        template<size_t OtherColumns>
-        constexpr Mat<Rows, OtherColumns, Type, StoreType>
-        operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
-        {
-            Mat<Rows, OtherColumns, Type, StoreType> result;
-
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < OtherColumns; ++j)
-                {
-                    Type sum = 0;
-                    for (size_t k = 0; k < Columns; ++k)
-                        sum += At(i, k) * other.At(k, j);
-                    result.At(i, j) = sum;
-                }
-            return result;
-        }
-
-        constexpr Mat& operator*=(const Type& f) noexcept
-        {
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) *= f;
-            return *this;
-        }
-
-        template<size_t OtherColumns>
-        constexpr Mat<Rows, OtherColumns, Type, StoreType>
-        operator*=(const Mat<Columns, OtherColumns, Type, StoreType>& other)
-        {
-            return *this = *this * other;
-        }
-
-        constexpr Mat operator*(const Type& f) const noexcept
-        {
-            Mat result(*this);
-            result *= f;
-            return result;
-        }
-
-        constexpr Mat& operator/=(const Type& f) noexcept
-        {
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) /= f;
-            return *this;
-        }
-
-        constexpr Mat operator/(const Type& f) const noexcept
-        {
-            Mat result(*this);
-            result /= f;
-            return result;
-        }
-
-        constexpr Mat& operator=(const Mat& other) noexcept
-        {
-            if (this == &other)
-                return *this;
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) = other.At(i, j);
-            return *this;
-        }
-
-        constexpr Mat& operator=(Mat&& other) noexcept
-        {
-            if (this == &other)
-                return *this;
-
-            for (size_t i = 0; i < Rows; ++i)
-                for (size_t j = 0; j < Columns; ++j)
-                    At(i, j) = other.At(i, j);
-
-            return *this;
-        }
-
-        [[nodiscard]]
-        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);
-
-            return transposed;
-        }
-
-        [[nodiscard]]
-        constexpr Type Determinant() const
-        {
-            static_assert(Rows == Columns, "Determinant is only defined for square matrices.");
-
-            if constexpr (Rows == 1)
-                return At(0, 0);
-
-            else if constexpr (Rows == 2)
-                return At(0, 0) * At(1, 1) - At(0, 1) * At(1, 0);
-            else
-            {
-                Type det = 0;
-                for (size_t i = 0; i < Columns; ++i)
-                {
-                    const Type cofactor = (i % 2 == 0 ? 1 : -1) * At(0, i) * Minor(0, i).Determinant();
-                    det += cofactor;
-                }
-                return det;
-            }
-        }
-
-        [[nodiscard]]
-        constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> Minor(const size_t row, const size_t column) const
-        {
-            Mat<Rows - 1, Columns - 1, Type, StoreType> result;
-            for (size_t i = 0, m = 0; i < Rows; ++i)
-            {
-                if (i == row)
-                    continue;
-                for (size_t j = 0, n = 0; j < Columns; ++j)
-                {
-                    if (j == column)
-                        continue;
-                    result.At(m, n) = At(i, j);
-                    ++n;
-                }
-                ++m;
-            }
-            return result;
-        }
-
-        [[nodiscard]]
-        constexpr const std::array<Type, Rows * Columns>& RawArray() const
-        {
-            return m_data;
-        }
-
-        [[nodiscard]]
-        constexpr std::array<Type, Rows * Columns>& RawArray()
-        {
-            return const_cast<std::array<Type, Rows * Columns>>(std::as_const(*this).RawArray());
-        }
-
-        [[nodiscard]]
-        std::string ToString() const noexcept
-        {
-            std::ostringstream oss;
-            for (size_t i = 0; i < Rows; ++i)
-            {
-                for (size_t j = 0; j < Columns; ++j)
-                {
-                    oss << At(i, j);
-                    if (j != Columns - 1)
-                        oss << ' ';
-                }
-                oss << '\n';
-            }
-            return oss.str();
-        }
-
-        [[nodiscard]]
-        bool operator==(const Mat& mat) const
-        {
-            return m_data == mat.m_data;
-        }
-
-        [[nodiscard]]
-        bool operator!=(const Mat& mat) const
-        {
-            return !operator==(mat);
-        }
-
-        // Static methods that return fixed-size matrices
-        [[nodiscard]]
-        constexpr static Mat<4, 4> ToScreenMat(const Type& screenWidth, const Type& screenHeight) noexcept
-        {
-            return {
-                    {screenWidth / 2, 0, 0, 0},
-                    {0, -screenHeight / 2, 0, 0},
-                    {0, 0, 1, 0},
-                    {screenWidth / 2, screenHeight / 2, 0, 1},
-            };
-        }
-
-    private:
-        std::array<Type, Rows * Columns> m_data;
-    };
-
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
-    [[nodiscard]]
-    constexpr static Mat<1, 4, Type, St> MatRowFromVector(const Vector3& vector) noexcept
-    {
-        return {{vector.x, vector.y, vector.z, 1}};
-    }
-
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
-    [[nodiscard]]
-    constexpr static Mat<4, 1, Type, St> MatColumnFromVector(const Vector3& 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& diff) noexcept
-    {
-        return
-        {
-                {1, 0, 0, diff.x},
-                {0, 1, 0, diff.y},
-                {0, 0, 1, diff.z},
-                {0, 0, 0, 1},
-        };
-    }
-
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
-    [[nodiscard]]
-    Mat<4, 4, Type, St> MatRotationAxisX(const Angle& angle) noexcept
-    {
-        return
-        {
-            {1, 0,           0,            0},
-            {0, angle.Cos(), -angle.Sin(), 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
-    {
-        return
-        {
-            {angle.Cos(),  0, angle.Sin(), 0},
-            {0           , 1,           0, 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
-    {
-        return
-        {
-            {angle.Cos(), -angle.Sin(), 0, 0},
-            {angle.Sin(),  angle.Cos(), 0, 0},
-            {          0,        0,     1, 0},
-            {          0,        0,     0, 1},
-        };
-    }
-
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
-    [[nodiscard]]
-    static Mat<4, 4, Type, St> MatCameraView(const Vector3& forward, const Vector3& right, const Vector3& up,
-                                             const Vector3& cameraOrigin) noexcept
-    {
-        return  Mat<4, 4, Type, St>
-        {
-            {right.x,   right.y,   right.z,   0},
-            {up.x,      up.y,      up.z,      0},
-            {forward.x, forward.y, forward.z, 0},
-            {0,         0,         0,         1},
-
-        } * MatTranslation<Type, St>(-cameraOrigin);
-    }
-
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class ViewAngles>
-    [[nodiscard]]
-    Mat<4, 4, Type, St> MatRotation(const ViewAngles& angles) noexcept
-    {
-        return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
-    }
-} // namespace omath

include/omath/Triangle.hpp

@@ -1,74 +0,0 @@
-//
-// Created by Orange on 11/13/2024.
-//
-#pragma once
-#include "omath/Vector3.hpp"
-
-namespace omath
-{
-    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 m_vertex1;
-        Vector3 m_vertex2;
-        Vector3 m_vertex3;
-
-        [[nodiscard]]
-        constexpr Vector3 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 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 SideBVector() const
-        {
-            return m_vertex3 - m_vertex2;
-        }
-        [[nodiscard]]
-        constexpr Vector3 MidPoint() const
-        {
-            return (m_vertex1 + m_vertex2 + m_vertex3) / 3;
-        }
-    };
-} // namespace omath

include/omath/Vector2.hpp

@@ -1,201 +0,0 @@
-//
-// Created by Vlad on 02.09.2024.
-//
-
-#pragma once
-#include <tuple>
-#include <cmath>
-
-namespace omath
-{
-    class Vector2
-    {
-    public:
-        float x = 0.f;
-        float y = 0.f;
-
-        // Constructors
-        constexpr Vector2() = default;
-
-        constexpr Vector2(const float x, const float y) : x(x), y(y) {}
-
-        // Equality operators
-        [[nodiscard]]
-        constexpr bool operator==(const Vector2& src) const
-        {
-            return x == src.x && y == src.y;
-        }
-
-        [[nodiscard]]
-        constexpr bool operator!=(const Vector2& src) const
-        {
-            return !(*this == src);
-        }
-
-        // Compound assignment operators
-        constexpr Vector2& operator+=(const Vector2& v)
-        {
-            x += v.x;
-            y += v.y;
-
-            return *this;
-        }
-
-        constexpr Vector2& operator-=(const Vector2& v)
-        {
-            x -= v.x;
-            y -= v.y;
-
-            return *this;
-        }
-
-        constexpr Vector2& operator*=(const Vector2& v)
-        {
-            x *= v.x;
-            y *= v.y;
-
-            return *this;
-        }
-
-        constexpr Vector2& operator/=(const Vector2& v)
-        {
-            x /= v.x;
-            y /= v.y;
-
-            return *this;
-        }
-
-        constexpr Vector2& operator*=(const float fl)
-        {
-            x *= fl;
-            y *= fl;
-
-            return *this;
-        }
-
-        constexpr Vector2& operator/=(const float fl)
-        {
-            x /= fl;
-            y /= fl;
-
-            return *this;
-        }
-
-        constexpr Vector2& operator+=(const float fl)
-        {
-            x += fl;
-            y += fl;
-
-            return *this;
-        }
-
-        constexpr Vector2& operator-=(const float fl)
-        {
-            x -= fl;
-            y -= fl;
-
-            return *this;
-        }
-
-        // Basic vector operations
-        [[nodiscard]] float DistTo(const Vector2& vOther) const
-        {
-            return std::sqrt(DistToSqr(vOther));
-        }
-
-        [[nodiscard]] constexpr float DistToSqr(const Vector2& vOther) const
-        {
-            return (x - vOther.x) * (x - vOther.x) + (y - vOther.y) * (y - vOther.y);
-        }
-
-        [[nodiscard]] constexpr float Dot(const Vector2& vOther) const
-        {
-            return x * vOther.x + y * vOther.y;
-        }
-
-#ifndef _MSC_VER
-        [[nodiscard]] constexpr float Length() const
-        {
-            return std::hypot(x, y);
-        }
-
-        [[nodiscard]] constexpr Vector2 Normalized() const
-        {
-            const float len = Length();
-            return len > 0.f ? *this / len : *this;
-        }
-#else
-        [[nodiscard]] float Length() const
-        {
-            return std::hypot(x, y);
-        }
-
-        [[nodiscard]] Vector2 Normalized() const
-        {
-            const float len = Length();
-            return len > 0.f ? *this / len : *this;
-        }
-#endif
-        [[nodiscard]] constexpr float LengthSqr() const
-        {
-            return x * x + y * y;
-        }
-
-        constexpr Vector2& Abs()
-        {
-            //FIXME: Replace with std::abs, if it will become constexprable
-            x = x < 0 ? -x : x;
-            y = y < 0 ? -y : y;
-            return *this;
-        }
-
-        template<class type>
-        [[nodiscard]] constexpr const type& As() const
-        {
-            return *reinterpret_cast<const type*>(this);
-        }
-        template<class type>
-        [[nodiscard]] constexpr type& As()
-        {
-            return *reinterpret_cast<type*>(this);
-        }
-
-        [[nodiscard]] constexpr Vector2 operator-() const
-        {
-            return {-x, -y};
-        }
-
-        // Binary arithmetic operators
-        [[nodiscard]] constexpr Vector2 operator+(const Vector2& v) const
-        {
-            return {x + v.x, y + v.y};
-        }
-
-        [[nodiscard]] constexpr Vector2 operator-(const Vector2& v) const
-        {
-            return {x - v.x, y - v.y};
-        }
-
-        [[nodiscard]] constexpr Vector2 operator*(const float fl) const
-        {
-            return {x * fl, y * fl};
-        }
-
-        [[nodiscard]] constexpr Vector2 operator/(const float fl) const
-        {
-            return {x / fl, y / fl};
-        }
-
-         // Sum of elements
-        [[nodiscard]] constexpr float Sum() const
-        {
-            return x + y;
-        }
-
-        [[nodiscard]]
-        constexpr std::tuple<float, float> AsTuple() const
-        {
-            return std::make_tuple(x, y);
-        }
-    };
-}

include/omath/Vector3.hpp

@@ -1,271 +0,0 @@
-//
-// Created by vlad on 10/28/23.
-//
-
-#pragma once
-
-#include <cstdint>
-#include <functional>
-#include "omath/Vector2.hpp"
-#include "omath/Angle.hpp"
-#include <expected>
-#include <immintrin.h>
-
-
-namespace omath
-{
-
-    enum class Vector3Error
-    {
-        IMPOSSIBLE_BETWEEN_ANGLE,
-    };
-
-    class Vector3 : public Vector2
-    {
-    public:
-        float z = 0.f;
-        constexpr Vector3(const float x, const float y, const float z) : Vector2(x, y), z(z) { }
-        constexpr Vector3() : Vector2() {};
-
-        [[nodiscard]] constexpr bool operator==(const Vector3& src) const
-        {
-            return Vector2::operator==(src) && (src.z == z);
-        }
-
-        [[nodiscard]] constexpr bool operator!=(const Vector3& src) const
-        {
-            return !(*this == src);
-        }
-
-        constexpr Vector3& operator+=(const Vector3& v)
-        {
-            Vector2::operator+=(v);
-            z += v.z;
-
-            return *this;
-        }
-
-        constexpr Vector3& operator-=(const Vector3& v)
-        {
-            Vector2::operator-=(v);
-            z -= v.z;
-
-            return *this;
-        }
-
-        constexpr Vector3& operator*=(const float fl)
-        {
-            Vector2::operator*=(fl);
-            z *= fl;
-
-            return *this;
-        }
-
-        constexpr Vector3& operator*=(const Vector3& v)
-        {
-            Vector2::operator*=(v);
-            z *= v.z;
-
-            return *this;
-        }
-
-        constexpr Vector3& operator/=(const Vector3& v)
-        {
-            Vector2::operator/=(v);
-            z /= v.z;
-
-            return *this;
-        }
-
-        constexpr Vector3& operator+=(const float fl)
-        {
-            Vector2::operator+=(fl);
-            z += fl;
-
-            return *this;
-        }
-
-        constexpr Vector3& operator/=(const float fl)
-        {
-            Vector2::operator/=(fl);
-            z /= fl;
-
-            return *this;
-        }
-
-        constexpr Vector3& operator-=(const float fl)
-        {
-            Vector2::operator-=(fl);
-            z -= fl;
-
-            return *this;
-        }
-
-        constexpr Vector3& Abs()
-        {
-            Vector2::Abs();
-            z = z < 0.f ? -z : z;
-
-            return *this;
-        }
-
-        [[nodiscard]] constexpr float DistToSqr(const Vector3& vOther) const
-        {
-            return (*this - vOther).LengthSqr();
-        }
-
-        [[nodiscard]] constexpr float Dot(const Vector3& vOther) const
-        {
-            return Vector2::Dot(vOther) + z * vOther.z;
-        }
-
-#ifndef _MSC_VER
-        [[nodiscard]] constexpr float Length() const
-        {
-            return std::hypot(x, y, z);
-        }
-
-        [[nodiscard]] constexpr float Length2D() const
-        {
-            return Vector2::Length();
-        }
-        [[nodiscard]] float DistTo(const Vector3& vOther) const
-        {
-            return (*this - vOther).Length();
-        }
-        [[nodiscard]] constexpr Vector3 Normalized() const
-        {
-            const float length = this->Length();
-
-            return length != 0 ? *this / length : *this;
-        }
-#else
-        [[nodiscard]] float Length() const
-        {
-            return std::hypot(x, y, z);
-        }
-
-        [[nodiscard]] Vector3 Normalized() const
-        {
-            const float length = this->Length();
-
-            return length != 0 ? *this / length : *this;
-        }
-
-        [[nodiscard]] float Length2D() const
-        {
-            return Vector2::Length();
-        }
-
-        [[nodiscard]] float DistTo(const Vector3& vOther) const
-        {
-            return (*this - vOther).Length();
-        }
-#endif
-
-
-        [[nodiscard]] constexpr float LengthSqr() const
-        {
-            return Vector2::LengthSqr() + z * z;
-        }
-
-        [[nodiscard]] constexpr Vector3 operator-() const
-        {
-            return {-x, -y, -z};
-        }
-
-        [[nodiscard]] constexpr Vector3 operator+(const Vector3& v) const
-        {
-            return {x + v.x, y + v.y, z + v.z};
-        }
-
-        [[nodiscard]] constexpr Vector3 operator-(const Vector3& v) const
-        {
-            return {x - v.x, y - v.y, z - v.z};
-        }
-
-        [[nodiscard]] constexpr Vector3 operator*(const float fl) const
-        {
-            return {x * fl, y * fl, z * fl};
-        }
-
-        [[nodiscard]] constexpr Vector3 operator*(const Vector3& v) const
-        {
-            return {x * v.x, y * v.y, z * v.z};
-        }
-
-        [[nodiscard]] constexpr Vector3 operator/(const float fl) const
-        {
-            return {x / fl, y / fl, z / fl};
-        }
-
-        [[nodiscard]] constexpr Vector3 operator/(const Vector3& v) const
-        {
-            return {x / v.x, y / v.y, z / v.z};
-        }
-
-        [[nodiscard]] constexpr Vector3 Cross(const Vector3 &v) const
-        {
-            return
-            {
-                y * v.z - z * v.y,
-                z * v.x - x * v.z,
-                x * v.y - y * v.x
-            };
-        }
-        [[nodiscard]] constexpr float Sum() const
-        {
-            return Sum2D() + z;
-        }
-
-        [[nodiscard]] std::expected<Angle<float, 0.f, 180.f, AngleFlags::Clamped>, Vector3Error>
-        AngleBetween(const Vector3& other) const
-        {
-            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));
-        }
-
-        [[nodiscard]] bool IsPerpendicular(const Vector3& other) const
-        {
-            if (const auto angle = AngleBetween(other))
-                return angle->AsDegrees() == 90.f;
-
-            return false;
-        }
-
-        [[nodiscard]] constexpr float Sum2D() const
-        {
-            return Vector2::Sum();
-        }
-
-        [[nodiscard]] Vector3 ViewAngleTo(const Vector3& other) const;
-
-        [[nodiscard]] constexpr std::tuple<float, float, float> AsTuple() const
-        {
-            return std::make_tuple(x, y, z);
-        }
-    };
-}
-// ReSharper disable once CppRedundantNamespaceDefinition
-namespace std
-{
-    template<>
-    struct hash<omath::Vector3>
-    {
-        std::size_t operator()(const omath::Vector3& vec) const noexcept
-        {
-            std::size_t hash = 0;
-            constexpr std::hash<float> hasher;
-
-            hash ^= hasher(vec.x) + 0x9e3779b9 + (hash<<6) + (hash>>2);
-            hash ^= hasher(vec.y) + 0x9e3779b9 + (hash<<6) + (hash>>2);
-            hash ^= hasher(vec.z) + 0x9e3779b9 + (hash<<6) + (hash>>2);
-
-            return hash;
-        }
-    };
-}

include/omath/Vector4.hpp

@@ -1,154 +0,0 @@
-//
-// Vector4.h
-//
-#pragma once
-
-#include <omath/Vector3.hpp>
-#include <algorithm>
-
-namespace omath
-{
-    class Vector4 : public Vector3
-    {
-    public:
-        float w;
-
-        constexpr Vector4(const float x, const float y, const float z, const float w) : Vector3(x, y, z), w(w) {}
-        constexpr Vector4() : Vector3(), w(0.f) {};
-
-        [[nodiscard]]
-        constexpr bool operator==(const Vector4& src) const
-        {
-            return Vector3::operator==(src) && w == src.w;
-        }
-
-        [[nodiscard]]
-        constexpr bool operator!=(const Vector4& src) const
-        {
-            return !(*this == src);
-        }
-
-        constexpr Vector4& operator+=(const Vector4& v)
-        {
-            Vector3::operator+=(v);
-            w += v.w;
-
-            return *this;
-        }
-
-        constexpr Vector4& operator-=(const Vector4& v)
-        {
-            Vector3::operator-=(v);
-            w -= v.w;
-
-            return *this;
-        }
-
-        constexpr Vector4& operator*=(const float scalar)
-        {
-            Vector3::operator*=(scalar);
-            w *= scalar;
-
-            return *this;
-        }
-
-        constexpr Vector4& operator*=(const Vector4& v)
-        {
-            Vector3::operator*=(v);
-            w *= v.w;
-
-            return *this;
-        }
-
-        constexpr Vector4& operator/=(const float scalar)
-        {
-            Vector3::operator/=(scalar);
-            w /= scalar;
-
-            return *this;
-        }
-
-        constexpr Vector4& operator/=(const Vector4& v)
-        {
-            Vector3::operator/=(v);
-            w /= v.w;
-            return *this;
-        }
-
-        [[nodiscard]] constexpr float LengthSqr() const
-        {
-            return Vector3::LengthSqr() + w * w;
-        }
-
-        [[nodiscard]] constexpr float Dot(const Vector4& vOther) const
-        {
-            return Vector3::Dot(vOther) + w * vOther.w;
-        }
-
-        [[nodiscard]] float Length() const;
-
-        constexpr Vector4& Abs()
-        {
-            Vector3::Abs();
-            w = w < 0.f ? -w : w;
-
-            return *this;
-        }
-        constexpr Vector4& Clamp(const float min, const float max)
-        {
-            x = std::clamp(x, min, max);
-            y = std::clamp(y, min, max);
-            z = std::clamp(z, min, max);
-
-            return *this;
-        }
-
-        [[nodiscard]]
-        constexpr Vector4 operator-() const
-        {
-            return {-x, -y, -z, -w};
-        }
-
-        [[nodiscard]]
-        constexpr Vector4 operator+(const Vector4& v) const
-        {
-            return {x + v.x, y + v.y, z + v.z, w + v.w};
-        }
-
-        [[nodiscard]]
-        constexpr Vector4 operator-(const Vector4& v) const
-        {
-            return {x - v.x, y - v.y, z - v.z, w - v.w};
-        }
-
-        [[nodiscard]]
-        constexpr Vector4 operator*(const float scalar) const
-        {
-            return {x * scalar, y * scalar, z * scalar, w * scalar};
-        }
-
-        [[nodiscard]]
-        constexpr Vector4 operator*(const Vector4& v) const
-        {
-            return {x * v.x, y * v.y, z * v.z, w * v.w};
-        }
-
-        [[nodiscard]]
-        constexpr Vector4 operator/(const float scalar) const
-        {
-            return {x / scalar, y / scalar, z / scalar, w / scalar};
-        }
-
-        [[nodiscard]]
-        constexpr Vector4 operator/(const Vector4& v) const
-        {
-            return {x / v.x, y / v.y, z / v.z, w / v.w};
-        }
-
-        [[nodiscard]]
-        constexpr float Sum() const
-        {
-            return Vector3::Sum() + w;
-        }
-    };
-}

include/omath/angle.hpp

@@ -3,8 +3,9 @@
 //
 
 #pragma once
-#include "omath/Angles.hpp"
+#include "omath/angles.hpp"
 #include <algorithm>
+#include <utility>
 
 namespace omath
 {
@@ -19,10 +20,10 @@ namespace omath
     class Angle
     {
         Type m_angle;
-        constexpr Angle(const Type& degrees)
+        constexpr explicit Angle(const Type& degrees) noexcept
         {
             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,75 +33,74 @@ namespace omath
                 std::unreachable();
             }
         }
+
     public:
         [[nodiscard]]
-        constexpr static Angle FromDegrees(const Type& degrees)
+        constexpr static Angle from_degrees(const Type& degrees) noexcept
         {
-            return {degrees};
+            return Angle{degrees};
         }
-        constexpr Angle() : m_angle(0)
+        constexpr Angle() noexcept: m_angle(0)
         {
-
         }
         [[nodiscard]]
-        constexpr static Angle FromRadians(const Type& degrees)
+        constexpr static Angle from_radians(const Type& degrees) noexcept
         {
-            return {angles::RadiansToDegrees<Type>(degrees)};
+            return Angle{angles::radians_to_degrees<Type>(degrees)};
         }
 
         [[nodiscard]]
-        constexpr const Type& operator*() const
+        constexpr const Type& operator*() const noexcept
         {
             return m_angle;
         }
 
         [[nodiscard]]
-        constexpr Type AsDegrees() const
+        constexpr Type as_degrees() const noexcept
         {
             return m_angle;
         }
 
         [[nodiscard]]
-        constexpr Type AsRadians() const
+        constexpr Type as_radians() const noexcept
         {
-            return angles::DegreesToRadians(m_angle);
+            return angles::degrees_to_radians(m_angle);
         }
 
         [[nodiscard]]
-        Type Sin() const
+        Type sin() const noexcept
         {
-            return std::sin(AsRadians());
+            return std::sin(as_radians());
         }
 
         [[nodiscard]]
-        Type Cos() const
+        Type cos() const noexcept
         {
-            return std::cos(AsRadians());
+            return std::cos(as_radians());
         }
 
         [[nodiscard]]
-        Type Tan() const
+        Type tan() const noexcept
         {
-            return std::tan(AsRadians());
+            return std::tan(as_radians());
         }
 
         [[nodiscard]]
-        Type Atan() const
+        Type atan() const noexcept
         {
-            return std::atan(AsRadians());
+            return std::atan(as_radians());
         }
 
         [[nodiscard]]
-        Type Cot() const
+        Type cot() const noexcept
         {
-            return Cos() / Sin();
+            return cos() / sin();
         }
 
-        [[nodiscard]]
+        constexpr Angle& operator+=(const Angle& other) noexcept
-        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);
@@ -114,19 +114,18 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr std::partial_ordering operator<=>(const Angle& other) const = default;
+        constexpr std::partial_ordering operator<=>(const Angle& other) const noexcept = default;
 
-        [[nodiscard]]
+        constexpr Angle& operator-=(const Angle& other) noexcept
-        constexpr Angle& operator-=(const Angle& other)
         {
             return operator+=(-other);
         }
 
         [[nodiscard]]
-        constexpr Angle& operator+(const Angle& other)
+        constexpr Angle& operator+(const Angle& other) noexcept
         {
             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)};
@@ -138,15 +137,15 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Angle& operator-(const Angle& other)
+        constexpr Angle& operator-(const Angle& other) noexcept
         {
             return operator+(-other);
         }
 
         [[nodiscard]]
-        constexpr Angle operator-() const
+        constexpr Angle operator-() const noexcept
         {
-            return {-m_angle};
+            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) noexcept
+    {
+        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) noexcept
+    {
+        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) noexcept
+    {
+        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) noexcept
+    {
+        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) noexcept
+    {
+        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/LineTracer.hpp

@@ -1,38 +0,0 @@
-//
-// Created by Orange on 11/13/2024.
-//
-#pragma once
-
-#include "omath/Vector3.hpp"
-#include "omath/Triangle.hpp"
-
-namespace omath::collision
-{
-    class Ray
-    {
-    public:
-        Vector3 start;
-        Vector3 end;
-
-        [[nodiscard]]
-        Vector3 DirectionVector() const;
-
-        [[nodiscard]]
-        Vector3 DirectionVectorNormalized() const;
-    };
-    class LineTracer
-    {
-    public:
-        LineTracer() = delete;
-
-
-        [[nodiscard]]
-        static bool CanTraceLine(const Ray& ray, const Triangle<Vector3>& triangle);
-
-
-        // Realization of Möller–Trumbore intersection algorithm
-        // https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
-        [[nodiscard]]
-        static Vector3 GetRayHitPoint(const Ray& ray, const Triangle<Vector3>& triangle);
-    };
-}

include/omath/collision/line_tracer.hpp

@@ -0,0 +1,37 @@
+//
+// Created by Orange on 11/13/2024.
+//
+#pragma once
+
+#include "omath/triangle.hpp"
+#include "omath/vector3.hpp"
+
+namespace omath::collision
+{
+    class Ray
+    {
+    public:
+        Vector3<float> start;
+        Vector3<float> end;
+        bool infinite_length = false;
+
+        [[nodiscard]]
+        Vector3<float> direction_vector() const noexcept;
+
+        [[nodiscard]]
+        Vector3<float> direction_vector_normalized() const noexcept;
+    };
+    class LineTracer
+    {
+    public:
+        LineTracer() = delete;
+
+        [[nodiscard]]
+        static bool can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
+
+        // Realization of Möller–Trumbore intersection algorithm
+        // https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
+        [[nodiscard]]
+        static Vector3<float> get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
+    };
+} // namespace omath::collision

include/omath/color.hpp

@@ -0,0 +1,177 @@
+//
+// 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) noexcept: Vector4(r, g, b, a)
+        {
+            clamp(0.f, 1.f);
+        }
+
+        constexpr explicit Color() noexcept = default;
+        [[nodiscard]]
+        constexpr static Color from_rgba(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a) noexcept
+        {
+            return Color{Vector4(r, g, b, a) / 255.f};
+        }
+
+        [[nodiscard]]
+        constexpr static Color from_hsv(float hue, const float saturation, const float value) noexcept
+        {
+            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) noexcept
+        {
+            return from_hsv(hsv.hue, hsv.saturation, hsv.value);
+        }
+
+        [[nodiscard]]
+        constexpr Hsv to_hsv() const noexcept
+        {
+            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) noexcept: Vector4(vec)
+        {
+            clamp(0.f, 1.f);
+        }
+        constexpr void set_hue(const float hue) noexcept
+        {
+            auto hsv = to_hsv();
+            hsv.hue = hue;
+
+            *this = from_hsv(hsv);
+        }
+
+        constexpr void set_saturation(const float saturation) noexcept
+        {
+            auto hsv = to_hsv();
+            hsv.saturation = saturation;
+
+            *this = from_hsv(hsv);
+        }
+
+        constexpr void set_value(const float value) noexcept
+        {
+            auto hsv = to_hsv();
+            hsv.value = value;
+
+            *this = from_hsv(hsv);
+        }
+        [[nodiscard]]
+        constexpr Color blend(const Color& other, float ratio) const noexcept
+        {
+            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};
+        }
+#ifdef OMATH_IMGUI_INTEGRATION
+        [[nodiscard]]
+        ImColor to_im_color() const noexcept
+        {
+            return {to_im_vec4()};
+        }
+#endif
+    };
+} // namespace omath

include/omath/engines/OpenGL/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
-{
-    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
-    {
-    public:
-        Camera(const Vector3& 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& target) override;
-        [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
-        [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
-    };
-}

include/omath/engines/OpenGL/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
-{
-    constexpr Vector3 kAbsUp = {0, 1, 0};
-    constexpr Vector3 kAbsRight = {1, 0, 0};
-    constexpr Vector3 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/Formulas.hpp

@@ -1,54 +0,0 @@
-//
-// Created by Orange on 12/23/2024.
-//
-#pragma once
-#include "Constants.hpp"
-
-
-namespace omath::opengl
-{
-    [[nodiscard]]
-    inline Vector3 ForwardVector(const ViewAngles& angles)
-    {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsForward);
-
-        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
-    }
-
-    [[nodiscard]]
-    inline Vector3 RightVector(const ViewAngles& angles)
-    {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsRight);
-
-        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
-    }
-
-    [[nodiscard]]
-    inline Vector3 UpVector(const ViewAngles& angles)
-    {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsUp);
-
-        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
-    }
-
-    [[nodiscard]] inline Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3& cam_origin)
-    {
-        return MatCameraView<float, MatStoreType::COLUMN_MAJOR>(-ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
-    }
-
-
-    [[nodiscard]]
-    inline 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},
-
-            };
-    }
-}

include/omath/engines/Source/Camera.hpp

@@ -1,19 +0,0 @@
-//
-// Created by Orange on 12/4/2024.
-//
-#pragma once
-#include "Constants.hpp"
-#include "omath/projection/Camera.hpp"
-
-namespace omath::source
-{
-    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
-    {
-    public:
-        Camera(const Vector3& 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& target) override;
-        [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
-        [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
-    };
-}

include/omath/engines/Source/Constants.hpp

@@ -1,24 +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
-{
-    constexpr Vector3 kAbsUp = {0, 0, 1};
-    constexpr Vector3 kAbsRight = {0, -1, 0};
-    constexpr Vector3 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/Formulas.hpp

@@ -1,57 +0,0 @@
-//
-// Created by Orange on 12/4/2024.
-//
-#pragma once
-#include "Constants.hpp"
-
-namespace omath::source
-{
-    [[nodiscard]]
-    inline Vector3 ForwardVector(const ViewAngles& angles)
-    {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsForward);
-
-        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
-    }
-
-    [[nodiscard]]
-    inline Vector3 RightVector(const ViewAngles& angles)
-    {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsRight);
-
-        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
-    }
-
-    [[nodiscard]]
-    inline Vector3 UpVector(const ViewAngles& angles)
-    {
-        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsUp);
-
-        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
-    }
-
-    [[nodiscard]] inline Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3& cam_origin)
-    {
-        return MatCameraView(ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
-    }
-
-
-    [[nodiscard]]
-    inline Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
-                                                  const float far)
-    {
-        // NOTE: Needed tp make thing draw normal, since source is wierd
-        // and use tricky projection matrix formula.
-        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

include/omath/engines/iw_engine/camera.hpp

@@ -0,0 +1,13 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+
+#pragma once
+#include "omath/engines/iw_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+#include "traits/camera_trait.hpp"
+
+namespace omath::iw_engine
+{
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+} // 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) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+} // namespace omath::iw_engine

include/omath/engines/iw_engine/traits/camera_trait.hpp

@@ -0,0 +1,24 @@
+//
+// Created by Vlad on 8/10/2025.
+//
+
+#pragma once
+#include "omath/engines/iw_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+
+namespace omath::iw_engine
+{
+    class CameraTrait final
+    {
+    public:
+        [[nodiscard]]
+        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+
+        [[nodiscard]]
+        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+        [[nodiscard]]
+        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+                                             float near, float far) noexcept;
+    };
+
+} // namespace omath::iw_engine

include/omath/engines/iw_engine/traits/pred_engine_trait.hpp

@@ -0,0 +1,79 @@
+//
+// Created by Vlad on 8/6/2025.
+//
+#pragma once
+
+#include "omath/engines/iw_engine/formulas.hpp"
+#include "omath/projectile_prediction/projectile.hpp"
+#include "omath/projectile_prediction/target.hpp"
+#include <optional>
+
+namespace omath::iw_engine
+{
+    class PredEngineTrait final
+    {
+    public:
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+                                                                    const float pitch, const float yaw,
+                                                                    const float time, const float gravity) noexcept
+        {
+            auto current_pos = projectile.m_origin
+                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
+                                                 RollAngle::from_degrees(0)})
+                                         * projectile.m_launch_speed * time;
+            current_pos.z -= (gravity * projectile.m_gravity_scale) * (time * time) * 0.5f;
+
+            return current_pos;
+        }
+        [[nodiscard]]
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+                                                                const float time, const float gravity) noexcept
+        {
+            auto predicted = target.m_origin + target.m_velocity * time;
+
+            if (target.m_is_airborne)
+                predicted.z -= gravity * (time * time) * 0.5f;
+
+            return predicted;
+        }
+        [[nodiscard]]
+        static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
+        {
+            return std::sqrt(delta.x * delta.x + delta.y * delta.y);
+        }
+
+        [[nodiscard]]
+        constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
+        {
+            return vec.z;
+        }
+
+        [[nodiscard]]
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+                                                         Vector3<float> predicted_target_position,
+                                                         const std::optional<float> projectile_pitch) noexcept
+        {
+            const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
+            const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
+
+            return {predicted_target_position.x, predicted_target_position.y, projectile.m_origin.z + height};
+        }
+        // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
+        // 89 look up, -89 look down
+        [[nodiscard]]
+        static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto distance = origin.distance_to(view_to);
+            const auto delta = view_to - origin;
+
+            return angles::radians_to_degrees(std::asin(delta.z / distance));
+        }
+        [[nodiscard]]
+        static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto delta = view_to - origin;
+
+            return angles::radians_to_degrees(std::atan2(delta.y, delta.x));
+        };
+    };
+} // namespace omath::iw_engine

include/omath/engines/opengl_engine/camera.hpp

@@ -0,0 +1,12 @@
+//
+// Created by Orange on 12/23/2024.
+//
+#pragma once
+#include "omath/engines/opengl_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+#include "traits/camera_trait.hpp"
+
+namespace omath::opengl_engine
+{
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+} // 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) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+} // namespace omath::opengl_engine

include/omath/engines/opengl_engine/traits/camera_trait.hpp

@@ -0,0 +1,24 @@
+//
+// Created by Vlad on 8/10/2025.
+//
+
+#pragma once
+#include "omath/engines/opengl_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+
+namespace omath::opengl_engine
+{
+    class CameraTrait final
+    {
+    public:
+        [[nodiscard]]
+        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+
+        [[nodiscard]]
+        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+        [[nodiscard]]
+        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+                                             float near, float far) noexcept;
+    };
+
+} // namespace omath::opengl_engine

include/omath/engines/opengl_engine/traits/pred_engine_trait.hpp

@@ -0,0 +1,78 @@
+//
+// Created by Vlad on 8/6/2025.
+//
+#pragma once
+#include "omath/engines/opengl_engine/formulas.hpp"
+#include "omath/projectile_prediction/projectile.hpp"
+#include "omath/projectile_prediction/target.hpp"
+#include <optional>
+
+namespace omath::opengl_engine
+{
+    class PredEngineTrait final
+    {
+    public:
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+                                                                    const float pitch, const float yaw,
+                                                                    const float time, const float gravity) noexcept
+        {
+            auto current_pos = projectile.m_origin
+                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
+                                                 RollAngle::from_degrees(0)})
+                                         * projectile.m_launch_speed * time;
+            current_pos.y -= (gravity * projectile.m_gravity_scale) * (time * time) * 0.5f;
+
+            return current_pos;
+        }
+        [[nodiscard]]
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+                                                                const float time, const float gravity) noexcept
+        {
+            auto predicted = target.m_origin + target.m_velocity * time;
+
+            if (target.m_is_airborne)
+                predicted.y -= gravity * (time * time) * 0.5f;
+
+            return predicted;
+        }
+        [[nodiscard]]
+        static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
+        {
+            return std::sqrt(delta.x * delta.x + delta.z * delta.z);
+        }
+
+        [[nodiscard]]
+        constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
+        {
+            return vec.y;
+        }
+
+        [[nodiscard]]
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+                                                         Vector3<float> predicted_target_position,
+                                                         const std::optional<float> projectile_pitch) noexcept
+        {
+            const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
+            const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
+
+            return {predicted_target_position.x, predicted_target_position.y + height, projectile.m_origin.z};
+        }
+        // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
+        // 89 look up, -89 look down
+        [[nodiscard]]
+        static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto distance = origin.distance_to(view_to);
+            const auto delta = view_to - origin;
+
+            return angles::radians_to_degrees(std::asin(delta.y / distance));
+        }
+        [[nodiscard]]
+        static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto delta = view_to - origin;
+
+            return angles::radians_to_degrees(std::atan2(delta.z, delta.x));
+        };
+    };
+} // namespace omath::opengl_engine

include/omath/engines/source_engine/camera.hpp

@@ -0,0 +1,11 @@
+//
+// Created by Orange on 12/4/2024.
+//
+#pragma once
+#include "omath/engines/source_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+#include "traits/camera_trait.hpp"
+namespace omath::source_engine
+{
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+} // 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) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+} // namespace omath::source_engine

include/omath/engines/source_engine/traits/camera_trait.hpp

@@ -0,0 +1,24 @@
+//
+// Created by Vlad on 8/10/2025.
+//
+
+#pragma once
+#include "omath/engines/source_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+
+namespace omath::source_engine
+{
+    class CameraTrait final
+    {
+    public:
+        [[nodiscard]]
+        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+
+        [[nodiscard]]
+        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+        [[nodiscard]]
+        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+                                             float near, float far) noexcept;
+    };
+
+} // namespace omath::source_engine

include/omath/engines/source_engine/traits/pred_engine_trait.hpp

@@ -0,0 +1,79 @@
+//
+// Created by Vlad on 8/3/2025.
+//
+
+#pragma once
+#include "omath/engines/source_engine/formulas.hpp"
+#include "omath/projectile_prediction/projectile.hpp"
+#include "omath/projectile_prediction/target.hpp"
+#include <optional>
+
+namespace omath::source_engine
+{
+    class PredEngineTrait final
+    {
+    public:
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+                                                                    const float pitch, const float yaw,
+                                                                    const float time, const float gravity) noexcept
+        {
+            auto current_pos = projectile.m_origin
+                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
+                                                 RollAngle::from_degrees(0)})
+                                         * projectile.m_launch_speed * time;
+            current_pos.z -= (gravity * projectile.m_gravity_scale) * (time * time) * 0.5f;
+
+            return current_pos;
+        }
+        [[nodiscard]]
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+                                                                const float time, const float gravity) noexcept
+        {
+            auto predicted = target.m_origin + target.m_velocity * time;
+
+            if (target.m_is_airborne)
+                predicted.z -= gravity * (time * time) * 0.5f;
+
+            return predicted;
+        }
+        [[nodiscard]]
+        static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
+        {
+            return std::sqrt(delta.x * delta.x + delta.y * delta.y);
+        }
+
+        [[nodiscard]]
+        constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
+        {
+            return vec.z;
+        }
+
+        [[nodiscard]]
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+                                                         Vector3<float> predicted_target_position,
+                                                         const std::optional<float> projectile_pitch) noexcept
+        {
+            const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
+            const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
+
+            return {predicted_target_position.x, predicted_target_position.y, projectile.m_origin.z + height};
+        }
+        // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
+        // 89 look up, -89 look down
+        [[nodiscard]]
+        static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto distance = origin.distance_to(view_to);
+            const auto delta = view_to - origin;
+
+            return angles::radians_to_degrees(std::asin(delta.z / distance));
+        }
+        [[nodiscard]]
+        static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto delta = view_to - origin;
+
+            return angles::radians_to_degrees(std::atan2(delta.y, delta.x));
+        };
+    };
+} // namespace omath::source_engine

include/omath/engines/unity_engine/camera.hpp

@@ -0,0 +1,13 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+
+#pragma once
+#include "omath/engines/unity_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+#include "traits/camera_trait.hpp"
+
+namespace omath::unity_engine
+{
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+} // 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) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+} // namespace omath::unity_engine

include/omath/engines/unity_engine/traits/camera_trait.hpp

@@ -0,0 +1,24 @@
+//
+// Created by Vlad on 8/10/2025.
+//
+
+#pragma once
+#include "omath/engines/unity_engine/formulas.hpp"
+#include "omath/projection/camera.hpp"
+
+namespace omath::unity_engine
+{
+    class CameraTrait final
+    {
+    public:
+        [[nodiscard]]
+        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+
+        [[nodiscard]]
+        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+        [[nodiscard]]
+        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+                                             float near, float far) noexcept;
+    };
+
+} // namespace omath::unity_engine

include/omath/engines/unity_engine/traits/pred_engine_trait.hpp

@@ -0,0 +1,78 @@
+//
+// Created by Vlad on 8/6/2025.
+//
+#pragma once
+#include "omath/engines/unity_engine/formulas.hpp"
+#include "omath/projectile_prediction/projectile.hpp"
+#include "omath/projectile_prediction/target.hpp"
+#include <optional>
+
+namespace omath::unity_engine
+{
+    class PredEngineTrait final
+    {
+    public:
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+                                                                    const float pitch, const float yaw,
+                                                                    const float time, const float gravity) noexcept
+        {
+            auto current_pos = projectile.m_origin
+                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
+                                                 RollAngle::from_degrees(0)})
+                                         * projectile.m_launch_speed * time;
+            current_pos.y -= (gravity * projectile.m_gravity_scale) * (time * time) * 0.5f;
+
+            return current_pos;
+        }
+        [[nodiscard]]
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+                                                                const float time, const float gravity) noexcept
+        {
+            auto predicted = target.m_origin + target.m_velocity * time;
+
+            if (target.m_is_airborne)
+                predicted.y -= gravity * (time * time) * 0.5f;
+
+            return predicted;
+        }
+        [[nodiscard]]
+        static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
+        {
+            return std::sqrt(delta.x * delta.x + delta.z * delta.z);
+        }
+
+        [[nodiscard]]
+        constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
+        {
+            return vec.y;
+        }
+
+        [[nodiscard]]
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+                                                         Vector3<float> predicted_target_position,
+                                                         const std::optional<float> projectile_pitch) noexcept
+        {
+            const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
+            const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
+
+            return {predicted_target_position.x, predicted_target_position.y + height, projectile.m_origin.z};
+        }
+        // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
+        // 89 look up, -89 look down
+        [[nodiscard]]
+        static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto distance = origin.distance_to(view_to);
+            const auto delta = view_to - origin;
+
+            return angles::radians_to_degrees(std::asin(delta.y / distance));
+        }
+        [[nodiscard]]
+        static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto delta = view_to - origin;
+
+            return angles::radians_to_degrees(std::atan2(delta.z, delta.x));
+        };
+    };
+} // namespace omath::unity_engine

include/omath/mat.hpp

@@ -0,0 +1,482 @@
+//
+// 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>
+
+#ifdef near
+#undef near
+#endif
+
+#ifdef far
+#undef far
+#endif
+
+namespace omath
+{
+    struct MatSize
+    {
+        size_t rows, columns;
+    };
+
+    enum class MatStoreType : uint8_t
+    {
+        ROW_MAJOR = 0,
+        COLUMN_MAJOR
+    };
+
+    template<typename M1, typename M2> concept MatTemplateEqual
+            = (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>
+    class Mat final
+    {
+    public:
+        constexpr Mat() noexcept
+        {
+            clear();
+        }
+
+        [[nodiscard]]
+        constexpr static MatStoreType get_store_ordering() noexcept
+        {
+            return StoreType;
+        }
+        constexpr Mat(const std::initializer_list<std::initializer_list<Type>>& rows)
+        {
+            if (rows.size() != Rows)
+                throw std::invalid_argument("Initializer list rows size does not match template parameter Rows");
+
+            auto row_it = rows.begin();
+            for (size_t i = 0; i < Rows; ++i, ++row_it)
+            {
+                if (row_it->size() != Columns)
+                    throw std::invalid_argument(
+                            "All rows must have the same number of columns as template parameter Columns");
+
+                auto col_it = row_it->begin();
+                for (size_t j = 0; j < Columns; ++j, ++col_it)
+                {
+                    at(i, j) = std::move(*col_it);
+                }
+            }
+        }
+
+        constexpr explicit Mat(const Type* raw_data)
+        {
+            std::copy_n(raw_data, Rows * Columns, m_data.begin());
+        }
+
+        constexpr Mat(const Mat& other) noexcept
+        {
+            m_data = other.m_data;
+        }
+
+        [[nodiscard]]
+        constexpr Type& operator[](const size_t row, const size_t 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
+        {
+            m_data = std::move(other.m_data);
+        }
+
+        [[nodiscard]]
+        static constexpr size_t row_count() noexcept
+        {
+            return Rows;
+        }
+
+        [[nodiscard]]
+        static constexpr size_t columns_count() noexcept
+        {
+            return Columns;
+        }
+
+        [[nodiscard]]
+        static consteval MatSize size() noexcept
+        {
+            return {Rows, Columns};
+        }
+
+        [[nodiscard]]
+        constexpr const Type& at(const size_t row_index, const size_t column_index) const
+        {
+#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[row_index * Columns + column_index];
+
+            else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
+                return m_data[row_index + column_index * Rows];
+
+            else
+            {
+                static_assert(false, "Invalid matrix access convention");
+                std::unreachable();
+            }
+        }
+
+        [[nodiscard]] constexpr Type& at(const size_t row_index, const size_t column_index)
+        {
+            return const_cast<Type&>(std::as_const(*this).at(row_index, column_index));
+        }
+
+        [[nodiscard]]
+        constexpr Type sum() const noexcept
+        {
+            return std::accumulate(m_data.begin(), m_data.end(), static_cast<Type>(0));
+        }
+
+        constexpr void clear() noexcept
+        {
+            set(static_cast<Type>(0));
+        }
+
+        constexpr void set(const Type& value) noexcept
+        {
+            std::ranges::fill(m_data, value);
+        }
+
+        // Operator overloading for multiplication with another Mat
+        template<size_t OtherColumns> [[nodiscard]]
+        constexpr Mat<Rows, OtherColumns, Type, StoreType>
+        operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
+        {
+            Mat<Rows, OtherColumns, Type, StoreType> result;
+
+            for (size_t i = 0; i < Rows; ++i)
+                for (size_t j = 0; j < OtherColumns; ++j)
+                {
+                    Type sum = 0;
+                    for (size_t k = 0; k < Columns; ++k)
+                        sum += at(i, k) * other.at(k, j);
+                    result.at(i, j) = sum;
+                }
+            return result;
+        }
+
+        constexpr Mat& operator*=(const Type& f) noexcept
+        {
+            std::ranges::for_each(m_data, [&f](auto& val) { val *= f; });
+            return *this;
+        }
+
+        template<size_t OtherColumns> constexpr Mat<Rows, OtherColumns, Type, StoreType>
+        operator*=(const Mat<Columns, OtherColumns, Type, StoreType>& other)
+        {
+            return *this = *this * other;
+        }
+
+        [[nodiscard]]
+        constexpr Mat operator*(const Type& value) const noexcept
+        {
+            Mat result(*this);
+            result *= value;
+            return result;
+        }
+
+        constexpr Mat& operator/=(const Type& value) noexcept
+        {
+            std::ranges::for_each(m_data, [&value](auto& val) { val /= value; });
+            return *this;
+        }
+
+        [[nodiscard]]
+        constexpr Mat operator/(const Type& value) const noexcept
+        {
+            Mat result(*this);
+            result /= value;
+            return result;
+        }
+
+        constexpr Mat& operator=(const Mat& other) noexcept
+        {
+            if (this != &other)
+                m_data = other.m_data;
+
+            return *this;
+        }
+
+        constexpr Mat& operator=(Mat&& other) noexcept
+        {
+            if (this != &other)
+                m_data = std::move(other.m_data);
+
+            return *this;
+        }
+
+        [[nodiscard]]
+        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);
+
+            return transposed;
+        }
+
+        [[nodiscard]]
+        constexpr Type determinant() const
+        {
+            static_assert(Rows == Columns, "Determinant is only defined for square matrices.");
+
+            if constexpr (Rows == 1)
+                return at(0, 0);
+
+            if constexpr (Rows == 2)
+                return at(0, 0) * at(1, 1) - at(0, 1) * at(1, 0);
+
+            if constexpr (Rows > 2)
+            {
+                Type det = 0;
+                for (size_t column = 0; column < Columns; ++column)
+                {
+                    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> 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)
+            {
+                if (i == row)
+                    continue;
+                for (size_t j = 0, n = 0; j < Columns; ++j)
+                {
+                    if (j == column)
+                        continue;
+                    result.at(m, n) = at(i, j);
+                    ++n;
+                }
+                ++m;
+            }
+            return result;
+        }
+
+        [[nodiscard]]
+        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>& raw_array()
+        {
+            return m_data;
+        }
+
+        [[nodiscard]]
+        std::string to_string() const noexcept
+        {
+            std::ostringstream oss;
+            oss << "[[";
+
+            for (size_t i = 0; i < Rows; ++i)
+            {
+                if (i > 0)
+                    oss << " [";
+
+                for (size_t j = 0; j < Columns; ++j)
+                {
+                    oss << std::setw(9) << std::fixed << std::setprecision(3) << at(i, j);
+                    if (j != Columns - 1)
+                        oss << ", ";
+                }
+                oss << (i == Rows - 1 ? "]]" : "]\n");
+            }
+            return oss.str();
+        }
+
+        [[nodiscard]]
+        bool operator==(const Mat& mat) const
+        {
+            return m_data == mat.m_data;
+        }
+
+        [[nodiscard]]
+        bool operator!=(const Mat& mat) const
+        {
+            return !operator==(mat);
+        }
+
+        // Static methods that return fixed-size matrices
+        [[nodiscard]]
+        constexpr static Mat<4, 4> to_screen_mat(const Type& screen_width, const Type& screen_height) noexcept
+        {
+            return {
+                    {screen_width / 2, 0, 0, 0},
+                    {0, -screen_height / 2, 0, 0},
+                    {0, 0, 1, 0},
+                    {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> [[nodiscard]]
+    constexpr static Mat<1, 4, Type, St> mat_row_from_vector(const Vector3<Type>& vector) noexcept
+    {
+        return {{vector.x, vector.y, vector.z, 1}};
+    }
+
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard]]
+    constexpr static Mat<4, 1, Type, St> mat_column_from_vector(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> mat_translation(const Vector3<Type>& diff) noexcept
+    {
+        return
+        {
+                {1, 0, 0, diff.x},
+                {0, 1, 0, diff.y},
+                {0, 0, 1, diff.z},
+                {0, 0, 0, 1},
+        };
+    }
+
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
+    [[nodiscard]]
+    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.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> mat_rotation_axis_y(const Angle& angle) noexcept
+    {
+        return
+        {
+            {angle.cos(),  0, angle.sin(), 0},
+            {0           , 1,           0, 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> mat_rotation_axis_z(const Angle& angle) noexcept
+    {
+        return
+        {
+            {angle.cos(), -angle.sin(), 0, 0},
+            {angle.sin(),  angle.cos(), 0, 0},
+            {          0,        0,     1, 0},
+            {          0,        0,     0, 1},
+        };
+    }
+
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    [[nodiscard]]
+    static Mat<4, 4, Type, St> mat_camera_view(const Vector3<Type>& forward, const Vector3<Type>& right,
+                                               const Vector3<Type>& up, const Vector3<Type>& camera_origin) noexcept
+    {
+        return  Mat<4, 4, Type, St>
+        {
+            {right.x,   right.y,   right.z,   0},
+            {up.x,      up.y,      up.z,      0},
+            {forward.x, forward.y, forward.z, 0},
+            {0,         0,         0,         1},
+        } * mat_translation<Type, St>(-camera_origin);
+    }
+
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    [[nodiscard]]
+    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
+    {
+        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,11 +1,14 @@
 #pragma once
+
+#ifdef OMATH_ENABLE_LEGACY
+
+#include "omath/vector3.hpp"
 #include <initializer_list>
 #include <memory>
 #include <string>
 
 namespace omath
 {
-    class Vector3;
 
     class Matrix final
     {
@@ -16,51 +19,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& diff);
+        static Matrix translation_matrix(const Vector3<float>& diff);
 
         [[nodiscard]]
-        static Matrix OrientationMatrix(const Vector3& forward, const Vector3& right, const Vector3& 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 +75,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 +99,7 @@ namespace omath
         Matrix operator/(float f) const;
 
         [[nodiscard]]
-        std::string ToString() const;
+        std::string to_string() const;
 
         ~Matrix();
 
@@ -106,3 +109,4 @@ namespace omath
         std::unique_ptr<float[]> m_data;
     };
 } // namespace omath
+#endif

include/omath/pathfinding/Astar.hpp

@@ -1,19 +0,0 @@
-//
-// Created by Vlad on 28.07.2024.
-//
-
-#pragma once
-#include <vector>
-#include "NavigationMesh.hpp"
-#include "omath/Vector3.hpp"
-
-namespace omath::pathfinding
-{
-    class Astar final
-    {
-    public:
-        [[nodiscard]]
-        static std::vector<Vector3> FindPath(const Vector3& start, const Vector3& end, const NavigationMesh& navMesh);
-
-    };
-}

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, std::string> GetClosestVertex(const Vector3& point) const;
-
-
-        [[nodiscard]]
-        const std::vector<Vector3>& GetNeighbors(const Vector3& 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, std::vector<Vector3>> 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) noexcept;
+
+    private:
+        [[nodiscard]]
+        static std::vector<Vector3<float>>
+        reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
+                               const Vector3<float>& current) noexcept;
+
+        [[nodiscard]]
+        static auto get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
+                                     const Vector3<float>& end_vertex) noexcept;
+    };
+} // namespace omath::pathfinding

include/omath/pathfinding/navigation_mesh.hpp

@@ -0,0 +1,37 @@
+//
+// 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 noexcept;
+
+        [[nodiscard]]
+        const std::vector<Vector3<float>>& get_neighbors(const Vector3<float>& vertex) const noexcept;
+
+        [[nodiscard]]
+        bool empty() const;
+
+        [[nodiscard]] std::vector<uint8_t> serialize() const noexcept;
+
+        void deserialize(const std::vector<uint8_t>& raw) noexcept;
+
+        std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_vertex_map;
+    };
+} // namespace omath::pathfinding

include/omath/prediction/Engine.hpp

@@ -1,38 +0,0 @@
-//
-// Created by Vlad on 6/9/2024.
-//
-
-#pragma once
-
-#include <optional>
-#include "omath/Vector3.hpp"
-#include "omath/prediction/Projectile.hpp"
-#include "omath/prediction/Target.hpp"
-
-namespace omath::prediction
-{
-    class Engine final
-    {
-    public:
-        explicit Engine(float gravityConstant, float simulationTimeStep,
-                        float maximumSimulationTime, float distanceTolerance);
-
-        [[nodiscard]]
-        std::optional<Vector3> MaybeCalculateAimPoint(const Projectile& projectile, const Target& target) const;
-
-    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& targetPosition) const;
-
-
-        [[nodiscard]]
-        bool IsProjectileReachedTarget(const Vector3& targetPosition, const Projectile& projectile, float pitch, float time) const;
-
-    };
-}

include/omath/prediction/Projectile.hpp

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

include/omath/prediction/Target.hpp

@@ -1,29 +0,0 @@
-//
-// Created by Vlad on 6/9/2024.
-//
-
-#pragma once
-#include "omath/Vector3.hpp"
-
-namespace omath::prediction
-{
-    class Target final
-    {
-    public:
-
-        [[nodiscard]]
-        constexpr Vector3 PredictPosition(const float time, const float gravity) const
-        {
-            auto predicted = m_origin + m_velocity * time;
-
-            if (m_isAirborne)
-                predicted.z -= gravity * std::pow(time, 2.f) * 0.5f;
-
-            return predicted;
-        }
-
-        Vector3 m_origin;
-        Vector3 m_velocity;
-        bool m_isAirborne{};
-    };
-}

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 ProjPredEngineInterface
+    {
+    public:
+        [[nodiscard]]
+        virtual std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
+                                                                        const Target& target) const = 0;
+        virtual ~ProjPredEngineInterface() = 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 ProjPredEngineInterface
+    {
+    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,109 @@
+//
+// Created by Vlad on 6/9/2024.
+//
+
+#pragma once
+
+#include "omath/engines/source_engine/traits/pred_engine_trait.hpp"
+#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
+{
+    template<class EngineTrait = source_engine::PredEngineTrait>
+    class ProjPredEngineLegacy final : public ProjPredEngineInterface
+    {
+    public:
+        explicit ProjPredEngineLegacy(const float gravity_constant, const float simulation_time_step,
+                                      const float maximum_simulation_time, const float distance_tolerance)
+            : m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),
+              m_maximum_simulation_time(maximum_simulation_time), m_distance_tolerance(distance_tolerance)
+        {
+        }
+
+        [[nodiscard]]
+        std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
+                                                                const Target& target) const override
+        {
+            for (float time = 0.f; time < m_maximum_simulation_time; time += m_simulation_time_step)
+            {
+                const auto predicted_target_position =
+                        EngineTrait::predict_target_position(target, time, m_gravity_constant);
+
+                const auto projectile_pitch =
+                        maybe_calculate_projectile_launch_pitch_angle(projectile, predicted_target_position);
+
+                if (!projectile_pitch.has_value()) [[unlikely]]
+                    continue;
+
+                if (!is_projectile_reached_target(predicted_target_position, projectile, projectile_pitch.value(),
+                                                  time))
+                    continue;
+
+                return EngineTrait::calc_viewpoint_from_angles(projectile, predicted_target_position, projectile_pitch);
+            }
+            return std::nullopt;
+        }
+
+    private:
+        const float m_gravity_constant;
+        const float m_simulation_time_step;
+        const float m_maximum_simulation_time;
+        const float m_distance_tolerance;
+
+        // Realization of this formula:
+        // https://stackoverflow.com/questions/54917375/how-to-calculate-the-angle-to-shoot-a-bullet-in-order-to-hit-a-moving-target
+        /*
+        \[
+        \theta \;=\; \arctan\!\Biggl(
+        \frac{%
+        v^{2}\;\pm\;\sqrt{\,v^{4}-g\!\left(gx^{2}+2yv^{2}\right)\,}
+        }{%
+        gx
+       }\Biggr)
+       \]
+        */
+        [[nodiscard]]
+        std::optional<float>
+        maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
+                                                      const Vector3<float>& target_position) const noexcept
+        {
+            const auto bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
+
+            if (bullet_gravity == 0.f)
+                return EngineTrait::calc_direct_pitch_angle(projectile.m_origin, target_position);
+
+            const auto delta = target_position - projectile.m_origin;
+
+            const auto distance2d = EngineTrait::calc_vector_2d_distance(delta);
+            const auto distance2d_sqr = distance2d * distance2d;
+            const auto launch_speed_sqr = projectile.m_launch_speed * projectile.m_launch_speed;
+
+            float root = launch_speed_sqr * launch_speed_sqr
+                         - bullet_gravity
+                                   * (bullet_gravity * distance2d_sqr
+                                      + 2.0f * EngineTrait::get_vector_height_coordinate(delta) * launch_speed_sqr);
+
+            if (root < 0.0f) [[unlikely]]
+                return std::nullopt;
+
+            root = std::sqrt(root);
+            const float angle = std::atan((launch_speed_sqr - root) / (bullet_gravity * distance2d));
+
+            return angles::radians_to_degrees(angle);
+        }
+        [[nodiscard]]
+        bool is_projectile_reached_target(const Vector3<float>& target_position, const Projectile& projectile,
+                                          const float pitch, const float time) const noexcept
+        {
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin, target_position);
+            const auto projectile_position =
+                    EngineTrait::predict_projectile_position(projectile, pitch, yaw, time, m_gravity_constant);
+
+            return projectile_position.distance_to(target_position) <= m_distance_tolerance;
+        }
+    };
+} // namespace omath::projectile_prediction

include/omath/projectile_prediction/projectile.hpp

@@ -0,0 +1,17 @@
+//
+// Created by Vlad on 6/9/2024.
+//
+
+#pragma once
+#include "omath/vector3.hpp"
+
+namespace omath::projectile_prediction
+{
+    class Projectile final
+    {
+    public:
+        Vector3<float> m_origin;
+        float m_launch_speed{};
+        float m_gravity_scale{};
+    };
+} // namespace omath::projectile_prediction

include/omath/projectile_prediction/target.hpp

@@ -0,0 +1,17 @@
+//
+// Created by Vlad on 6/9/2024.
+//
+
+#pragma once
+#include "omath/vector3.hpp"
+
+namespace omath::projectile_prediction
+{
+    class Target final
+    {
+    public:
+        Vector3<float> m_origin;
+        Vector3<float> m_velocity;
+        bool m_is_airborne{};
+    };
+} // namespace omath::projectile_prediction

include/omath/projection/Camera.hpp

@@ -1,156 +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& 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)
-        {
-
-        }
-
-        virtual void LookAt(const Vector3& target) = 0;
-
-        [[nodiscard]] virtual Mat4x4Type CalcViewMatrix() const = 0;
-
-        [[nodiscard]] virtual Mat4x4Type CalcProjectionMatrix() const = 0;
-
-        [[nodiscard]] Mat4x4Type CalcViewProjectionMatrix() const
-        {
-            return CalcProjectionMatrix() * CalcViewMatrix();
-        }
-
-        void SetFieldOfView(const FieldOfView& fov)
-        {
-            m_fieldOfView = fov;
-            m_viewProjectionMatrix = CalcViewProjectionMatrix();
-        }
-
-        void SetNearPlane(const float near)
-        {
-            m_nearPlaneDistance = near;
-            m_viewProjectionMatrix = CalcViewProjectionMatrix();
-        }
-
-        void SetFarPlane(const float far)
-        {
-            m_farPlaneDistance = far;
-            m_viewProjectionMatrix = CalcViewProjectionMatrix();
-        }
-
-        void SetViewAngles(const ViewAnglesType& viewAngles)
-        {
-            m_viewAngles = viewAngles;
-            m_viewProjectionMatrix = CalcViewProjectionMatrix();
-        }
-
-        void SetOrigin(const Vector3& origin)
-        {
-            m_origin = origin;
-            m_viewProjectionMatrix = CalcViewProjectionMatrix();
-        }
-
-        void SetViewPort(const ViewPort& viewPort)
-        {
-            m_viewPort = viewPort;
-            m_viewProjectionMatrix = CalcViewProjectionMatrix();
-        }
-
-        [[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& GetOrigin() const
-        {
-            return m_origin;
-        }
-
-        [[nodiscard]] std::expected<Vector3, Error> WorldToScreen(const Vector3& worldPosition) const
-        {
-            if (!m_viewProjectionMatrix.has_value())
-                m_viewProjectionMatrix = CalcViewProjectionMatrix();
-
-            auto projected = m_viewProjectionMatrix.value() * 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 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,176 @@
+//
+// 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 TraitClass>
+    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) noexcept
+            : 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:
+        void look_at(const Vector3<float>& target)
+        {
+            m_view_angles = TraitClass::calc_look_at_angle(m_origin, target);
+        }
+
+        [[nodiscard]] Mat4X4Type calc_view_projection_matrix() const noexcept
+        {
+            return TraitClass::calc_projection_matrix(m_field_of_view, m_view_port, m_near_plane_distance,
+                                                      m_far_plane_distance)
+                   * TraitClass::calc_view_matrix(m_view_angles, m_origin);
+        }
+
+    public:
+        [[nodiscard]] const Mat4X4Type& get_view_projection_matrix() const noexcept
+        {
+            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) noexcept
+        {
+            m_field_of_view = fov;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        void set_near_plane(const float near) noexcept
+        {
+            m_near_plane_distance = near;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        void set_far_plane(const float far) noexcept
+        {
+            m_far_plane_distance = far;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        void set_view_angles(const ViewAnglesType& view_angles) noexcept
+        {
+            m_view_angles = view_angles;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        void set_origin(const Vector3<float>& origin) noexcept
+        {
+            m_origin = origin;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        void set_view_port(const ViewPort& view_port) noexcept
+        {
+            m_view_port = view_port;
+            m_view_projection_matrix = std::nullopt;
+        }
+
+        [[nodiscard]] const FieldOfView& get_field_of_view() const noexcept
+        {
+            return m_field_of_view;
+        }
+
+        [[nodiscard]] const float& get_near_plane() const noexcept
+        {
+            return m_near_plane_distance;
+        }
+
+        [[nodiscard]] const float& get_far_plane() const noexcept
+        {
+            return m_far_plane_distance;
+        }
+
+        [[nodiscard]] const ViewAnglesType& get_view_angles() const noexcept
+        {
+            return m_view_angles;
+        }
+
+        [[nodiscard]] const Vector3<float>& get_origin() const noexcept
+        {
+            return m_origin;
+        }
+
+        [[nodiscard]] std::expected<Vector3<float>, Error>
+        world_to_screen(const Vector3<float>& world_position) const noexcept
+        {
+            auto normalized_cords = world_to_view_port(world_position);
+
+            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 noexcept
+        {
+            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) noexcept
+        {
+            return std::ranges::any_of(ndc.raw_array(), [](const auto& val) { return val < -1 || val > 1; });
+        }
+
+        [[nodiscard]] Vector3<float> ndc_to_screen_position(const Vector3<float>& ndc) const noexcept
+        {
+            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,85 @@
+//
+// Created by Orange on 11/13/2024.
+//
+#pragma once
+#include "omath/vector3.hpp"
+
+namespace omath
+{
+    /*
+    v1
+    |\
+    | \
+  a |  \ hypot
+    |   \
+ v2 ----- v3
+      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

@@ -0,0 +1,212 @@
+//
+// Created by Vlad on 02.09.2024.
+//
+
+#pragma once
+#include <cmath>
+#include <tuple>
+
+#ifdef OMATH_IMGUI_INTEGRATION
+#include <imgui.h>
+#endif
+
+namespace omath
+{
+
+    template<class Type>
+    requires std::is_arithmetic_v<Type>
+    class Vector2
+    {
+    public:
+        Type x = static_cast<Type>(0);
+        Type y = static_cast<Type>(0);
+
+        // Constructors
+        constexpr Vector2() = default;
+
+        constexpr Vector2(const Type& x, const Type& y) noexcept: x(x), y(y)
+        {
+        }
+
+        // Equality operators
+        [[nodiscard]]
+        constexpr bool operator==(const Vector2& other) const noexcept
+        {
+            return x == other.x && y == other.y;
+        }
+
+        [[nodiscard]]
+        constexpr bool operator!=(const Vector2& other) const noexcept
+        {
+            return !(*this == other);
+        }
+
+        // Compound assignment operators
+        constexpr Vector2& operator+=(const Vector2& other) noexcept
+        {
+            x += other.x;
+            y += other.y;
+
+            return *this;
+        }
+
+        constexpr Vector2& operator-=(const Vector2& other) noexcept
+        {
+            x -= other.x;
+            y -= other.y;
+
+            return *this;
+        }
+
+        constexpr Vector2& operator*=(const Vector2& other) noexcept
+        {
+            x *= other.x;
+            y *= other.y;
+
+            return *this;
+        }
+
+        constexpr Vector2& operator/=(const Vector2& other) noexcept
+        {
+            x /= other.x;
+            y /= other.y;
+
+            return *this;
+        }
+
+        constexpr Vector2& operator*=(const Type& value) noexcept
+        {
+            x *= value;
+            y *= value;
+
+            return *this;
+        }
+
+        constexpr Vector2& operator/=(const Type& value) noexcept
+        {
+            x /= value;
+            y /= value;
+
+            return *this;
+        }
+
+        constexpr Vector2& operator+=(const Type& value) noexcept
+        {
+            x += value;
+            y += value;
+
+            return *this;
+        }
+
+        constexpr Vector2& operator-=(const Type& value) noexcept
+        {
+            x -= value;
+            y -= value;
+
+            return *this;
+        }
+
+        // Basic vector operations
+        [[nodiscard]] Type distance_to(const Vector2& other) const noexcept
+        {
+            return std::sqrt(distance_to_sqr(other));
+        }
+
+        [[nodiscard]] constexpr Type distance_to_sqr(const Vector2& other) const noexcept
+        {
+            return (x - other.x) * (x - other.x) + (y - other.y) * (y - other.y);
+        }
+
+        [[nodiscard]] constexpr Type dot(const Vector2& other) const noexcept
+        {
+            return x * other.x + y * other.y;
+        }
+
+#ifndef _MSC_VER
+        [[nodiscard]] constexpr Type length() const noexcept
+        {
+            return std::hypot(this->x, this->y);
+        }
+
+        [[nodiscard]] constexpr Vector2 normalized() const noexcept
+        {
+            const Type len = length();
+            return len > 0.f ? *this / len : *this;
+        }
+#else
+        [[nodiscard]] Type length() const noexcept
+        {
+            return std::hypot(x, y);
+        }
+
+        [[nodiscard]] Vector2 normalized() const noexcept
+        {
+            const Type len = length();
+            return len > static_cast<Type>(0) ? *this / len : *this;
+        }
+#endif
+        [[nodiscard]] constexpr Type length_sqr() const noexcept
+        {
+            return x * x + y * y;
+        }
+
+        constexpr Vector2& abs() noexcept
+        {
+            // FIXME: Replace with std::abs, if it will become constexprable
+            x = x < static_cast<Type>(0) ? -x : x;
+            y = y < static_cast<Type>(0) ? -y : y;
+            return *this;
+        }
+
+        [[nodiscard]] constexpr Vector2 operator-() const noexcept
+        {
+            return {-x, -y};
+        }
+
+        // Binary arithmetic operators
+        [[nodiscard]] constexpr Vector2 operator+(const Vector2& other) const noexcept
+        {
+            return {x + other.x, y + other.y};
+        }
+
+        [[nodiscard]] constexpr Vector2 operator-(const Vector2& other) const noexcept
+        {
+            return {x - other.x, y - other.y};
+        }
+
+        [[nodiscard]] constexpr Vector2 operator*(const Type& value) const noexcept
+        {
+            return {x * value, y * value};
+        }
+
+        [[nodiscard]] constexpr Vector2 operator/(const Type& value) const noexcept
+        {
+            return {x / value, y / value};
+        }
+
+        // Sum of elements
+        [[nodiscard]] constexpr Type sum() const noexcept
+        {
+            return x + y;
+        }
+
+        [[nodiscard]]
+        constexpr std::tuple<Type, Type> as_tuple() const noexcept
+        {
+            return std::make_tuple(x, y);
+        }
+
+#ifdef OMATH_IMGUI_INTEGRATION
+        [[nodiscard]]
+        ImVec2 to_im_vec2() const noexcept
+        {
+            return {static_cast<float>(this->x), static_cast<float>(this->y)};
+        }
+        [[nodiscard]]
+        static Vector3<float> from_im_vec2(const ImVec2& other) noexcept
+        {
+            return {static_cast<Type>(other.x), static_cast<Type>(other.y)};
+        }
+#endif
+    };
+} // namespace omath

include/omath/vector3.hpp

@@ -0,0 +1,275 @@
+//
+// Created by vlad on 10/28/23.
+//
+
+#pragma once
+
+#include "omath/angle.hpp"
+#include "omath/vector2.hpp"
+#include <cstdint>
+#include <expected>
+#include <functional>
+
+namespace omath
+{
+
+    enum class Vector3Error
+    {
+        IMPOSSIBLE_BETWEEN_ANGLE,
+    };
+
+    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) noexcept: Vector2<Type>(x, y), z(z)
+        {
+        }
+        constexpr Vector3() noexcept: Vector2<Type>() {};
+
+        [[nodiscard]] constexpr bool operator==(const Vector3& other) const noexcept
+        {
+            return Vector2<Type>::operator==(other) && (other.z == z);
+        }
+
+        [[nodiscard]] constexpr bool operator!=(const Vector3& other) const noexcept
+        {
+            return !(*this == other);
+        }
+
+        constexpr Vector3& operator+=(const Vector3& other) noexcept
+        {
+            Vector2<Type>::operator+=(other);
+            z += other.z;
+
+            return *this;
+        }
+
+        constexpr Vector3& operator-=(const Vector3& other) noexcept
+        {
+            Vector2<Type>::operator-=(other);
+            z -= other.z;
+
+            return *this;
+        }
+
+        constexpr Vector3& operator*=(const Type& value) noexcept
+        {
+            Vector2<Type>::operator*=(value);
+            z *= value;
+
+            return *this;
+        }
+
+        constexpr Vector3& operator*=(const Vector3& other) noexcept
+        {
+            Vector2<Type>::operator*=(other);
+            z *= other.z;
+
+            return *this;
+        }
+
+        constexpr Vector3& operator/=(const Vector3& other) noexcept
+        {
+            Vector2<Type>::operator/=(other);
+            z /= other.z;
+
+            return *this;
+        }
+
+        constexpr Vector3& operator+=(const Type& value) noexcept
+        {
+            Vector2<Type>::operator+=(value);
+            z += value;
+
+            return *this;
+        }
+
+        constexpr Vector3& operator/=(const Type& value) noexcept
+        {
+            Vector2<Type>::operator/=(value);
+            z /= value;
+
+            return *this;
+        }
+
+        constexpr Vector3& operator-=(const Type& value) noexcept
+        {
+            Vector2<Type>::operator-=(value);
+            z -= value;
+
+            return *this;
+        }
+
+        constexpr Vector3& abs() noexcept
+        {
+            Vector2<Type>::abs();
+            z = z < 0.f ? -z : z;
+
+            return *this;
+        }
+
+        [[nodiscard]] constexpr Type distance_to_sqr(const Vector3& other) const noexcept
+        {
+            return (*this - other).length_sqr();
+        }
+
+        [[nodiscard]] constexpr Type dot(const Vector3& other) const noexcept
+        {
+            return Vector2<Type>::dot(other) + z * other.z;
+        }
+
+#ifndef _MSC_VER
+        [[nodiscard]] constexpr Type length() const
+        {
+            return std::hypot(this->x, this->y, z);
+        }
+
+        [[nodiscard]] constexpr Type length_2d() const
+        {
+            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_value != 0 ? *this / length_value : *this;
+        }
+#else
+        [[nodiscard]] Type length() const noexcept
+        {
+            return std::hypot(this->x, this->y, z);
+        }
+
+        [[nodiscard]] Vector3 normalized() const noexcept
+        {
+            const Type len = this->length();
+
+            return len != static_cast<Type>(0) ? *this / len : *this;
+        }
+
+        [[nodiscard]] Type length_2d() const noexcept
+        {
+            return Vector2<Type>::length();
+        }
+
+        [[nodiscard]] Type distance_to(const Vector3& vOther) const noexcept
+        {
+            return (*this - vOther).length();
+        }
+#endif
+
+        [[nodiscard]] constexpr Type length_sqr() const noexcept
+        {
+            return Vector2<Type>::length_sqr() + z * z;
+        }
+
+        [[nodiscard]] constexpr Vector3 operator-() const noexcept
+        {
+            return {-this->x, -this->y, -z};
+        }
+
+        [[nodiscard]] constexpr Vector3 operator+(const Vector3& other) const noexcept
+        {
+            return {this->x + other.x, this->y + other.y, z + other.z};
+        }
+
+        [[nodiscard]] constexpr Vector3 operator-(const Vector3& other) const noexcept
+        {
+            return {this->x - other.x, this->y - other.y, z - other.z};
+        }
+
+        [[nodiscard]] constexpr Vector3 operator*(const Type& value) const noexcept
+        {
+            return {this->x * value, this->y * value, z * value};
+        }
+
+        [[nodiscard]] constexpr Vector3 operator*(const Vector3& other) const noexcept
+        {
+            return {this->x * other.x, this->y * other.y, z * other.z};
+        }
+
+        [[nodiscard]] constexpr Vector3 operator/(const Type& value) const noexcept
+        {
+            return {this->x / value, this->y / value, z / value};
+        }
+
+        [[nodiscard]] constexpr Vector3 operator/(const Vector3& other) const noexcept
+        {
+            return {this->x / other.x, this->y / other.y, z / other.z};
+        }
+
+        [[nodiscard]] constexpr Vector3 cross(const Vector3& other) const noexcept
+        {
+            return {this->y * other.z - z * other.y, z * other.x - this->x * other.z,
+                    this->x * other.y - this->y * other.x};
+        }
+
+        [[nodiscard]] constexpr Type sum() const noexcept
+        {
+            return sum_2d() + z;
+        }
+
+        [[nodiscard]] std::expected<Angle<float, 0.f, 180.f, AngleFlags::Clamped>, Vector3Error>
+        angle_between(const Vector3& other) const noexcept
+        {
+            const auto bottom = length() * other.length();
+
+            if (bottom == static_cast<Type>(0))
+                return std::unexpected(Vector3Error::IMPOSSIBLE_BETWEEN_ANGLE);
+
+            return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::from_radians(std::acos(dot(other) / bottom));
+        }
+
+        [[nodiscard]] bool is_perpendicular(const Vector3& other) const noexcept
+        {
+            if (const auto angle = angle_between(other))
+                return angle->as_degrees() == static_cast<Type>(90);
+
+            return false;
+        }
+
+        [[nodiscard]] constexpr Type sum_2d() const noexcept
+        {
+            return Vector2<Type>::sum();
+        }
+
+        [[nodiscard]] constexpr std::tuple<Type, Type, Type> as_tuple() const noexcept
+        {
+            return std::make_tuple(this->x, this->y, z);
+        }
+
+        [[nodiscard]] Vector3 view_angle_to(const Vector3& other) const noexcept
+        {
+            const auto distance = distance_to(other);
+            const auto delta = other - *this;
+
+            return {angles::radians_to_degrees(std::asin(delta.z / distance)),
+                    angles::radians_to_degrees(std::atan2(delta.y, delta.x)), 0};
+        }
+    };
+} // namespace omath
+// ReSharper disable once CppRedundantNamespaceDefinition
+namespace std
+{
+    template<> 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.y) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
+            hash ^= hasher(vec.z) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
+
+            return hash;
+        }
+    };
+} // namespace std

include/omath/vector4.hpp

@@ -0,0 +1,180 @@
+//
+// Vector4.h
+//
+#pragma once
+
+#include <algorithm>
+#include <omath/vector3.hpp>
+
+namespace omath
+{
+    template<class Type>
+    requires std::is_arithmetic_v<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() noexcept: Vector3<Type>(), w(static_cast<Type>(0)) {};
+
+        [[nodiscard]]
+        constexpr bool operator==(const Vector4& other) const noexcept
+        {
+            return Vector3<Type>::operator==(other) && w == other.w;
+        }
+
+        [[nodiscard]]
+        constexpr bool operator!=(const Vector4& other) const noexcept
+        {
+            return !(*this == other);
+        }
+
+        constexpr Vector4& operator+=(const Vector4& other) noexcept
+        {
+            Vector3<Type>::operator+=(other);
+            w += other.w;
+
+            return *this;
+        }
+
+        constexpr Vector4& operator-=(const Vector4& other) noexcept
+        {
+            Vector3<Type>::operator-=(other);
+            w -= other.w;
+
+            return *this;
+        }
+
+        constexpr Vector4& operator*=(const Type& value) noexcept
+        {
+            Vector3<Type>::operator*=(value);
+            w *= value;
+
+            return *this;
+        }
+
+        constexpr Vector4& operator*=(const Vector4& other) noexcept
+        {
+            Vector3<Type>::operator*=(other);
+            w *= other.w;
+
+            return *this;
+        }
+
+        constexpr Vector4& operator/=(const Type& value) noexcept
+        {
+            Vector3<Type>::operator/=(value);
+            w /= value;
+
+            return *this;
+        }
+
+        constexpr Vector4& operator/=(const Vector4& other) noexcept
+        {
+            Vector3<Type>::operator/=(other);
+            w /= other.w;
+            return *this;
+        }
+
+        [[nodiscard]] constexpr Type length_sqr() const noexcept
+        {
+            return Vector3<Type>::length_sqr() + w * w;
+        }
+
+        [[nodiscard]] constexpr Type dot(const Vector4& other) const noexcept
+        {
+            return Vector3<Type>::dot(other) + w * other.w;
+        }
+
+        [[nodiscard]] Vector3<Type> length() const noexcept
+        {
+            return std::sqrt(length_sqr());
+        }
+
+        constexpr Vector4& abs() noexcept
+        {
+            Vector3<Type>::abs();
+            w = w < 0.f ? -w : w;
+
+            return *this;
+        }
+        constexpr Vector4& clamp(const Type& min, const Type& max) noexcept
+        {
+            this->x = std::clamp(this->x, min, max);
+            this->y = std::clamp(this->y, min, max);
+            this->z = std::clamp(this->z, min, max);
+
+            return *this;
+        }
+
+        [[nodiscard]]
+        constexpr Vector4 operator-() const noexcept
+        {
+            return {-this->x, -this->y, -this->z, -w};
+        }
+
+        [[nodiscard]]
+        constexpr Vector4 operator+(const Vector4& other) const noexcept
+        {
+            return {this->x + other.x, this->y + other.y, this->z + other.z, w + other.w};
+        }
+
+        [[nodiscard]]
+        constexpr Vector4 operator-(const Vector4& other) const noexcept
+        {
+            return {this->x - other.x, this->y - other.y, this->z - other.z, w - other.w};
+        }
+
+        [[nodiscard]]
+        constexpr Vector4 operator*(const Type& value) const noexcept
+        {
+            return {this->x * value, this->y * value, this->z * value, w * value};
+        }
+
+        [[nodiscard]]
+        constexpr Vector4 operator*(const Vector4& other) const noexcept
+        {
+            return {this->x * other.x, this->y * other.y, this->z * other.z, w * other.w};
+        }
+
+        [[nodiscard]]
+        constexpr Vector4 operator/(const Type& value) const noexcept
+        {
+            return {this->x / value, this->y / value, this->z / value, w / value};
+        }
+
+        [[nodiscard]]
+        constexpr Vector4 operator/(const Vector4& other) const noexcept
+        {
+            return {this->x / other.x, this->y / other.y, this->z / other.z, w / other.w};
+        }
+
+        [[nodiscard]]
+        constexpr Type sum() const noexcept
+        {
+            return Vector3<Type>::sum() + w;
+        }
+
+#ifdef OMATH_IMGUI_INTEGRATION
+        [[nodiscard]]
+        ImVec4 to_im_vec4() const noexcept
+        {
+            return {
+                    static_cast<float>(this->x),
+                    static_cast<float>(this->y),
+                    static_cast<float>(this->z),
+                    static_cast<float>(w),
+            };
+        }
+        [[nodiscard]]
+        static Vector4<float> from_im_vec4(const ImVec4& other) noexcept
+        {
+            return {static_cast<Type>(other.x), static_cast<Type>(other.y), static_cast<Type>(other.z)};
+        }
+    }
+#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) noexcept
+    {
+        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,13 +0,0 @@
-target_sources(omath PRIVATE
-        Vector3.cpp
-        Matrix.cpp
-        color.cpp
-        Vector4.cpp
-        Vector2.cpp
-)
-
-add_subdirectory(prediction)
-add_subdirectory(pathfinding)
-add_subdirectory(projection)
-add_subdirectory(collision)
-add_subdirectory(engines)

source/Vector2.cpp

@@ -1,11 +0,0 @@
-//
-// Created by Vlad on 02.09.2024.
-//
-#include "omath/Vector2.hpp"
-#include <cmath>
-
-
-namespace omath
-{
-
-}

source/Vector3.cpp

@@ -1,23 +0,0 @@
-//
-// Created by vlad on 10/28/23.
-//
-
-#include <omath/Vector3.hpp>
-#include <cmath>
-#include <omath/Angles.hpp>
-
-namespace omath
-{
-    Vector3 Vector3::ViewAngleTo(const Vector3 &other) const
-    {
-        const float distance = DistTo(other);
-        const auto delta = other - *this;
-
-        return
-        {
-            angles::RadiansToDegrees(std::asin(delta.z / distance)),
-            angles::RadiansToDegrees(std::atan2(delta.y, delta.x)),
-            0.f
-        };
-    }
-}

source/Vector4.cpp

@@ -1,16 +0,0 @@
-//
-// Vector4.cpp
-//
-
-#include "omath/Vector4.hpp"
-#include <cmath>
-
-
-namespace omath
-{
-
-    float Vector4::Length() const
-    {
-        return std::sqrt(LengthSqr());
-    }
-}

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>& triangle)
-    {
-        return GetRayHitPoint(ray, triangle) == ray.end;
-    }
-    Vector3 Ray::DirectionVector() const
-    {
-        return end - start;
-    }
-
-    Vector3 Ray::DirectionVectorNormalized() const
-    {
-        return DirectionVector().Normalized();
-    }
-
-    Vector3 LineTracer::GetRayHitPoint(const Ray& ray, const Triangle<Vector3>& 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) noexcept
+    {
+        return get_ray_hit_point(ray, triangle) == ray.end;
+    }
+    Vector3<float> Ray::direction_vector() const noexcept
+    {
+        return end - start;
+    }
+
+    Vector3<float> Ray::direction_vector_normalized() const noexcept
+    {
+        return direction_vector().normalized();
+    }
+
+    Vector3<float> LineTracer::get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept
+    {
+        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

@@ -1,13 +0,0 @@
-//
-// Created by vlad on 2/4/24.
-//
-
-#include "omath/Color.hpp"
-#include <algorithm>
-#include <cmath>
-
-
-namespace omath
-{
-
-}

source/engines/CMakeLists.txt

@@ -1,2 +0,0 @@
-add_subdirectory(Source)
-add_subdirectory(OpenGL)

source/engines/OpenGL/CMakeLists.txt

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

source/engines/OpenGL/Camera.cpp

@@ -1,35 +0,0 @@
-//
-// Created by Orange on 12/23/2024.
-//
-#include "omath/engines/OpenGL/Camera.hpp"
-#include "omath/engines/OpenGL/Formulas.hpp"
-
-
-namespace omath::opengl
-{
-
-    Camera::Camera(const Vector3& 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& 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::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/Source/CMakeLists.txt

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

source/engines/Source/Camera.cpp

@@ -1,37 +0,0 @@
-//
-// Created by Orange on 12/4/2024.
-//
-#include "omath/engines/Source/Camera.hpp"
-#include "omath/engines/Source/Formulas.hpp"
-
-
-namespace omath::source
-{
-
-    Camera::Camera(const Vector3& 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& 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::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/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) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+
+    Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        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) noexcept
+    {
+        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) noexcept
+    {
+        // 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/iw_engine/traits/camera_trait.cpp

@@ -0,0 +1,27 @@
+//
+// Created by Vlad on 8/11/2025.
+//
+#include "omath/engines/iw_engine/traits/camera_trait.hpp"
+
+namespace omath::iw_engine
+{
+
+    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
+    {
+        const auto distance = cam_origin.distance_to(look_at);
+        const auto delta = cam_origin - look_at;
+
+        return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
+                YawAngle::from_radians(std::atan2(delta.y, delta.x)), RollAngle::from_radians(0.f)};
+    }
+    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return iw_engine::calc_view_matrix(angles, cam_origin);
+    }
+    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
+                                               const projection::ViewPort& view_port, const float near,
+                                               const float far) noexcept
+    {
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+    }
+} // namespace omath::iw_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) noexcept
+    {
+        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) noexcept
+    {
+        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) noexcept
+    {
+        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) noexcept
+    {
+        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) noexcept
+    {
+        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) noexcept
+    {
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+
+        return {
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
+                {0, 0, -(far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                {0, 0, -1, 0},
+        };
+    }
+} // namespace omath::opengl_engine

source/engines/opengl_engine/traits/camera_trait.cpp

@@ -0,0 +1,28 @@
+//
+// Created by Vlad on 8/11/2025.
+//
+#include "omath/engines/opengl_engine/traits/camera_trait.hpp"
+
+
+namespace omath::opengl_engine
+{
+
+    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
+    {
+        const auto distance = cam_origin.distance_to(look_at);
+        const auto delta = cam_origin - look_at;
+
+        return {PitchAngle::from_radians(-std::asin(delta.y / distance)),
+                YawAngle::from_radians(std::atan2(delta.z, delta.x)), RollAngle::from_radians(0.f)};
+    }
+    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return opengl_engine::calc_view_matrix(angles, cam_origin);
+    }
+    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
+                                               const projection::ViewPort& view_port, const float near,
+                                               const float far) noexcept
+    {
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+    }
+} // namespace omath::opengl_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) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        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) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return mat_camera_view(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) noexcept
+    {
+        // 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/source_engine/traits/camera_trait.cpp

@@ -0,0 +1,27 @@
+//
+// Created by Vlad on 8/11/2025.
+//
+#include "omath/engines/source_engine/traits/camera_trait.hpp"
+
+namespace omath::source_engine
+{
+
+    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
+    {
+        const auto distance = cam_origin.distance_to(look_at);
+        const auto delta = cam_origin - look_at;
+
+        return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
+                YawAngle::from_radians(std::atan2(delta.y, delta.x)), RollAngle::from_radians(0.f)};
+    }
+    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return source_engine::calc_view_matrix(angles, cam_origin);
+    }
+    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
+                                               const projection::ViewPort& view_port, const float near,
+                                               const float far) noexcept
+    {
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+    }
+} // namespace omath::source_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) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), -right_vector(angles),
+                                                               up_vector(angles), cam_origin);
+    }
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_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) noexcept
+    {
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+
+        return {
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
+                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                {0, 0, -1.f, 0},
+        };
+    }
+} // namespace omath::unity_engine