added nodiscard message

Feature/gcem

.agents/skills/code-style/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: code-style
+description: omath project C++ code style derived from .idea/codeStyles/Project.xml and .clang-format. Use when writing, editing, or reviewing C++ code in this repo so formatting and naming match the rest of the codebase.
+---
+
+# omath Code Style
+
+Authoritative sources: `.clang-format` (formatting) and `.idea/codeStyles/Project.xml` (Rider/CLion naming + formatting). When in doubt, run clang-format — it is the enforced formatter (`clangFormatSettings.ENABLED = true`).
+
+## Formatting
+
+Base style: LLVM with Stroustrup-style braces.
+
+- **Indent**: 4 spaces, no tabs. Tab width 4. Continuation indent 8.
+- **Column limit**: 120.
+- **Namespace indentation**: `All` — indent contents of every namespace.
+- **Access modifier offset**: -4 (access specifiers sit at the class column; members indent one level deeper).
+- **Pointer/reference alignment**: Left, with a space *before* `*` / `&` in declarations: `const Vector3& other`, `Type* ptr`.
+- **Include blocks**: Merge. Sort using-declarations.
+- **Keep blank lines**: max 2 in code and declarations. No blank line at the start of a block.
+- **Align trailing comments**: false.
+- **Break before binary operators**: non-assignment.
+
+### Braces (Allman / next-line for everything)
+
+Opening brace on its own line after:
+class, struct, union, enum, namespace, function, control statement (`if`/`for`/`while`/`switch`), `case` label, lambda body, `catch`, `else`, `while` (of do-while), extern block.
+
+Empty functions, records, and namespaces still split (`SplitEmptyFunction/Record/Namespace: true`).
+
+### Short-form rules (all disabled)
+
+Never collapse onto one line: blocks, functions, lambdas, `if` statements, loops.
+
+### Templates
+
+`template<class T>` goes on its own line, declaration follows on the next line:
+
+```cpp
+template<class Type>
+requires std::is_arithmetic_v<Type>
+class Vector3 : public Vector2<Type>
+{
+    ...
+};
+```
+
+No space after `template` keyword. `requires` clause is not extra-indented.
+
+### Spaces
+
+- After control-statement keywords (`if (`, `for (`, `while (`).
+- **Not** before `(` in function declarations/definitions/calls.
+- After C-style cast: `(int) x`.
+- Around range-based-for colon: `for (auto& x : xs)`.
+- After commas in template args/params.
+- Inside empty parens/braces/templates: no.
+
+## Naming
+
+| Kind | Style | Example |
+|---|---|---|
+| Namespaces | `snake_case` | `omath::pathfinding`, `omath::primitives` |
+| Types (class, struct, enum, union, concept, type alias, typedef, template parameter) | `PascalCase` | `Vector3`, `NavigationMesh`, `Astar`, `ContainedType` |
+| Functions (free + member) | `snake_case` | `find_path`, `distance_to_sqr`, `create_box` |
+| Fields (class/struct/union members) | `snake_case` | `dir_forward`, `nav_mesh` |
+| Variables (global, local, lambda) | `snake_case` | `length_value`, `side_size` |
+| Parameters | `snake_case` | `dir_right`, `v_other` |
+| Macros | `UPPER_SNAKE_CASE` | `OMATH_FOO_BAR` |
+| Enumerators | `UPPER_SNAKE_CASE` | `IMPOSSIBLE_BETWEEN_ANGLE`, `WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS` |
+
+Enum types themselves are PascalCase (`enum class Vector3Error`, `enum class Error`); their members are UPPER_SNAKE_CASE.
+
+## Files
+
+- Headers: `.hpp`, sources: `.cpp`. Both use `snake_case` filenames (e.g. `vector3.hpp`, `proj_pred_engine_avx2.hpp`).
+- C headers: `.h`, sources: `.c` (no enforced filename style).
+- CUDA: `.cu` / `.cuh`.
+- C++ modules: `.ixx`, `.mxx`, `.cppm`, `.ccm`, `.cxxm`, `.c++m`.
+- Header guard: `#pragma once` only — no `#ifndef` guards.
+- File header comment is optional and follows the form `// Created by <name> on <date>`.
+
+## Idioms used throughout the codebase
+
+- Prefer `[[nodiscard]]`, `noexcept`, and `constexpr` on math / value-type methods.
+- `namespace omath` is the root; sub-features live in nested namespaces (`omath::collision`, `omath::engines::source_engine`, etc.).
+- Closing namespace brace gets a trailing comment: `} // namespace omath::primitives`.
+- Use `std::expected<T, E>` with an `enum class …Error` for fallible operations (see `Vector3Error`, `projection::Error`).
+
+## When editing
+
+Match the surrounding style exactly. If a region disagrees with this guide, prefer the existing local style — don't reformat unrelated code (per the project's CLAUDE.md "Surgical Changes" rule). Run clang-format on touched files before committing.

.agents/skills/karpathy-guidelines/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: karpathy-guidelines
+description: Behavioral guidelines to reduce common LLM coding mistakes. Use when writing, reviewing, or refactoring code to avoid overcomplication, make surgical changes, surface assumptions, and define verifiable success criteria.
+license: MIT
+---
+
+# Karpathy Guidelines
+
+Behavioral guidelines to reduce common LLM coding mistakes, derived from [Andrej Karpathy's observations](https://x.com/karpathy/status/2015883857489522876) on LLM coding pitfalls.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+## 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.

.claude/skills/code-style/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: code-style
+description: omath project C++ code style derived from .idea/codeStyles/Project.xml and .clang-format. Use when writing, editing, or reviewing C++ code in this repo so formatting and naming match the rest of the codebase.
+---
+
+# omath Code Style
+
+Authoritative sources: `.clang-format` (formatting) and `.idea/codeStyles/Project.xml` (Rider/CLion naming + formatting). When in doubt, run clang-format — it is the enforced formatter (`clangFormatSettings.ENABLED = true`).
+
+## Formatting
+
+Base style: LLVM with Stroustrup-style braces.
+
+- **Indent**: 4 spaces, no tabs. Tab width 4. Continuation indent 8.
+- **Column limit**: 120.
+- **Namespace indentation**: `All` — indent contents of every namespace.
+- **Access modifier offset**: -4 (access specifiers sit at the class column; members indent one level deeper).
+- **Pointer/reference alignment**: Left, with a space *before* `*` / `&` in declarations: `const Vector3& other`, `Type* ptr`.
+- **Include blocks**: Merge. Sort using-declarations.
+- **Keep blank lines**: max 2 in code and declarations. No blank line at the start of a block.
+- **Align trailing comments**: false.
+- **Break before binary operators**: non-assignment.
+
+### Braces (Allman / next-line for everything)
+
+Opening brace on its own line after:
+class, struct, union, enum, namespace, function, control statement (`if`/`for`/`while`/`switch`), `case` label, lambda body, `catch`, `else`, `while` (of do-while), extern block.
+
+Empty functions, records, and namespaces still split (`SplitEmptyFunction/Record/Namespace: true`).
+
+### Short-form rules (all disabled)
+
+Never collapse onto one line: blocks, functions, lambdas, `if` statements, loops.
+
+### Templates
+
+`template<class T>` goes on its own line, declaration follows on the next line:
+
+```cpp
+template<class Type>
+requires std::is_arithmetic_v<Type>
+class Vector3 : public Vector2<Type>
+{
+    ...
+};
+```
+
+No space after `template` keyword. `requires` clause is not extra-indented.
+
+### Spaces
+
+- After control-statement keywords (`if (`, `for (`, `while (`).
+- **Not** before `(` in function declarations/definitions/calls.
+- After C-style cast: `(int) x`.
+- Around range-based-for colon: `for (auto& x : xs)`.
+- After commas in template args/params.
+- Inside empty parens/braces/templates: no.
+
+## Naming
+
+| Kind | Style | Example |
+|---|---|---|
+| Namespaces | `snake_case` | `omath::pathfinding`, `omath::primitives` |
+| Types (class, struct, enum, union, concept, type alias, typedef, template parameter) | `PascalCase` | `Vector3`, `NavigationMesh`, `Astar`, `ContainedType` |
+| Functions (free + member) | `snake_case` | `find_path`, `distance_to_sqr`, `create_box` |
+| Fields (class/struct/union members) | `snake_case` | `dir_forward`, `nav_mesh` |
+| Variables (global, local, lambda) | `snake_case` | `length_value`, `side_size` |
+| Parameters | `snake_case` | `dir_right`, `v_other` |
+| Macros | `UPPER_SNAKE_CASE` | `OMATH_FOO_BAR` |
+| Enumerators | `UPPER_SNAKE_CASE` | `IMPOSSIBLE_BETWEEN_ANGLE`, `WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS` |
+
+Enum types themselves are PascalCase (`enum class Vector3Error`, `enum class Error`); their members are UPPER_SNAKE_CASE.
+
+## Files
+
+- Headers: `.hpp`, sources: `.cpp`. Both use `snake_case` filenames (e.g. `vector3.hpp`, `proj_pred_engine_avx2.hpp`).
+- C headers: `.h`, sources: `.c` (no enforced filename style).
+- CUDA: `.cu` / `.cuh`.
+- C++ modules: `.ixx`, `.mxx`, `.cppm`, `.ccm`, `.cxxm`, `.c++m`.
+- Header guard: `#pragma once` only — no `#ifndef` guards.
+- File header comment is optional and follows the form `// Created by <name> on <date>`.
+
+## Idioms used throughout the codebase
+
+- Prefer `[[nodiscard]]`, `noexcept`, and `constexpr` on math / value-type methods.
+- `namespace omath` is the root; sub-features live in nested namespaces (`omath::collision`, `omath::engines::source_engine`, etc.).
+- Closing namespace brace gets a trailing comment: `} // namespace omath::primitives`.
+- Use `std::expected<T, E>` with an `enum class …Error` for fallible operations (see `Vector3Error`, `projection::Error`).
+
+## When editing
+
+Match the surrounding style exactly. If a region disagrees with this guide, prefer the existing local style — don't reformat unrelated code (per the project's CLAUDE.md "Surgical Changes" rule). Run clang-format on touched files before committing.

.claude/skills/karpathy-guidelines/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: karpathy-guidelines
+description: Behavioral guidelines to reduce common LLM coding mistakes. Use when writing, reviewing, or refactoring code to avoid overcomplication, make surgical changes, surface assumptions, and define verifiable success criteria.
+license: MIT
+---
+
+# Karpathy Guidelines
+
+Behavioral guidelines to reduce common LLM coding mistakes, derived from [Andrej Karpathy's observations](https://x.com/karpathy/status/2015883857489522876) on LLM coding pitfalls.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+## 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.

.idea/editor.xml

@@ -139,6 +139,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppNotAllPathsReturnValue/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppObjectMemberMightNotBeInitialized/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppOutParameterMustBeWritten/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppOverrideWithDifferentVisibility/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppParameterMayBeConst/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppParameterMayBeConstPtrOrRef/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppParameterNamesMismatch/@EntryIndexedValue" value="HINT" type="string" />

AGENTS.md

@@ -0,0 +1,65 @@
+# AGENTS.md
+
+Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+## 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
+
+---
+
+**These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.

CLAUDE.md

@@ -0,0 +1,65 @@
+# CLAUDE.md
+
+Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+## 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
+
+---
+
+**These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.

CMakeLists.txt

@@ -1,5 +1,4 @@
 cmake_minimum_required(VERSION 3.26)
-
 file(READ VERSION OMATH_VERSION)
 project(omath VERSION ${OMATH_VERSION} LANGUAGES CXX)
 
@@ -31,9 +30,11 @@ option(OMATH_SUPRESS_SAFETY_CHECKS
 option(OMATH_ENABLE_COVERAGE "Enable coverage" OFF)
 option(OMATH_ENABLE_FORCE_INLINE
        "Will for compiler to make some functions to be force inlined no matter what" ON)
-
 option(OMATH_ENABLE_LUA
         "omath bindings for lua" OFF)
+option(OMATH_ENABLE_HOOKING "omath will HooksManager that can hook DirectX/OpenGL automatically" OFF)
+option(OMATH_ENABLE_MODULES "Build omath C++ module interface" OFF)
+
 if(VCPKG_MANIFEST_FEATURES)
     foreach(omath_feature IN LISTS VCPKG_MANIFEST_FEATURES)
         if(omath_feature STREQUAL "imgui")
@@ -48,6 +49,8 @@ if(VCPKG_MANIFEST_FEATURES)
             set(OMATH_BUILD_EXAMPLES ON)
         elseif(omath_feature STREQUAL "lua")
             set(OMATH_ENABLE_LUA ON)
+        elseif(omath_feature STREQUAL "hooking")
+            set(OMATH_ENABLE_HOOKING ON)
         endif()
 
     endforeach()
@@ -78,6 +81,11 @@ if(${PROJECT_IS_TOP_LEVEL})
     message(STATUS "[${PROJECT_NAME}]: Coverage feature status ${OMATH_ENABLE_COVERAGE}")
     message(STATUS "[${PROJECT_NAME}]: Valgrind feature status ${OMATH_ENABLE_VALGRIND}")
     message(STATUS "[${PROJECT_NAME}]: Lua feature status ${OMATH_ENABLE_LUA}")
+    message(STATUS "[${PROJECT_NAME}]: Modules feature status ${OMATH_ENABLE_MODULES}")
+endif()
+
+if(OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>" CACHE STRING "" FORCE)
 endif()
 
 file(GLOB_RECURSE OMATH_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp")
@@ -89,6 +97,20 @@ else()
     add_library(${PROJECT_NAME} STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
 endif()
 
+if(OMATH_ENABLE_MODULES)
+    if(CMAKE_VERSION VERSION_LESS 3.28)
+        message(FATAL_ERROR "OMATH_ENABLE_MODULES requires CMake 3.28 or newer")
+    endif()
+    set_target_properties(${PROJECT_NAME} PROPERTIES CXX_SCAN_FOR_MODULES ON)
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+        target_compile_options(${PROJECT_NAME} PRIVATE /wd5244)
+    endif()
+    target_sources(
+        ${PROJECT_NAME}
+        PUBLIC FILE_SET omath_modules TYPE CXX_MODULES BASE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/modules"
+               FILES "${CMAKE_CURRENT_SOURCE_DIR}/modules/omath.cppm")
+endif()
+
 if (OMATH_ENABLE_LUA)
     target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_LUA)
 
@@ -100,6 +122,21 @@ if (OMATH_ENABLE_LUA)
     target_include_directories(${PROJECT_NAME} PRIVATE ${SOL2_INCLUDE_DIRS})
 endif ()
 
+if (OMATH_ENABLE_HOOKING)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_HOOKING)
+
+    find_package(safetyhook CONFIG REQUIRED)
+    target_link_libraries(${PROJECT_NAME} PRIVATE safetyhook::safetyhook)
+
+    if (WIN32)
+        target_link_libraries(${PROJECT_NAME} PRIVATE d3d9 d3d11 d3d12 dxgi opengl32 gdi32)
+    elseif (UNIX AND NOT APPLE)
+        find_package(OpenGL REQUIRED)
+        target_link_libraries(${PROJECT_NAME} PRIVATE OpenGL::GL ${CMAKE_DL_LIBS})
+    endif ()
+endif ()
+
+
 add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
 
 target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_VERSION="${PROJECT_VERSION}")
@@ -147,10 +184,6 @@ set_target_properties(
                CXX_STANDARD 23
                CXX_STANDARD_REQUIRED ON)
 
-if(OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
-    set_target_properties(${PROJECT_NAME} PROPERTIES MSVC_RUNTIME_LIBRARY
-                                                     "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-endif()
 
 if(OMATH_USE_AVX2)
     if(MSVC)
@@ -213,6 +246,10 @@ target_include_directories(
 
 # Installation rules
 
+if(OMATH_ENABLE_MODULES)
+    set(OMATH_MODULE_FILE_SET FILE_SET omath_modules DESTINATION modules)
+endif()
+
 # Install the library
 install(
     TARGETS ${PROJECT_NAME}
@@ -221,6 +258,7 @@ install(
     LIBRARY DESTINATION lib COMPONENT ${PROJECT_NAME} # For shared libraries
     RUNTIME DESTINATION bin COMPONENT ${PROJECT_NAME} # For executables (on
                                                       # Windows)
+    ${OMATH_MODULE_FILE_SET}
     )
 
 # Install headers as part of omath_component

CMakePresets.json

@@ -56,7 +56,9 @@
       "hidden": true,
       "inherits": ["windows-base", "vcpkg-base"],
       "cacheVariables": {
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples"
+        "VCPKG_TARGET_TRIPLET": "x64-windows-static",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;hooking",
+        "OMATH_STATIC_MSVC_RUNTIME_LIBRARY": "ON"
       }
     },
     {
@@ -89,9 +91,10 @@
         "strategy": "external"
       },
       "cacheVariables": {
-        "VCPKG_TARGET_TRIPLET": "x86-windows",
+        "VCPKG_TARGET_TRIPLET": "x86-windows-static",
         "VCPKG_HOST_TRIPLET": "x64-windows",
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples",
+        "OMATH_STATIC_MSVC_RUNTIME_LIBRARY": "ON"
       }
     },
     {
@@ -114,9 +117,10 @@
         "strategy": "external"
       },
       "cacheVariables": {
-        "VCPKG_TARGET_TRIPLET": "arm64-windows",
+        "VCPKG_TARGET_TRIPLET": "arm64-windows-static",
-        "VCPKG_HOST_TRIPLET": "arm64-windows",
+        "VCPKG_HOST_TRIPLET": "arm64-windows-static",
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;examples"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;examples",
+        "OMATH_STATIC_MSVC_RUNTIME_LIBRARY": "ON"
       }
     },
     {

CREDITS.md

@@ -4,7 +4,8 @@ Thanks to everyone who made this possible, including:
 
 - Saikari aka luadebug for VCPKG port and awesome new initial logo design.
 - Billy O'Neal aka BillyONeal for fixing compilation issues due to C math library compatibility.
-- Alex2772 for reference of AUI declarative interface design for omath::hud
+- Alex2772 for reference of AUI declarative interface design for omath::hud.
+- Keith O'Hara aka kthohr for a C++ generalized constant expression-based math library that was used as reference.
 
 And a big hand to everyone else who has contributed over the past!
 

README.md

@@ -81,7 +81,7 @@ if (auto screen = camera.world_to_screen(world_position)) {
 - **Collision Detection**: Production ready code to handle collision detection by using simple interfaces.
 - **No Additional Dependencies**: No additional dependencies need to use OMath except unit test execution
 - **Ready for meta-programming**: Omath use templates for common types like Vectors, Matrixes etc, to handle all types!
-- **Engine support**: Supports coordinate systems of **Source, Unity, Unreal, Frostbite, IWEngine, CryEngine and canonical OpenGL**.
+- **Engine support**: Supports coordinate systems of **Source, Rage, Unity, Unreal, Frostbite, IWEngine, CryEngine and canonical OpenGL**.
 - **Cross platform**: Supports Windows, MacOS and Linux.
 - **Algorithms**: Has ability to scan for byte pattern with wildcards in ELF/Mach-O/PE files/modules, binary slices, works even with Wine apps. 
 - **Scripting**: Supports to make scripts in Lua out of box.
@@ -113,6 +113,10 @@ if (auto screen = camera.world_to_screen(world_position)) {
 
 <br>
 
+![GTA5 Preview]
+
+<br>
+
 ![OpenGL Preview]
 
 <br>
@@ -144,6 +148,7 @@ if (auto screen = camera.world_to_screen(world_position)) {
 [BO2 Preview]: docs/images/showcase/cod_bo2.png
 [CS2 Preview]: docs/images/showcase/cs2.jpeg
 [TF2 Preview]: docs/images/showcase/tf2.jpg
+[GTA5 Preview]: https://i.imgur.com/W7T8RhZ.png
 [OpenGL Preview]: docs/images/showcase/opengl.png
 <!----------------------------------{ Buttons }--------------------------------->
 [QUICKSTART]: docs/getting_started.md

VERSION

@@ -1 +1 @@
-5.0.0
+5.3.0

examples/CMakeLists.txt

@@ -4,6 +4,20 @@ add_subdirectory(example_proj_mat_builder)
 add_subdirectory(example_signature_scan)
 add_subdirectory(example_hud)
 
+if(OMATH_ENABLE_HOOKING AND WIN32)
+    # Requires imgui with dx9-binding, dx11-binding, dx12-binding, opengl3-binding, win32-binding.
+    # Install via: vcpkg install imgui[dx9-binding,dx11-binding,dx12-binding,opengl3-binding,win32-binding]
+    find_package(imgui CONFIG QUIET)
+    if(imgui_FOUND)
+        add_subdirectory(example_dx9_hook)
+        add_subdirectory(example_dx11_hook)
+        add_subdirectory(example_dx12_hook)
+        add_subdirectory(example_opengl_hook)
+    else()
+        message(STATUS "[omath] imgui not found - hook examples skipped")
+    endif()
+endif()
+
 if(OMATH_ENABLE_VALGRIND)
     omath_setup_valgrind(example_projection_matrix_builder)
     omath_setup_valgrind(example_signature_scan)

examples/example_dx11_hook/CMakeLists.txt

@@ -0,0 +1,13 @@
+project(example_dx11_hook)
+
+add_library(${PROJECT_NAME} SHARED dllmain.cpp)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    CXX_STANDARD 23
+    MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
+    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
+
+find_package(imgui CONFIG REQUIRED)
+target_link_libraries(${PROJECT_NAME} PRIVATE omath::omath imgui::imgui d3d11 dxgi)

examples/example_dx11_hook/dllmain.cpp

@@ -0,0 +1,154 @@
+#include "omath/hooks/hooks_manager.hpp"
+#include <Windows.h>
+#include <d3d11.h>
+#include <dxgi.h>
+#include <imgui.h>
+#include <imgui_impl_dx11.h>
+#include <imgui_impl_win32.h>
+
+extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND, UINT, WPARAM, LPARAM);
+
+namespace
+{
+    bool g_initialized = false;
+    bool g_init_attempted = false;
+
+    ID3D11Device* g_device = nullptr;
+    ID3D11DeviceContext* g_context = nullptr;
+    ID3D11RenderTargetView* g_render_target_view = nullptr;
+
+    void create_render_target(IDXGISwapChain* swap_chain)
+    {
+        ID3D11Texture2D* back_buffer = nullptr;
+        if (FAILED(swap_chain->GetBuffer(0, IID_PPV_ARGS(&back_buffer))))
+            return;
+        g_device->CreateRenderTargetView(back_buffer, nullptr, &g_render_target_view);
+        back_buffer->Release();
+    }
+
+    void init(IDXGISwapChain* swap_chain)
+    {
+        g_init_attempted = true;
+
+        if (FAILED(swap_chain->GetDevice(IID_PPV_ARGS(&g_device))))
+            return;
+
+        g_device->GetImmediateContext(&g_context);
+
+        DXGI_SWAP_CHAIN_DESC desc{};
+        swap_chain->GetDesc(&desc);
+
+        create_render_target(swap_chain);
+
+        ImGui::CreateContext();
+        ImGui::StyleColorsDark();
+        ImGui::GetIO().IniFilename = nullptr;
+        ImGui::GetIO().LogFilename = nullptr;
+        ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange;
+
+        ImGui_ImplWin32_Init(desc.OutputWindow);
+        ImGui_ImplDX11_Init(g_device, g_context);
+
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.set_on_wnd_proc(
+                [](HWND h, UINT msg, WPARAM wp, LPARAM lp) -> std::optional<LRESULT>
+                {
+                    if (ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp))
+                        return 0;
+                    return std::nullopt;
+                });
+        std::ignore = mgr.hook_wnd_proc(desc.OutputWindow);
+
+        g_initialized = true;
+    }
+
+    void on_present(IDXGISwapChain* swap_chain, UINT, UINT)
+    {
+        if (!g_initialized)
+        {
+            if (!g_init_attempted)
+                init(swap_chain);
+            return;
+        }
+
+        if (!g_render_target_view)
+            create_render_target(swap_chain);
+
+        g_context->OMSetRenderTargets(1, &g_render_target_view, nullptr);
+
+        ImGui_ImplDX11_NewFrame();
+        ImGui_ImplWin32_NewFrame();
+        ImGui::NewFrame();
+
+        ImGui::SetNextWindowSize({300.f, 80.f}, ImGuiCond_Once);
+        ImGui::SetNextWindowPos({10.f, 10.f}, ImGuiCond_Once);
+        ImGui::Begin("omath | DX11 hook");
+        ImGui::Text("Hook active");
+        ImGui::Text("FPS: %.1f", ImGui::GetIO().Framerate);
+        ImGui::End();
+
+        ImGui::Render();
+        ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
+    }
+
+    void on_resize_buffers(IDXGISwapChain*, UINT, UINT, UINT, DXGI_FORMAT, UINT)
+    {
+        if (g_render_target_view)
+        {
+            g_render_target_view->Release();
+            g_render_target_view = nullptr;
+        }
+    }
+} // namespace
+
+BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
+{
+    if (reason == DLL_PROCESS_ATTACH)
+    {
+        DisableThreadLibraryCalls(h_instance);
+        CreateThread(
+                nullptr, 0,
+                [](LPVOID) -> DWORD
+                {
+                    while (!GetModuleHandle("d3d11.dll"))
+                        Sleep(100);
+
+                    auto& mgr = omath::hooks::HooksManager::get();
+                    mgr.set_on_present(on_present);
+                    mgr.set_on_resize_buffers(on_resize_buffers);
+                    mgr.hook_dx11();
+                    return 0;
+                },
+                nullptr, 0, nullptr);
+    }
+    else if (reason == DLL_PROCESS_DETACH)
+    {
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.unhook_wnd_proc();
+        mgr.unhook_dx11();
+
+        if (g_initialized)
+        {
+            ImGui_ImplDX11_Shutdown();
+            ImGui_ImplWin32_Shutdown();
+            ImGui::DestroyContext();
+        }
+
+        if (g_render_target_view)
+        {
+            g_render_target_view->Release();
+            g_render_target_view = nullptr;
+        }
+        if (g_context)
+        {
+            g_context->Release();
+            g_context = nullptr;
+        }
+        if (g_device)
+        {
+            g_device->Release();
+            g_device = nullptr;
+        }
+    }
+    return TRUE;
+}

examples/example_dx12_hook/CMakeLists.txt

@@ -0,0 +1,13 @@
+project(example_dx12_hook)
+
+add_library(${PROJECT_NAME} MODULE dllmain.cpp)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    CXX_STANDARD 23
+    MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
+    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
+
+find_package(imgui CONFIG REQUIRED)
+target_link_libraries(${PROJECT_NAME} PRIVATE omath::omath imgui::imgui d3d12 dxgi)

examples/example_dx12_hook/dllmain.cpp

@@ -0,0 +1,254 @@
+#include "omath/hooks/hooks_manager.hpp"
+#include <Windows.h>
+#include <d3d12.h>
+#include <dxgi1_4.h>
+#include <imgui.h>
+#include <imgui_impl_dx12.h>
+#include <imgui_impl_win32.h>
+#include <tuple>
+#include <vector>
+
+extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND, UINT, WPARAM, LPARAM);
+bool show_menu = true;
+
+namespace
+{
+    struct frame_context
+    {
+        ID3D12Resource* render_target = nullptr;
+        D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = {};
+    };
+
+    bool g_initialized = false;
+    bool g_init_attempted = false;
+
+    ID3D12Device* g_device = nullptr;
+    ID3D12CommandQueue* g_command_queue = nullptr;
+    IDXGISwapChain3* g_swap_chain = nullptr;
+    ID3D12DescriptorHeap* g_rtv_heap = nullptr;
+    ID3D12DescriptorHeap* g_srv_heap = nullptr;
+    ID3D12GraphicsCommandList* g_command_list = nullptr;
+    ID3D12CommandAllocator* g_command_allocator = nullptr;
+    std::vector<frame_context> g_frames;
+
+    void init(IDXGISwapChain* swap_chain)
+    {
+        g_init_attempted = true;
+
+        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&g_swap_chain))))
+            return;
+
+        if (FAILED(swap_chain->GetDevice(IID_PPV_ARGS(&g_device))))
+            return;
+
+        DXGI_SWAP_CHAIN_DESC desc{};
+        swap_chain->GetDesc(&desc);
+        const UINT buffer_count = desc.BufferCount;
+
+        {
+            D3D12_DESCRIPTOR_HEAP_DESC heap_desc{};
+            heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
+            heap_desc.NumDescriptors = buffer_count;
+            heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
+            if (FAILED(g_device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&g_srv_heap))))
+                return;
+        }
+        {
+            D3D12_DESCRIPTOR_HEAP_DESC heap_desc{};
+            heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
+            heap_desc.NumDescriptors = buffer_count;
+            heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
+            heap_desc.NodeMask = 1;
+            if (FAILED(g_device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&g_rtv_heap))))
+                return;
+        }
+
+        if (FAILED(g_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
+                                                    IID_PPV_ARGS(&g_command_allocator))))
+            return;
+
+        g_frames.resize(buffer_count);
+        const UINT rtv_size = g_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+        D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = g_rtv_heap->GetCPUDescriptorHandleForHeapStart();
+
+        for (UINT i = 0; i < buffer_count; ++i)
+        {
+            g_frames[i].rtv_handle = rtv_handle;
+            if (FAILED(swap_chain->GetBuffer(i, IID_PPV_ARGS(&g_frames[i].render_target))))
+                return;
+            g_device->CreateRenderTargetView(g_frames[i].render_target, nullptr, rtv_handle);
+            rtv_handle.ptr += rtv_size;
+        }
+
+        if (FAILED(g_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, g_command_allocator, nullptr,
+                                               IID_PPV_ARGS(&g_command_list))))
+            return;
+        g_command_list->Close();
+
+        ImGui::CreateContext();
+        ImGui::StyleColorsDark();
+        ImGui::GetIO().IniFilename = nullptr;
+        ImGui::GetIO().LogFilename = nullptr;
+        ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+
+        ImGui_ImplWin32_Init(desc.OutputWindow);
+        ImGui_ImplDX12_Init(g_device, static_cast<int>(buffer_count), desc.BufferDesc.Format, g_srv_heap,
+                            g_srv_heap->GetCPUDescriptorHandleForHeapStart(),
+                            g_srv_heap->GetGPUDescriptorHandleForHeapStart());
+        ImGui_ImplDX12_CreateDeviceObjects();
+
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.set_on_wnd_proc(
+                [](HWND h, UINT msg, WPARAM wp, LPARAM lp) -> std::optional<LRESULT>
+                {
+                    if (!show_menu)
+                        return std::nullopt;
+
+                    ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp);
+                    return true;
+                });
+        std::ignore = mgr.hook_wnd_proc(desc.OutputWindow);
+
+        g_initialized = true;
+    }
+
+    void on_execute_command_lists(ID3D12CommandQueue* queue, UINT, ID3D12CommandList* const*)
+    {
+        if (!g_command_queue)
+            g_command_queue = queue;
+    }
+
+    void on_present(IDXGISwapChain* swap_chain, UINT, UINT)
+    {
+        if (!g_initialized)
+        {
+            if (!g_init_attempted && g_command_queue)
+                init(swap_chain);
+            return;
+        }
+
+        if (!g_command_queue)
+            return;
+
+        if (GetAsyncKeyState(VK_INSERT) & 1)
+            show_menu = !show_menu;
+
+        if (!show_menu)
+            return;
+
+        ImGui_ImplDX12_NewFrame();
+        ImGui_ImplWin32_NewFrame();
+        ImGui::NewFrame();
+        ImGui::GetIO().MouseDrawCursor = true;
+        ImGui::ShowDemoWindow();
+        ImGui::EndFrame();
+
+        const UINT buf_idx = g_swap_chain->GetCurrentBackBufferIndex();
+        auto& fc = g_frames[buf_idx];
+
+        g_command_allocator->Reset();
+        g_command_list->Reset(g_command_allocator, nullptr);
+
+        D3D12_RESOURCE_BARRIER barrier{};
+        barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
+        barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
+        barrier.Transition.pResource = fc.render_target;
+        barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
+        barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
+        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
+        g_command_list->ResourceBarrier(1, &barrier);
+        g_command_list->OMSetRenderTargets(1, &fc.rtv_handle, FALSE, nullptr);
+        g_command_list->SetDescriptorHeaps(1, &g_srv_heap);
+
+        ImGui::Render();
+        ImGui_ImplDX12_RenderDrawData(ImGui::GetDrawData(), g_command_list);
+
+        barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
+        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
+        g_command_list->ResourceBarrier(1, &barrier);
+        g_command_list->Close();
+
+        ID3D12CommandList* cmd_lists[] = {g_command_list};
+        g_command_queue->ExecuteCommandLists(1, cmd_lists);
+    }
+
+    void release_dx12_resources()
+    {
+        for (auto& fc : g_frames)
+        {
+            if (fc.render_target)
+            {
+                fc.render_target->Release();
+                fc.render_target = nullptr;
+            }
+        }
+        g_frames.clear();
+        if (g_command_allocator)
+        {
+            g_command_allocator->Release();
+            g_command_allocator = nullptr;
+        }
+        if (g_command_list)
+        {
+            g_command_list->Release();
+            g_command_list = nullptr;
+        }
+        if (g_srv_heap)
+        {
+            g_srv_heap->Release();
+            g_srv_heap = nullptr;
+        }
+        if (g_rtv_heap)
+        {
+            g_rtv_heap->Release();
+            g_rtv_heap = nullptr;
+        }
+        if (g_swap_chain)
+        {
+            g_swap_chain->Release();
+            g_swap_chain = nullptr;
+        }
+        if (g_device)
+        {
+            g_device->Release();
+            g_device = nullptr;
+        }
+    }
+} // namespace
+
+BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
+{
+    if (reason == DLL_PROCESS_ATTACH)
+    {
+        DisableThreadLibraryCalls(h_instance);
+        CreateThread(
+                nullptr, 0,
+                [](LPVOID) -> DWORD
+                {
+                    while (!GetModuleHandle("d3d12.dll"))
+                        Sleep(100);
+
+                    auto& mgr = omath::hooks::HooksManager::get();
+                    mgr.set_on_present(on_present);
+                    mgr.set_on_execute_command_lists(on_execute_command_lists);
+                    std::ignore = mgr.hook_dx12();
+                    return 0;
+                },
+                nullptr, 0, nullptr);
+    }
+    else if (reason == DLL_PROCESS_DETACH)
+    {
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.unhook_wnd_proc();
+        mgr.unhook_dx12();
+
+        if (g_initialized)
+        {
+            ImGui_ImplDX12_Shutdown();
+            ImGui_ImplWin32_Shutdown();
+            ImGui::DestroyContext();
+        }
+        release_dx12_resources();
+    }
+    return TRUE;
+}

examples/example_dx9_hook/CMakeLists.txt

@@ -0,0 +1,13 @@
+project(example_dx9_hook)
+
+add_library(${PROJECT_NAME} MODULE dllmain.cpp)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    CXX_STANDARD 23
+    MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
+    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
+
+find_package(imgui CONFIG REQUIRED)
+target_link_libraries(${PROJECT_NAME} PRIVATE omath::omath imgui::imgui d3d9)

examples/example_dx9_hook/dllmain.cpp

@@ -0,0 +1,107 @@
+#include <Windows.h>
+#include <d3d9.h>
+#include <imgui.h>
+#include <imgui_impl_dx9.h>
+#include <imgui_impl_win32.h>
+
+#include "omath/hooks/hooks_manager.hpp"
+
+extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND, UINT, WPARAM, LPARAM);
+
+namespace
+{
+    bool g_initialized    = false;
+    bool g_init_attempted = false;
+
+    void init(IDirect3DDevice9* device)
+    {
+        g_init_attempted = true;
+
+        D3DDEVICE_CREATION_PARAMETERS params{};
+        if (FAILED(device->GetCreationParameters(&params)))
+            return;
+
+        ImGui::CreateContext();
+        ImGui::StyleColorsDark();
+        ImGui::GetIO().IniFilename = nullptr;
+        ImGui::GetIO().LogFilename = nullptr;
+        ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange;
+
+        ImGui_ImplWin32_Init(params.hFocusWindow);
+        ImGui_ImplDX9_Init(device);
+
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.set_on_wnd_proc([](HWND h, UINT msg, WPARAM wp, LPARAM lp) -> std::optional<LRESULT> {
+            if (ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp))
+                return 0;
+            return std::nullopt;
+        });
+        mgr.hook_wnd_proc(params.hFocusWindow);
+
+        g_initialized = true;
+    }
+
+    void on_present(IDirect3DDevice9* device, const RECT*, const RECT*, HWND, const RGNDATA*)
+    {
+        if (!g_initialized)
+        {
+            if (!g_init_attempted)
+                init(device);
+            return;
+        }
+
+        ImGui_ImplDX9_NewFrame();
+        ImGui_ImplWin32_NewFrame();
+        ImGui::NewFrame();
+
+        ImGui::SetNextWindowSize({300.f, 80.f}, ImGuiCond_Once);
+        ImGui::SetNextWindowPos({10.f, 10.f}, ImGuiCond_Once);
+        ImGui::Begin("omath | DX9 hook");
+        ImGui::Text("Hook active");
+        ImGui::Text("FPS: %.1f", ImGui::GetIO().Framerate);
+        ImGui::End();
+
+        ImGui::EndFrame();
+        ImGui::Render();
+        ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());
+    }
+
+    void on_reset(IDirect3DDevice9*, D3DPRESENT_PARAMETERS*)
+    {
+        if (g_initialized)
+            ImGui_ImplDX9_InvalidateDeviceObjects();
+    }
+} // namespace
+
+BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
+{
+    if (reason == DLL_PROCESS_ATTACH)
+    {
+        DisableThreadLibraryCalls(h_instance);
+        CreateThread(nullptr, 0, [](LPVOID) -> DWORD
+        {
+            while (!GetModuleHandle("d3d9.dll"))
+                Sleep(100);
+
+            auto& mgr = omath::hooks::HooksManager::get();
+            mgr.set_on_dx9_present(on_present);
+            mgr.set_on_dx9_reset(on_reset);
+            mgr.hook_dx9();
+            return 0;
+        }, nullptr, 0, nullptr);
+    }
+    else if (reason == DLL_PROCESS_DETACH)
+    {
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.unhook_wnd_proc();
+        mgr.unhook_dx9();
+
+        if (g_initialized)
+        {
+            ImGui_ImplDX9_Shutdown();
+            ImGui_ImplWin32_Shutdown();
+            ImGui::DestroyContext();
+        }
+    }
+    return TRUE;
+}

examples/example_hud/gui/main_window.cpp

@@ -71,6 +71,7 @@ namespace imgui_desktop::gui
             ImGui::SliderFloat("X##ent", &m_entity_x, 100.f, vp->Size.x - 100.f);
             ImGui::SliderFloat("Top Y", &m_entity_top_y, 20.f, m_entity_bottom_y - 20.f);
             ImGui::SliderFloat("Bottom Y", &m_entity_bottom_y, m_entity_top_y + 20.f, vp->Size.y - 20.f);
+            ImGui::SliderFloat("Aspect", &m_entity_aspect, 1.f, 10.f);
         }
 
         if (ImGui::CollapsingHeader("Box", ImGuiTreeNodeFlags_DefaultOpen))
@@ -82,6 +83,7 @@ namespace imgui_desktop::gui
             ImGui::Checkbox("Dashed", &m_show_dashed_box);
             ImGui::ColorEdit4("Color##box", reinterpret_cast<float*>(&m_box_color), ImGuiColorEditFlags_NoInputs);
             ImGui::ColorEdit4("Fill##box", reinterpret_cast<float*>(&m_box_fill), ImGuiColorEditFlags_NoInputs);
+            ImGui::ColorEdit4("Outline##box", reinterpret_cast<float*>(&m_box_outline), ImGuiColorEditFlags_NoInputs);
             ImGui::SliderFloat("Thickness", &m_box_thickness, 0.5f, 5.f);
             ImGui::SliderFloat("Corner ratio", &m_corner_ratio, 0.05f, 0.5f);
             ImGui::Separator();
@@ -195,23 +197,33 @@ namespace imgui_desktop::gui
         const DashedBar dbar{m_bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width,
                              m_bar_value, m_bar_dash_len,      m_bar_dash_gap, m_bar_offset};
 
-        omath::hud::EntityOverlay({m_entity_x, m_entity_top_y}, {m_entity_x, m_entity_bottom_y},
+        auto outline_helper = [](const bool is_outline) -> Outlined
+        {
+            return is_outline ? Outlined::On : Outlined::Off;
+        };
+        omath::hud::EntityOverlay({m_entity_x, m_entity_top_y}, {m_entity_x, m_entity_bottom_y}, m_entity_aspect,
                                   std::make_shared<omath::hud::ImguiHudRenderer>())
                 .contents(
                         // ── Boxes ────────────────────────────────────────────────────
-                        when(m_show_box, Box{m_box_color, m_box_fill, m_box_thickness}),
+                        when(m_show_box, Box{m_box_color, m_box_fill, m_box_outline, m_box_thickness}),
                         when(m_show_cornered_box, CorneredBox{omath::Color::from_rgba(255, 0, 255, 255), m_box_fill,
-                                                              m_corner_ratio, m_box_thickness}),
+                                                              m_box_outline, m_corner_ratio, m_box_thickness}),
                         when(m_show_dashed_box, DashedBox{m_dash_color, m_dash_len, m_dash_gap, m_dash_thickness}),
                         RightSide{
                                 when(m_show_right_bar, bar),
                                 when(m_show_right_dashed_bar, dbar),
-                                when(m_show_right_labels,
+                                when(m_show_right_labels, Label{{0.f, 1.f, 0.f, 1.f},
-                                     Label{{0.f, 1.f, 0.f, 1.f}, m_label_offset, m_outlined, "Health: 100/100"}),
+                                                                m_label_offset,
-                                when(m_show_right_labels,
+                                                                outline_helper(m_outlined),
-                                     Label{{1.f, 0.f, 0.f, 1.f}, m_label_offset, m_outlined, "Shield: 125/125"}),
+                                                                "Health: 100/100"}),
-                                when(m_show_right_labels,
+                                when(m_show_right_labels, Label{{1.f, 0.f, 0.f, 1.f},
-                                     Label{{1.f, 0.f, 1.f, 1.f}, m_label_offset, m_outlined, "*LOCKED*"}),
+                                                                m_label_offset,
+                                                                outline_helper(m_outlined),
+                                                                "Shield: 125/125"}),
+                                when(m_show_right_labels, Label{{1.f, 0.f, 1.f, 1.f},
+                                                                m_label_offset,
+                                                                outline_helper(m_outlined),
+                                                                "*LOCKED*"}),
 
                                 SpaceVertical{10},
                                 when(m_show_ring, ProgressRing{m_ring_color, m_ring_bg, m_ring_radius, m_ring_ratio,
@@ -220,33 +232,41 @@ namespace imgui_desktop::gui
                         LeftSide{
                                 when(m_show_left_bar, bar),
                                 when(m_show_left_dashed_bar, dbar),
-                                when(m_show_left_labels, Label{omath::Color::from_rgba(255, 128, 0, 255),
+                                when(m_show_left_labels,
-                                                               m_label_offset, m_outlined, "Armor: 75"}),
+                                     Label{omath::Color::from_rgba(255, 128, 0, 255), m_label_offset,
-                                when(m_show_left_labels, Label{omath::Color::from_rgba(0, 200, 255, 255),
+                                           outline_helper(m_outlined), "Armor: 75"}),
-                                                               m_label_offset, m_outlined, "Level: 42"}),
+                                when(m_show_left_labels,
+                                     Label{omath::Color::from_rgba(0, 200, 255, 255), m_label_offset,
+                                           outline_helper(m_outlined), "Level: 42"}),
                         },
                         TopSide{
                                 when(m_show_top_bar, bar),
                                 when(m_show_top_dashed_bar, dbar),
-                                when(m_show_centered_top, Centered{Label{omath::Color::from_rgba(0, 255, 255, 255),
+                                when(m_show_centered_top,
-                                                                         m_label_offset, m_outlined, "*VISIBLE*"}}),
+                                     Centered{Label{omath::Color::from_rgba(0, 255, 255, 255), m_label_offset,
+                                                    outline_helper(m_outlined), "*VISIBLE*"}}),
                                 when(m_show_top_labels, Label{omath::Color::from_rgba(255, 255, 0, 255), m_label_offset,
-                                                              m_outlined, "*SCOPED*"}),
+                                                              outline_helper(m_outlined), "*SCOPED*"}),
                                 when(m_show_top_labels, Label{omath::Color::from_rgba(255, 0, 0, 255), m_label_offset,
-                                                              m_outlined, "*BLEEDING*"}),
+                                                              outline_helper(m_outlined), "*BLEEDING*"}),
                         },
                         BottomSide{
                                 when(m_show_bottom_bar, bar),
                                 when(m_show_bottom_dashed_bar, dbar),
-                                when(m_show_centered_bottom, Centered{Label{omath::Color::from_rgba(255, 255, 255, 255),
+                                when(m_show_centered_bottom,
-                                                                            m_label_offset, m_outlined, "PlayerName"}}),
+                                     Centered{Label{omath::Color::from_rgba(255, 255, 255, 255), m_label_offset,
+                                                    outline_helper(m_outlined), "PlayerName"}}),
                                 when(m_show_bottom_labels, Label{omath::Color::from_rgba(200, 200, 0, 255),
-                                                                 m_label_offset, m_outlined, "42m"}),
+                                                                 m_label_offset, outline_helper(m_outlined), "42m"}),
                         },
-                        when(m_show_aim, AimDot{{m_entity_x, m_entity_top_y+40.f}, m_aim_color, m_aim_radius}),
+                        when(m_show_aim, AimDot{{m_entity_x, m_entity_top_y + 40.f}, m_aim_color, m_aim_radius}),
                         when(m_show_scan, ScanMarker{m_scan_color, m_scan_outline, m_scan_outline_thickness}),
                         when(m_show_skeleton, Skeleton{m_skel_color, m_skel_thickness}),
-                        when(m_show_proj, ProjectileAim{{m_proj_pos_x, m_proj_pos_y}, m_proj_color, m_proj_size, m_proj_line_width, static_cast<ProjectileAim::Figure>(m_proj_figure)}),
+                        when(m_show_proj, ProjectileAim{{m_proj_pos_x, m_proj_pos_y},
+                                                        m_proj_color,
+                                                        m_proj_size,
+                                                        m_proj_line_width,
+                                                        static_cast<ProjectileAim::Figure>(m_proj_figure)}),
                         when(m_show_snap, SnapLine{{vp->Size.x / 2.f, vp->Size.y}, m_snap_color, m_snap_width}));
     }
 

examples/example_hud/gui/main_window.hpp

@@ -26,11 +26,11 @@ namespace imgui_desktop::gui
         bool m_opened = true;
 
         // Entity
-        float m_entity_x = 550.f, m_entity_top_y = 150.f, m_entity_bottom_y = 450.f;
+        float m_entity_x = 550.f, m_entity_top_y = 150.f, m_entity_bottom_y = 450.f, m_entity_aspect = 4.f;
-
         // Box
         omath::Color m_box_color{1.f, 1.f, 1.f, 1.f};
         omath::Color m_box_fill{0.f, 0.f, 0.f, 0.f};
+        omath::Color m_box_outline{0.f, 0.f, 0.f, 0.f};
         float m_box_thickness = 1.f, m_corner_ratio = 0.2f;
         bool m_show_box = true, m_show_cornered_box = true, m_show_dashed_box = false;
 

examples/example_opengl_hook/CMakeLists.txt

@@ -0,0 +1,13 @@
+project(example_opengl_hook)
+
+add_library(${PROJECT_NAME} MODULE dllmain.cpp)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    CXX_STANDARD 23
+    MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
+    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
+
+find_package(imgui CONFIG REQUIRED)
+target_link_libraries(${PROJECT_NAME} PRIVATE omath::omath imgui::imgui opengl32 gdi32)

examples/example_opengl_hook/dllmain.cpp

@@ -0,0 +1,116 @@
+#include "omath/hooks/hooks_manager.hpp"
+#include <Windows.h>
+#include <chrono>
+#include <imgui.h>
+#include <imgui_impl_opengl3.h>
+#include <imgui_impl_win32.h>
+#include <optional>
+#include <thread>
+
+extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND, UINT, WPARAM, LPARAM);
+
+namespace
+{
+    bool g_initialized = false;
+    bool g_init_attempted = false;
+    bool g_show_menu = true;
+
+    constexpr auto g_module_wait_delay = std::chrono::milliseconds{100};
+
+    void init(HDC hdc)
+    {
+        g_init_attempted = true;
+
+        const HWND hwnd = WindowFromDC(hdc);
+        if (!hwnd)
+            return;
+
+        ImGui::CreateContext();
+        ImGui::StyleColorsDark();
+        ImGui::GetIO().IniFilename = nullptr;
+        ImGui::GetIO().LogFilename = nullptr;
+        ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange;
+
+        ImGui_ImplWin32_Init(hwnd);
+        ImGui_ImplOpenGL3_Init();
+
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.set_on_wnd_proc(
+                [](HWND h, UINT msg, WPARAM wp, LPARAM lp) -> std::optional<LRESULT>
+                {
+                    if (!g_show_menu)
+                        return std::nullopt;
+
+                    if (ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp))
+                        return 0;
+                    return std::nullopt;
+                });
+        (void)mgr.hook_wnd_proc(hwnd);
+
+        g_initialized = true;
+    }
+
+    void on_swap_buffers(HDC hdc)
+    {
+        if (!g_initialized)
+        {
+            if (!g_init_attempted)
+                init(hdc);
+            return;
+        }
+
+        if (GetAsyncKeyState(VK_INSERT) & 1)
+            g_show_menu = !g_show_menu;
+
+        ImGui_ImplOpenGL3_NewFrame();
+        ImGui_ImplWin32_NewFrame();
+        ImGui::NewFrame();
+
+        if (g_show_menu)
+        {
+            ImGui::SetNextWindowSize({300.f, 100.f}, ImGuiCond_Once);
+            ImGui::SetNextWindowPos({10.f, 10.f}, ImGuiCond_Once);
+            ImGui::Begin("omath | OpenGL hook");
+            ImGui::Text("Hook active");
+            ImGui::Text("FPS: %.1f", ImGui::GetIO().Framerate);
+            ImGui::Text("INSERT toggles this window");
+            ImGui::End();
+        }
+
+        ImGui::Render();
+        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+    }
+
+    void hook_when_opengl_is_loaded()
+    {
+        while (!GetModuleHandle("opengl32.dll"))
+            std::this_thread::sleep_for(g_module_wait_delay);
+
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.set_on_opengl_swap_buffers(on_swap_buffers);
+        (void)mgr.hook_opengl();
+    }
+} // namespace
+
+BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
+{
+    if (reason == DLL_PROCESS_ATTACH)
+    {
+        DisableThreadLibraryCalls(h_instance);
+        std::thread{hook_when_opengl_is_loaded}.detach();
+    }
+    else if (reason == DLL_PROCESS_DETACH)
+    {
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.unhook_wnd_proc();
+        mgr.unhook_opengl();
+
+        if (g_initialized)
+        {
+            ImGui_ImplOpenGL3_Shutdown();
+            ImGui_ImplWin32_Shutdown();
+            ImGui::DestroyContext();
+        }
+    }
+    return true;
+}

include/omath/3d_primitives/obb.hpp

@@ -0,0 +1,37 @@
+//
+// Created by Vladislav on 07.05.2026.
+//
+
+#pragma once
+#include "omath/linear_algebra/vector3.hpp"
+#include <array>
+#include <type_traits>
+
+namespace omath::primitives
+{
+    // Oriented bounding box: a rectangular cuboid defined by a center, three
+    // orthonormal local axes, and the half-size along each of those axes.
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    struct Obb final
+    {
+        Vector3<Type> center;
+        Vector3<Type> axis_x;
+        Vector3<Type> axis_y;
+        Vector3<Type> axis_z;
+        Vector3<Type> half_extents;
+
+        [[nodiscard]]
+        constexpr std::array<Vector3<Type>, 8> vertices() const noexcept
+        {
+            const auto ex = axis_x * half_extents.x;
+            const auto ey = axis_y * half_extents.y;
+            const auto ez = axis_z * half_extents.z;
+
+            return {
+                    center - ex - ey - ez, center + ex - ey - ez, center - ex + ey - ez, center + ex + ey - ez,
+                    center - ex - ey + ez, center + ex - ey + ez, center - ex + ey + ez, center + ex + ey + ez,
+            };
+        }
+    };
+} // namespace omath::primitives

include/omath/collision/epa_algorithm.hpp

@@ -49,7 +49,7 @@ namespace omath::collision
         struct Params final
         {
             int max_iterations{64};
-            FloatingType tolerance{1e-4}; // absolute tolerance on distance growth
+            FloatingType tolerance{1e-4f}; // absolute tolerance on distance growth
         };
         // Precondition: simplex.size()==4 and contains the origin.
         [[nodiscard]]

include/omath/collision/line_tracer.hpp

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "omath/3d_primitives/aabb.hpp"
+#include "omath/3d_primitives/obb.hpp"
 #include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
 
@@ -36,6 +37,7 @@ namespace omath::collision
     {
         using TriangleType = Triangle<typename RayType::VectorType>;
         using AABBType = primitives::Aabb<typename RayType::VectorType::ContainedType>;
+        using OBBType = primitives::Obb<typename RayType::VectorType::ContainedType>;
 
     public:
         LineTracer() = delete;
@@ -137,6 +139,61 @@ namespace omath::collision
             return ray.start + dir * t_hit;
         }
 
+        // Slab method ray-OBB intersection. Project the ray into the OBB's local frame
+        // (axes are orthonormal, so the inverse rotation is just a transpose / dot products),
+        // then run the standard slab test against the local box [-half_extents, +half_extents].
+        // The ray parameter t is invariant under rigid transform, so the hit point is recovered
+        // in world space as ray.start + dir * t_hit.
+        [[nodiscard]]
+        constexpr static auto get_ray_hit_point(const RayType& ray, const OBBType& obb) noexcept
+        {
+            using T = typename RayType::VectorType::ContainedType;
+
+            const auto offset = ray.start - obb.center;
+            const auto dir = ray.direction_vector();
+
+            const T local_start[3] = {offset.dot(obb.axis_x), offset.dot(obb.axis_y), offset.dot(obb.axis_z)};
+            const T local_dir[3] = {dir.dot(obb.axis_x), dir.dot(obb.axis_y), dir.dot(obb.axis_z)};
+            const T half[3] = {obb.half_extents.x, obb.half_extents.y, obb.half_extents.z};
+
+            auto t_min = -std::numeric_limits<T>::infinity();
+            auto t_max = std::numeric_limits<T>::infinity();
+
+            const auto process_axis = [&](const T& d, const T& origin, const T& h) -> bool
+            {
+                constexpr T k_epsilon = std::numeric_limits<T>::epsilon();
+                if (std::abs(d) < k_epsilon)
+                    return origin >= -h && origin <= h;
+
+                const T inv = T(1) / d;
+                T t0 = (-h - origin) * inv;
+                T t1 = (h - origin) * inv;
+                if (t0 > t1)
+                    std::swap(t0, t1);
+
+                t_min = std::max(t_min, t0);
+                t_max = std::min(t_max, t1);
+                return t_min <= t_max;
+            };
+
+            if (!process_axis(local_dir[0], local_start[0], half[0]))
+                return ray.end;
+            if (!process_axis(local_dir[1], local_start[1], half[1]))
+                return ray.end;
+            if (!process_axis(local_dir[2], local_start[2], half[2]))
+                return ray.end;
+
+            const T t_hit = std::max(T(0), t_min);
+
+            if (t_max < T(0))
+                return ray.end; // box entirely behind origin
+
+            if (!ray.infinite_length && t_hit > T(1))
+                return ray.end; // box beyond ray endpoint
+
+            return ray.start + dir * t_hit;
+        }
+
         template<class MeshType>
         [[nodiscard]]
         constexpr static auto get_ray_hit_point(const RayType& ray, const MeshType& mesh) noexcept

include/omath/engines/cry_engine/constants.hpp

@@ -15,7 +15,7 @@ namespace omath::cry_engine
     constexpr Vector3<float> k_abs_forward = {0, 1, 0};
 
     using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
-    using Mat3X3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3X3 = Mat<3, 3, 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>;

include/omath/engines/cry_engine/formulas.hpp

@@ -7,27 +7,87 @@
 
 namespace omath::cry_engine
 {
-    [[nodiscard]]
+    [[nodiscard("rotation matrix result should not be discarded")]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.roll)
+               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
+    }
 
-    [[nodiscard]]
+    [[nodiscard("forward vector result should not be discarded")]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    constexpr Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]]
+    [[nodiscard("up vector result should not be discarded")]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) 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)};
+    }
+
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr 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);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.x),
+                YawAngle::from_degrees(angles.z),
+                RollAngle::from_degrees(angles.y),
+        };
+    }
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4
+    calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near_plane,
+                                       const float far_plane,
+                                       const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         return units / static_cast<FloatingType>(100);
@@ -35,7 +95,7 @@ namespace omath::cry_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units;
@@ -43,7 +103,7 @@ namespace omath::cry_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -51,7 +111,7 @@ namespace omath::cry_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         return centimeters * static_cast<FloatingType>(100);
@@ -59,7 +119,7 @@ namespace omath::cry_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return meters;
@@ -67,7 +127,7 @@ namespace omath::cry_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -4,21 +4,36 @@
 
 #pragma once
 #include "omath/engines/cry_engine/formulas.hpp"
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
-
 namespace omath::cry_engine
 {
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("look-at angle result should not be discarded")]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
+            return {PitchAngle::from_radians(internal::asin(direction.z)),
+                    YawAngle::from_radians(-internal::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)};
+        }
 
-        [[nodiscard]]
+        [[nodiscard("view matrix result should not be discarded")]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+        constexpr 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,
+            return cry_engine::calc_view_matrix(angles, cam_origin);
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::cry_engine

include/omath/engines/cry_engine/traits/mesh_trait.hpp

@@ -10,7 +10,7 @@ namespace omath::cry_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return cry_engine::rotation_matrix(rotation);

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

@@ -12,6 +12,7 @@ namespace omath::cry_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -25,7 +26,7 @@ namespace omath::cry_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -36,19 +37,19 @@ namespace omath::cry_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.y * delta.y);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.z;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -60,13 +61,13 @@ namespace omath::cry_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
             return angles::radians_to_degrees(std::asin(direction.z));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();

include/omath/engines/frostbite_engine/formulas.hpp

@@ -7,27 +7,91 @@
 
 namespace omath::frostbite_engine
 {
-    [[nodiscard]]
+    [[nodiscard("rotation matrix result should not be discarded")]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
+    [[nodiscard("forward vector result should not be discarded")]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    constexpr Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]]
+    [[nodiscard("up vector result should not be discarded")]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) 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)};
+    }
+
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr 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);
+    }
+
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.x),
+                YawAngle::from_degrees(angles.y),
+                RollAngle::from_degrees(angles.z),
+        };
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         return units / static_cast<FloatingType>(100);
@@ -35,7 +99,7 @@ namespace omath::frostbite_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units;
@@ -43,7 +107,7 @@ namespace omath::frostbite_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -51,7 +115,7 @@ namespace omath::frostbite_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         return centimeters * static_cast<FloatingType>(100);
@@ -59,7 +123,7 @@ namespace omath::frostbite_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return meters;
@@ -67,7 +131,7 @@ namespace omath::frostbite_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -4,6 +4,7 @@
 
 #pragma once
 #include "omath/engines/frostbite_engine/formulas.hpp"
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::frostbite_engine
@@ -11,14 +12,30 @@ namespace omath::frostbite_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("look-at angle result should not be discarded")]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
+            return {PitchAngle::from_radians(-internal::asin(direction.y)),
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+                    YawAngle::from_radians(internal::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)};
-        [[nodiscard]]
+        }
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return frostbite_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
-} // namespace omath::unreal_engine
+} // namespace omath::frostbite_engine

include/omath/engines/frostbite_engine/traits/mesh_trait.hpp

@@ -10,7 +10,7 @@ namespace omath::frostbite_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return frostbite_engine::rotation_matrix(rotation);

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

@@ -12,6 +12,7 @@ namespace omath::frostbite_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -25,7 +26,7 @@ namespace omath::frostbite_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -36,19 +37,19 @@ namespace omath::frostbite_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.z * delta.z);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.y;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -60,13 +61,13 @@ namespace omath::frostbite_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
             return angles::radians_to_degrees(std::asin(direction.y));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();

include/omath/engines/iw_engine/formulas.hpp

@@ -7,27 +7,89 @@
 
 namespace omath::iw_engine
 {
-    [[nodiscard]]
+    [[nodiscard("rotation matrix result should not be discarded")]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
+    [[nodiscard("forward vector result should not be discarded")]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    constexpr Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]]
+    [[nodiscard("right vector result should not be discarded")]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+    constexpr Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
+    [[nodiscard("up vector result should not be discarded")]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) 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)};
+    }
+
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr 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);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.y),
+                YawAngle::from_degrees(angles.z),
+                RollAngle::from_degrees(angles.x),
+        };
+    }
+
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr 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);
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        constexpr float k_source_reference_aspect = 4.f / 3.f;
+        const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect);
+
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    vertical_fov, aspect_ratio, near_plane, far_plane);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    vertical_fov, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
@@ -36,7 +98,7 @@ namespace omath::iw_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units_to_centimeters(units) / static_cast<FloatingType>(100);
@@ -44,7 +106,7 @@ namespace omath::iw_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -52,7 +114,7 @@ namespace omath::iw_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
@@ -61,7 +123,7 @@ namespace omath::iw_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return centimeters_to_units(meters * static_cast<FloatingType>(100));
@@ -69,7 +131,7 @@ namespace omath::iw_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -3,7 +3,8 @@
 //
 
 #pragma once
-#include "omath/engines/iw_engine/constants.hpp"
+#include "omath/engines/iw_engine/formulas.hpp"
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::iw_engine
@@ -11,14 +12,30 @@ namespace omath::iw_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("look-at angle result should not be discarded")]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
+            return {PitchAngle::from_radians(-internal::asin(direction.z)),
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+                    YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
-        [[nodiscard]]
+        }
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return iw_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::iw_engine

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

@@ -10,7 +10,7 @@ namespace omath::iw_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return iw_engine::rotation_matrix(rotation);

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

@@ -13,6 +13,7 @@ namespace omath::iw_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -26,7 +27,7 @@ namespace omath::iw_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -37,19 +38,19 @@ namespace omath::iw_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.y * delta.y);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.z;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -61,7 +62,7 @@ namespace omath::iw_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto distance = origin.distance_to(view_to);
@@ -69,7 +70,7 @@ namespace omath::iw_engine
 
             return angles::radians_to_degrees(std::asin(delta.z / distance));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto delta = view_to - origin;

include/omath/engines/opengl_engine/formulas.hpp

@@ -6,27 +6,93 @@
 
 namespace omath::opengl_engine
 {
-    [[nodiscard]]
+    [[nodiscard("rotation matrix result should not be discarded")]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
+    [[nodiscard("forward vector result should not be discarded")]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    constexpr 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);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr 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);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]]
+    [[nodiscard("up vector result should not be discarded")]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) 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)};
+    }
+
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return mat_look_at_right_handed(cam_origin, cam_origin + forward_vector(angles), up_vector(angles));
+    }
+
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll)
+               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(angles.yaw)
+               * mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(angles.pitch);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.x),
+                YawAngle::from_degrees(angles.y),
+                RollAngle::from_degrees(angles.z),
+        };
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_right_handed_vertical_fov<float, MatStoreType::COLUMN_MAJOR,
+                                                             NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_right_handed_vertical_fov<float, MatStoreType::COLUMN_MAJOR,
+                                                             NDCDepthRange::ZERO_TO_ONE>(field_of_view, aspect_ratio,
+                                                                                         near_plane, far_plane);
+
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         return units / static_cast<FloatingType>(100);
@@ -34,7 +100,7 @@ namespace omath::opengl_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units;
@@ -42,7 +108,7 @@ namespace omath::opengl_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -50,7 +116,7 @@ namespace omath::opengl_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         return centimeters * static_cast<FloatingType>(100);
@@ -58,7 +124,7 @@ namespace omath::opengl_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return meters;
@@ -66,7 +132,7 @@ namespace omath::opengl_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -3,7 +3,8 @@
 //
 
 #pragma once
-#include "omath/engines/opengl_engine/constants.hpp"
+#include "omath/engines/opengl_engine/formulas.hpp"
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::opengl_engine
@@ -11,14 +12,30 @@ namespace omath::opengl_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("look-at angle result should not be discarded")]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
+            return {PitchAngle::from_radians(internal::asin(direction.y)),
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+                    YawAngle::from_radians(-internal::atan2(direction.x, -direction.z)), RollAngle::from_radians(0.f)};
-        [[nodiscard]]
+        }
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return opengl_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::opengl_engine

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

@@ -10,7 +10,7 @@ namespace omath::opengl_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return opengl_engine::rotation_matrix(rotation);

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

@@ -12,6 +12,7 @@ namespace omath::opengl_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -25,7 +26,7 @@ namespace omath::opengl_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -36,19 +37,19 @@ namespace omath::opengl_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.z * delta.z);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.y;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -60,13 +61,13 @@ namespace omath::opengl_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
             return angles::radians_to_degrees(std::asin(direction.y));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();

include/omath/engines/rage_engine/camera.hpp

@@ -0,0 +1,13 @@
+//
+// Created by Orange on 6/3/2026.
+//
+
+#pragma once
+#include "omath/engines/rage_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+#include "traits/camera_trait.hpp"
+
+namespace omath::rage_engine
+{
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait, NDCDepthRange::ZERO_TO_ONE>;
+} // namespace omath::rage_engine

include/omath/engines/rage_engine/constants.hpp

@@ -0,0 +1,25 @@
+//
+// Created by Orange on 6/3/2026.
+//
+
+#pragma once
+#include "omath/linear_algebra/mat.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <omath/trigonometry/angle.hpp>
+#include <omath/trigonometry/view_angles.hpp>
+
+namespace omath::rage_engine
+{
+    constexpr Vector3<float> k_abs_up = {0, 0, 1};
+    constexpr Vector3<float> k_abs_right = {1, 0, 0};
+    constexpr Vector3<float> k_abs_forward = {0, 1, 0};
+
+    using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3X3 = Mat<3, 3, 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::rage_engine

include/omath/engines/rage_engine/formulas.hpp

@@ -0,0 +1,140 @@
+//
+// Created by Orange on 6/3/2026.
+//
+
+#pragma once
+#include "omath/engines/rage_engine/constants.hpp"
+#include <type_traits>
+
+namespace omath::rage_engine
+{
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+
+    [[nodiscard("forward vector result should not be discarded")]]
+    constexpr 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)};
+    }
+
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr 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)};
+    }
+
+    [[nodiscard("up vector result should not be discarded")]]
+    constexpr 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)};
+    }
+
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr 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);
+    }
+
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.roll)
+               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.x),
+                YawAngle::from_degrees(angles.z),
+                RollAngle::from_degrees(angles.y),
+        };
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4
+    calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near_plane,
+                                       const float far_plane,
+                                       const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard("centimeters value should not be discarded")]]
+    constexpr FloatingType units_to_centimeters(const FloatingType& units)
+    {
+        return units / static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard("meters value should not be discarded")]]
+    constexpr FloatingType units_to_meters(const FloatingType& units)
+    {
+        return units;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard("kilometers value should not be discarded")]]
+    constexpr FloatingType units_to_kilometers(const FloatingType& units)
+    {
+        return units_to_meters(units) / static_cast<FloatingType>(1000);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard("units value should not be discarded")]]
+    constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
+    {
+        return centimeters * static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard("units value should not be discarded")]]
+    constexpr FloatingType meters_to_units(const FloatingType& meters)
+    {
+        return meters;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard("units value should not be discarded")]]
+    constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
+    {
+        return meters_to_units(kilometers * static_cast<FloatingType>(1000));
+    }
+} // namespace omath::rage_engine

include/omath/engines/rage_engine/mesh.hpp

@@ -0,0 +1,13 @@
+//
+// Created by Orange on 6/3/2026.
+//
+
+#pragma once
+#include "constants.hpp"
+#include "omath/3d_primitives/mesh.hpp"
+#include "traits/mesh_trait.hpp"
+
+namespace omath::rage_engine
+{
+    using Mesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait>;
+} // namespace omath::rage_engine

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

@@ -0,0 +1,41 @@
+//
+// Created by Orange on 6/3/2026.
+//
+
+#pragma once
+#include "omath/engines/rage_engine/formulas.hpp"
+#include "omath/internal/constexpr_math.hpp"
+#include "omath/projection/camera.hpp"
+
+namespace omath::rage_engine
+{
+    class CameraTrait final
+    {
+    public:
+        [[nodiscard("look-at angle result should not be discarded")]]
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
+
+            return {PitchAngle::from_radians(internal::asin(direction.z)),
+                    YawAngle::from_radians(-internal::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return rage_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
+    };
+
+} // namespace omath::rage_engine

include/omath/engines/rage_engine/traits/mesh_trait.hpp

@@ -0,0 +1,20 @@
+//
+// Created by Orange on 6/3/2026.
+//
+
+#pragma once
+#include <omath/engines/rage_engine/constants.hpp>
+#include <omath/engines/rage_engine/formulas.hpp>
+
+namespace omath::rage_engine
+{
+    class MeshTrait final
+    {
+    public:
+        [[nodiscard("rotation matrix result should not be discarded")]]
+        static Mat4X4 rotation_matrix(const ViewAngles& rotation)
+        {
+            return rage_engine::rotation_matrix(rotation);
+        }
+    };
+} // namespace omath::rage_engine

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

@@ -0,0 +1,77 @@
+//
+// Created by Orange on 6/3/2026.
+//
+
+#pragma once
+#include "omath/engines/rage_engine/formulas.hpp"
+#include "omath/projectile_prediction/projectile.hpp"
+#include "omath/projectile_prediction/target.hpp"
+#include <optional>
+
+namespace omath::rage_engine
+{
+    class PredEngineTrait final
+    {
+    public:
+        [[nodiscard("projectile position result should not be discarded")]]
+        constexpr static Vector3<float>
+        predict_projectile_position(const projectile_prediction::Projectile<float>& projectile, const float pitch,
+                                    const float yaw, const float time, const float gravity) noexcept
+        {
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
+                               + 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("target position result should not be discarded")]]
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& 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("2d distance result should not be discarded")]]
+        static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
+        {
+            return std::sqrt(delta.x * delta.x + delta.y * delta.y);
+        }
+
+        [[nodiscard("height coordinate result should not be discarded")]]
+        constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
+        {
+            return vec.z;
+        }
+
+        [[nodiscard("viewpoint result should not be discarded")]]
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& 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};
+        }
+        [[nodiscard("pitch angle result should not be discarded")]]
+        static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto direction = (view_to - origin).normalized();
+            return angles::radians_to_degrees(std::asin(direction.z));
+        }
+        [[nodiscard("yaw angle result should not be discarded")]]
+        static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        {
+            const auto direction = (view_to - origin).normalized();
+
+            return angles::radians_to_degrees(-std::atan2(direction.x, direction.y));
+        };
+    };
+} // namespace omath::rage_engine

include/omath/engines/source_engine/formulas.hpp

@@ -6,27 +6,89 @@
 
 namespace omath::source_engine
 {
-    [[nodiscard]]
+    [[nodiscard("rotation matrix result should not be discarded")]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
+    [[nodiscard("forward vector result should not be discarded")]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+    constexpr Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]]
+    [[nodiscard("rotation matrix result should not be discarded")]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+    constexpr 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);
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
 
-    [[nodiscard]]
+    [[nodiscard("scale result should not be discarded")]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.y),
+                YawAngle::from_degrees(angles.z),
+                RollAngle::from_degrees(angles.x),
+        };
+    }
+
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr 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)};
+    }
+
+    [[nodiscard("up vector result should not be discarded")]]
+    constexpr 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)};
+    }
+
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr 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);
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        constexpr float k_source_reference_aspect = 4.f / 3.f;
+        const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect);
+
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    vertical_fov, aspect_ratio, near_plane, far_plane);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    vertical_fov, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
@@ -35,7 +97,7 @@ namespace omath::source_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units_to_centimeters(units) / static_cast<FloatingType>(100);
@@ -43,7 +105,7 @@ namespace omath::source_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -51,7 +113,7 @@ namespace omath::source_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
@@ -60,7 +122,7 @@ namespace omath::source_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return centimeters_to_units(meters * static_cast<FloatingType>(100));
@@ -68,7 +130,7 @@ namespace omath::source_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -3,7 +3,8 @@
 //
 
 #pragma once
-#include "omath/engines/source_engine/constants.hpp"
+#include "omath/engines/source_engine/formulas.hpp"
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::source_engine
@@ -11,14 +12,30 @@ namespace omath::source_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("look-at angle result should not be discarded")]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
+            return {PitchAngle::from_radians(-internal::asin(direction.z)),
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+                    YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
-        [[nodiscard]]
+        }
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return source_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::source_engine

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

@@ -10,7 +10,7 @@ namespace omath::source_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return source_engine::rotation_matrix(rotation);

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

@@ -13,6 +13,7 @@ namespace omath::source_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -26,7 +27,7 @@ namespace omath::source_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -37,19 +38,19 @@ namespace omath::source_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.y * delta.y);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.z;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -61,7 +62,7 @@ namespace omath::source_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto distance = origin.distance_to(view_to);
@@ -69,7 +70,7 @@ namespace omath::source_engine
 
             return angles::radians_to_degrees(std::asin(delta.z / distance));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto delta = view_to - origin;

include/omath/engines/unity_engine/formulas.hpp

@@ -7,27 +7,90 @@
 
 namespace omath::unity_engine
 {
-    [[nodiscard]]
+    [[nodiscard("rotation matrix result should not be discarded")]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
+    [[nodiscard("forward vector result should not be discarded")]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    constexpr Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]]
+    [[nodiscard("up vector result should not be discarded")]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) 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)};
+    }
+
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr 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);
+    }
+
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.x),
+                YawAngle::from_degrees(angles.y),
+                RollAngle::from_degrees(angles.z),
+        };
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return omath::mat_perspective_right_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                                    NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return omath::mat_perspective_right_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                                    NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         return units / static_cast<FloatingType>(100);
@@ -35,7 +98,7 @@ namespace omath::unity_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units;
@@ -43,7 +106,7 @@ namespace omath::unity_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -51,7 +114,7 @@ namespace omath::unity_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         return centimeters * static_cast<FloatingType>(100);
@@ -59,7 +122,7 @@ namespace omath::unity_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return meters;
@@ -67,7 +130,7 @@ namespace omath::unity_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -4,6 +4,7 @@
 
 #pragma once
 #include "omath/engines/unity_engine/formulas.hpp"
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::unity_engine
@@ -11,14 +12,30 @@ namespace omath::unity_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("look-at angle result should not be discarded")]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
+            return {PitchAngle::from_radians(-internal::asin(direction.y)),
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+                    YawAngle::from_radians(internal::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)};
-        [[nodiscard]]
+        }
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return unity_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::unity_engine

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

@@ -10,7 +10,7 @@ namespace omath::unity_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return unity_engine::rotation_matrix(rotation);

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

@@ -12,6 +12,7 @@ namespace omath::unity_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -25,7 +26,7 @@ namespace omath::unity_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -36,19 +37,19 @@ namespace omath::unity_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.z * delta.z);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.y;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -60,13 +61,13 @@ namespace omath::unity_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
             return angles::radians_to_degrees(std::asin(direction.y));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();

include/omath/engines/unreal_engine/formulas.hpp

@@ -7,27 +7,90 @@
 
 namespace omath::unreal_engine
 {
-    [[nodiscard]]
+    [[nodiscard("rotation matrix result should not be discarded")]]
-    Vector3<double> forward_vector(const ViewAngles& angles) noexcept;
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
+    [[nodiscard("forward vector result should not be discarded")]]
-    Vector3<double> right_vector(const ViewAngles& angles) noexcept;
+    constexpr Vector3<double> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Vector3<double> up_vector(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr Vector3<double> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]]
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+    }
 
-    [[nodiscard]]
+    [[nodiscard("up vector result should not be discarded")]]
-    Mat4X4 calc_perspective_projection_matrix(double field_of_view, double aspect_ratio, double near, double far,
+    constexpr Vector3<double> up_vector(const ViewAngles& angles) noexcept
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) 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)};
+    }
+
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept
+    {
+        return mat_camera_view<double, MatStoreType::ROW_MAJOR>(forward_vector(angles), right_vector(angles),
+                                                                up_vector(angles), cam_origin);
+    }
+
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<double, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_y<double, MatStoreType::ROW_MAJOR>(-angles.pitch)
+               * mat_rotation_axis_x<double, MatStoreType::ROW_MAJOR>(-angles.roll);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<double> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<double> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(-angles.y),
+                YawAngle::from_degrees(angles.z),
+                RollAngle::from_degrees(-angles.x),
+        };
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const double field_of_view, const double aspect_ratio, const double near_plane, const double far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_horizontal_fov<double, MatStoreType::ROW_MAJOR,
+                                                              NDCDepthRange::ZERO_TO_ONE>(field_of_view, aspect_ratio,
+                                                                                          near_plane, far_plane);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_horizontal_fov<double, MatStoreType::ROW_MAJOR,
+                                                              NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         return units;
@@ -35,7 +98,7 @@ namespace omath::unreal_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units / static_cast<FloatingType>(100);
@@ -43,7 +106,7 @@ namespace omath::unreal_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -51,7 +114,7 @@ namespace omath::unreal_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         return centimeters;
@@ -59,7 +122,7 @@ namespace omath::unreal_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return meters * static_cast<FloatingType>(100);
@@ -67,7 +130,7 @@ namespace omath::unreal_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -4,6 +4,7 @@
 
 #pragma once
 #include "omath/engines/unreal_engine/formulas.hpp"
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::unreal_engine
@@ -11,14 +12,30 @@ namespace omath::unreal_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("look-at angle result should not be discarded")]]
-        static ViewAngles calc_look_at_angle(const Vector3<double>& cam_origin, const Vector3<double>& look_at) noexcept;
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<double>& cam_origin,
+                                                       const Vector3<double>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
+            return {PitchAngle::from_radians(internal::asin(direction.z)),
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept;
+                    YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
-        [[nodiscard]]
+        }
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+
-                                             double near, double far, NDCDepthRange ndc_depth_range) noexcept;
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept
+        {
+            return unreal_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const double near_plane,
+                                                       const double far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::unreal_engine

include/omath/engines/unreal_engine/traits/mesh_trait.hpp

@@ -10,7 +10,7 @@ namespace omath::unreal_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return unreal_engine::rotation_matrix(rotation);

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

@@ -12,6 +12,7 @@ namespace omath::unreal_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         static Vector3<double> predict_projectile_position(const projectile_prediction::Projectile<double>& projectile,
                                                            const double pitch, const double yaw,
                                                            const double time, const double gravity) noexcept
@@ -27,7 +28,7 @@ namespace omath::unreal_engine
             return current_pos;
         }
 
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static Vector3<double> predict_target_position(const projectile_prediction::Target<double>& target,
                                                        const double time, const double gravity) noexcept
         {
@@ -39,19 +40,19 @@ namespace omath::unreal_engine
             return predicted;
         }
 
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static double calc_vector_2d_distance(const Vector3<double>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.z * delta.z);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         static double get_vector_height_coordinate(const Vector3<double>& vec) noexcept
         {
             return vec.y;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<double> calc_viewpoint_from_angles(const projectile_prediction::Projectile<double>& projectile,
                                                           Vector3<double> predicted_target_position,
                                                           const std::optional<double> projectile_pitch) noexcept
@@ -64,7 +65,7 @@ namespace omath::unreal_engine
 
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static double calc_direct_pitch_angle(const Vector3<double>& origin, const Vector3<double>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
@@ -72,7 +73,7 @@ namespace omath::unreal_engine
             return angles::radians_to_degrees(std::asin(direction.z));
         }
 
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static double calc_direct_yaw_angle(const Vector3<double>& origin, const Vector3<double>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();

include/omath/hooks/hooks_manager.hpp

@@ -0,0 +1,214 @@
+#pragma once
+
+#ifdef OMATH_ENABLE_HOOKING
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <shared_mutex>
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <Windows.h>
+#include <d3d12.h>
+#include <d3d9.h>
+#include <dxgi.h>
+#endif // _WIN32
+
+#ifdef __linux__
+#include <GL/glx.h>
+#endif // __linux__
+
+#include <safetyhook.hpp>
+
+namespace omath::hooks
+{
+    class HooksManager final
+    {
+        HooksManager() = default;
+
+    public:
+#ifdef _WIN32
+        // IDXGISwapChain callbacks — shared between DX11 and DX12 (same interface, same signature).
+        using present_callback = std::function<void(IDXGISwapChain*, UINT, UINT)>;
+        using resize_buffers_callback = std::function<void(IDXGISwapChain*, UINT, UINT, UINT, DXGI_FORMAT, UINT)>;
+        using execute_command_lists_callback =
+                std::function<void(ID3D12CommandQueue*, UINT, ID3D12CommandList* const*)>;
+
+        // IDirect3DDevice9 callbacks — DX9 only.
+        using dx9_present_callback =
+                std::function<void(IDirect3DDevice9*, const RECT*, const RECT*, HWND, const RGNDATA*)>;
+        using dx9_reset_callback = std::function<void(IDirect3DDevice9*, D3DPRESENT_PARAMETERS*)>;
+        using dx9_end_scene_callback = std::function<void(IDirect3DDevice9*)>;
+
+        // OpenGL callback — Windows. Fires before the hooked buffer swap function calls the original.
+        using opengl_swap_buffers_callback = std::function<void(HDC)>;
+
+        // Return nullopt to pass the message to the original WndProc; return a value to intercept it.
+        using wnd_proc_callback = std::function<std::optional<LRESULT>(HWND, UINT, WPARAM, LPARAM)>;
+#endif // _WIN32
+
+#ifdef __linux__
+        // OpenGL/GLX callback — Linux. Fires before glXSwapBuffers calls the original.
+        using opengl_swap_buffers_callback = std::function<void(Display*, GLXDrawable)>;
+#endif // __linux__
+
+        template<typename Callback>
+        using callback_ptr = std::shared_ptr<const Callback>;
+
+        [[nodiscard]] static HooksManager& get();
+        HooksManager(const HooksManager&) = delete;
+        HooksManager& operator=(const HooksManager&) = delete;
+        ~HooksManager();
+
+#ifdef _WIN32
+        [[nodiscard]] bool hook_dx9();
+        void unhook_dx9();
+        void set_on_dx9_present(dx9_present_callback callback);
+        void set_on_dx9_reset(dx9_reset_callback callback);
+        void set_on_dx9_end_scene(dx9_end_scene_callback callback);
+
+        [[nodiscard]] bool hook_dx11();
+        void unhook_dx11();
+
+        [[nodiscard]] bool hook_dx12();
+        void unhook_dx12();
+#endif // _WIN32
+
+        [[nodiscard]] bool hook_opengl();
+        void unhook_opengl();
+        void set_on_opengl_swap_buffers(opengl_swap_buffers_callback callback);
+
+#ifdef _WIN32
+        // Present and ResizeBuffers callbacks fire for whichever of DX11/DX12 is hooked.
+        void set_on_present(present_callback callback);
+        void set_on_resize_buffers(resize_buffers_callback callback);
+        void set_on_execute_command_lists(execute_command_lists_callback callback);
+
+        [[nodiscard]] bool hook_wnd_proc(HWND hwnd);
+        void unhook_wnd_proc();
+        void set_on_wnd_proc(wnd_proc_callback callback);
+#endif // _WIN32
+
+    private:
+#ifdef _WIN32
+        [[nodiscard]]
+        static HRESULT __stdcall dx9_present_detour(IDirect3DDevice9* p_device, const RECT* p_source_rect,
+                                                    const RECT* p_dest_rect, HWND h_dest_window_override,
+                                                    const RGNDATA* p_dirty_region);
+        [[nodiscard]]
+        static HRESULT __stdcall dx9_reset_detour(IDirect3DDevice9* p_device,
+                                                  D3DPRESENT_PARAMETERS* p_presentation_parameters);
+        [[nodiscard]]
+        static HRESULT __stdcall dx9_end_scene_detour(IDirect3DDevice9* p_device);
+
+        [[nodiscard]]
+        static HRESULT __stdcall dx11_present_detour(IDXGISwapChain* p_swap_chain, UINT sync_interval, UINT flags);
+        [[nodiscard]]
+        static HRESULT __stdcall dx11_resize_buffers_detour(IDXGISwapChain* p_swap_chain, UINT buffer_count, UINT width,
+                                                            UINT height, DXGI_FORMAT new_format, UINT swap_chain_flags);
+        [[nodiscard]]
+        static HRESULT __stdcall dx12_present_detour(IDXGISwapChain* p_swap_chain, UINT sync_interval, UINT flags);
+        [[nodiscard]]
+        static HRESULT __stdcall dx12_resize_buffers_detour(IDXGISwapChain* p_swap_chain, UINT buffer_count, UINT width,
+                                                            UINT height, DXGI_FORMAT new_format, UINT swap_chain_flags);
+        static void __stdcall dx12_execute_command_lists_detour(ID3D12CommandQueue* p_command_queue,
+                                                                UINT num_command_lists,
+                                                                ID3D12CommandList* const* pp_command_lists);
+
+        [[nodiscard]]
+        static BOOL __stdcall opengl_wgl_swap_buffers_detour(HDC hdc);
+        [[nodiscard]]
+        static BOOL __stdcall opengl_swap_buffers_detour(HDC hdc);
+
+        [[nodiscard]]
+        static LRESULT __stdcall wnd_proc_detour(HWND hwnd, UINT msg, WPARAM w_param, LPARAM l_param);
+#endif // _WIN32
+
+#ifdef __linux__
+        static void opengl_glx_swap_buffers_detour(Display* display, GLXDrawable drawable);
+#endif // __linux__
+
+        mutable std::shared_mutex m_hook_state_mutex;
+
+#ifdef _WIN32
+        mutable std::shared_mutex m_dx9_present_mutex;
+        mutable std::shared_mutex m_dx9_reset_mutex;
+        mutable std::shared_mutex m_dx9_end_scene_mutex;
+
+        mutable std::shared_mutex m_present_mutex;
+        mutable std::shared_mutex m_resize_buffers_mutex;
+        mutable std::shared_mutex m_execute_command_lists_mutex;
+
+        mutable std::shared_mutex m_wnd_proc_mutex;
+#endif // _WIN32
+
+        mutable std::shared_mutex m_opengl_swap_buffers_mutex;
+
+#ifdef _WIN32
+        bool m_is_dx9_hooked = false;
+        bool m_is_dx11_hooked = false;
+        bool m_is_dx12_hooked = false;
+        bool m_is_wnd_proc_hooked = false;
+
+        HWND m_hooked_hwnd = nullptr;
+        WNDPROC m_original_wndproc = nullptr;
+
+        safetyhook::InlineHook m_dx9_present_hook;
+        safetyhook::InlineHook m_dx9_reset_hook;
+        safetyhook::InlineHook m_dx9_end_scene_hook;
+
+        safetyhook::InlineHook m_dx11_present_hook;
+        safetyhook::InlineHook m_dx11_resize_buffers_hook;
+
+        safetyhook::InlineHook m_dx12_present_hook;
+        safetyhook::InlineHook m_dx12_resize_buffers_hook;
+        safetyhook::InlineHook m_dx12_execute_command_lists_hook;
+
+        safetyhook::InlineHook m_opengl_wgl_swap_buffers_hook;
+        safetyhook::InlineHook m_opengl_swap_buffers_hook;
+#endif // _WIN32
+
+#ifdef __linux__
+        safetyhook::InlineHook m_opengl_glx_swap_buffers_hook;
+#endif // __linux__
+
+        bool m_is_opengl_hooked = false;
+
+#ifdef _WIN32
+        callback_ptr<dx9_present_callback> m_dx9_present_cb;
+        callback_ptr<dx9_reset_callback> m_dx9_reset_cb;
+        callback_ptr<dx9_end_scene_callback> m_dx9_end_scene_cb;
+
+        callback_ptr<present_callback> m_present_cb;
+        callback_ptr<resize_buffers_callback> m_resize_buffers_cb;
+        callback_ptr<execute_command_lists_callback> m_execute_command_lists_cb;
+
+        callback_ptr<wnd_proc_callback> m_wnd_proc_cb;
+#endif // _WIN32
+
+        callback_ptr<opengl_swap_buffers_callback> m_opengl_swap_buffers_cb;
+    };
+} // namespace omath::hooks
+
+#else // !OMATH_ENABLE_HOOKING
+
+namespace omath::hooks
+{
+    class HooksManager final
+    {
+        HooksManager() = default;
+
+    public:
+        [[nodiscard]] static HooksManager& get();
+        HooksManager(const HooksManager&) = delete;
+        ~HooksManager();
+    };
+} // namespace omath::hooks
+
+#endif

include/omath/hud/canvas_box.hpp

@@ -11,7 +11,7 @@ namespace omath::hud
     public:
         CanvasBox(Vector2<float> top, Vector2<float> bottom, float ratio = 4.f);
 
-        [[nodiscard]]
+        [[nodiscard("You have to use array")]]
         std::array<Vector2<float>, 4> as_array() const;
 
         Vector2<float> top_left_corner;

include/omath/hud/entity_overlay.hpp

@@ -15,14 +15,15 @@ namespace omath::hud
     class EntityOverlay final
     {
     public:
-        EntityOverlay(const Vector2<float>& top, const Vector2<float>& bottom,
+        EntityOverlay(const Vector2<float>& top, const Vector2<float>& bottom, float aspect,
                       const std::shared_ptr<HudRendererInterface>& renderer);
 
         // ── Boxes ────────────────────────────────────────────────────────
         EntityOverlay& add_2d_box(const Color& box_color, const Color& fill_color = Color{0.f, 0.f, 0.f, 0.f},
-                                  float thickness = 1.f);
+                                  const Color& outline_color = Color{0.f, 0.f, 0.f, 0.f}, float thickness = 1.f);
 
         EntityOverlay& add_cornered_2d_box(const Color& box_color, const Color& fill_color = Color{0.f, 0.f, 0.f, 0.f},
+                                           const Color& outline_color = Color{0.f, 0.f, 0.f, 0.f},
                                            float corner_ratio_len = 0.2f, float thickness = 1.f);
 
         EntityOverlay& add_dashed_box(const Color& color, float dash_len = 8.f, float gap_len = 5.f,
@@ -56,22 +57,22 @@ namespace omath::hud
                                              float offset = 5.f);
 
         // ── Labels ───────────────────────────────────────────────────────
-        EntityOverlay& add_right_label(const Color& color, float offset, bool outlined, const std::string_view& text);
+        EntityOverlay& add_right_label(const Color& color, float offset, widget::Outlined outlined, const std::string_view& text);
 
-        EntityOverlay& add_left_label(const Color& color, float offset, bool outlined, const std::string_view& text);
+        EntityOverlay& add_left_label(const Color& color, float offset, widget::Outlined outlined, const std::string_view& text);
 
-        EntityOverlay& add_top_label(const Color& color, float offset, bool outlined, std::string_view text);
+        EntityOverlay& add_top_label(const Color& color, float offset, widget::Outlined outlined, std::string_view text);
 
-        EntityOverlay& add_bottom_label(const Color& color, float offset, bool outlined, std::string_view text);
+        EntityOverlay& add_bottom_label(const Color& color, float offset, widget::Outlined outlined, std::string_view text);
 
-        EntityOverlay& add_centered_top_label(const Color& color, float offset, bool outlined,
+        EntityOverlay& add_centered_top_label(const Color& color, float offset, widget::Outlined outlined,
                                               const std::string_view& text);
 
-        EntityOverlay& add_centered_bottom_label(const Color& color, float offset, bool outlined,
+        EntityOverlay& add_centered_bottom_label(const Color& color, float offset, widget::Outlined outlined,
                                                  const std::string_view& text);
 
         template<typename... Args>
-        EntityOverlay& add_right_label(const Color& color, const float offset, const bool outlined, std::format_string<Args...> fmt,
+        EntityOverlay& add_right_label(const Color& color, const float offset, const widget::Outlined outlined, std::format_string<Args...> fmt,
                                        Args&&... args)
         {
             return add_right_label(color, offset, outlined,
@@ -79,7 +80,7 @@ namespace omath::hud
         }
 
         template<typename... Args>
-        EntityOverlay& add_left_label(const Color& color, const float offset, const bool outlined, std::format_string<Args...> fmt,
+        EntityOverlay& add_left_label(const Color& color, const float offset, const widget::Outlined outlined, std::format_string<Args...> fmt,
                                       Args&&... args)
         {
             return add_left_label(color, offset, outlined,
@@ -87,7 +88,7 @@ namespace omath::hud
         }
 
         template<typename... Args>
-        EntityOverlay& add_top_label(const Color& color, const float offset, const bool outlined, std::format_string<Args...> fmt,
+        EntityOverlay& add_top_label(const Color& color, const float offset, const widget::Outlined outlined, std::format_string<Args...> fmt,
                                      Args&&... args)
         {
             return add_top_label(color, offset, outlined,
@@ -95,7 +96,7 @@ namespace omath::hud
         }
 
         template<typename... Args>
-        EntityOverlay& add_bottom_label(const Color& color, const float offset, const bool outlined,
+        EntityOverlay& add_bottom_label(const Color& color, const float offset, const widget::Outlined outlined,
                                         std::format_string<Args...> fmt, Args&&... args)
         {
             return add_bottom_label(color, offset, outlined,
@@ -103,7 +104,7 @@ namespace omath::hud
         }
 
         template<typename... Args>
-        EntityOverlay& add_centered_top_label(const Color& color, const float offset, const bool outlined,
+        EntityOverlay& add_centered_top_label(const Color& color, const float offset, const widget::Outlined outlined,
                                               std::format_string<Args...> fmt, Args&&... args)
         {
             return add_centered_top_label(color, offset, outlined,
@@ -111,7 +112,7 @@ namespace omath::hud
         }
 
         template<typename... Args>
-        EntityOverlay& add_centered_bottom_label(const Color& color, const float offset, const bool outlined,
+        EntityOverlay& add_centered_bottom_label(const Color& color, const float offset, const widget::Outlined outlined,
                                                  std::format_string<Args...> fmt, Args&&... args)
         {
             return add_centered_bottom_label(color, offset, outlined,

include/omath/hud/entity_overlay_widgets.hpp

@@ -26,13 +26,20 @@ namespace omath::hud::widget
     {
         Color color;
         Color fill{0.f, 0.f, 0.f, 0.f};
+        Color outline{0.f, 0.f, 0.f, 0.f};
         float thickness = 1.f;
     };
 
+    enum class Outlined
+    {
+        Off,
+        On,
+    };
     struct CorneredBox
     {
         Color color;
         Color fill{0.f, 0.f, 0.f, 0.f};
+        Color outline{0.f, 0.f, 0.f, 0.f};
         float corner_ratio = 0.2f;
         float thickness = 1.f;
     };
@@ -116,7 +123,7 @@ namespace omath::hud::widget
     {
         Color color;
         float offset;
-        bool outlined;
+        Outlined outlined;
         std::string_view text;
     };
 

include/omath/hud/renderer_realizations/imgui_renderer.hpp

@@ -27,7 +27,7 @@ namespace omath::hud
                        const Color& tint = Color{1.f, 1.f, 1.f, 1.f}) override;
         void add_text(const Vector2<float>& position, const Color& color, const std::string_view& text) override;
         [[nodiscard]]
-        virtual Vector2<float> calc_text_size(const std::string_view& text) override;
+        Vector2<float> calc_text_size(const std::string_view& text) override;
     };
 } // namespace omath::hud
 #endif // OMATH_IMGUI_INTEGRATION

include/omath/internal/constexpr_math.hpp

@@ -0,0 +1,707 @@
+//
+// Created by orange on 6/11/2026.
+//
+#pragma once
+
+#include <bit>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <numbers>
+#include <type_traits>
+
+namespace omath::internal
+{
+    // Embedded subset of GCE-Math 1.18.0.
+    //
+    // Original project:
+    //   GCE-Math: A C++ generalized constant expression-based math library
+    //   Copyright 2016-2024 Keith O'Hara
+    //   Licensed under the Apache License, Version 2.0.
+    namespace math_detail
+    {
+        using uint_t = unsigned int;
+        using llint_t = long long int;
+        using ullint_t = unsigned long long int;
+
+        template<class Type>
+        using limits = std::numeric_limits<Type>;
+
+        template<class Type>
+        constexpr Type pi = std::numbers::pi_v<Type>;
+
+        template<class Type>
+        constexpr Type half_pi = std::numbers::pi_v<Type> / static_cast<Type>(2);
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type abs(const Type value) noexcept
+        {
+            return value == Type{0} ? Type{0} : value < Type{0} ? -value : value;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr int sgn(const Type value) noexcept
+        {
+            return value > Type{0} ? 1 : value < Type{0} ? -1 : 0;
+        }
+
+        [[nodiscard]]
+        constexpr bool is_odd(const llint_t value) noexcept
+        {
+            return (value & 1U) != 0;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool is_nan(const Type value) noexcept
+        {
+            return value != value;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool is_neginf(const Type value) noexcept
+        {
+            return value == -limits<Type>::infinity();
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool is_posinf(const Type value) noexcept
+        {
+            return value == limits<Type>::infinity();
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool is_inf(const Type value) noexcept
+        {
+            return is_neginf(value) || is_posinf(value);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool is_finite(const Type value) noexcept
+        {
+            return !is_nan(value) && !is_inf(value);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool any_nan(const Type x, const Type y) noexcept
+        {
+            return is_nan(x) || is_nan(y);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool any_inf(const Type x, const Type y) noexcept
+        {
+            return is_inf(x) || is_inf(y);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool all_finite(const Type x, const Type y) noexcept
+        {
+            return is_finite(x) && is_finite(y);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool signbit(const Type value) noexcept
+        {
+            if constexpr (std::is_same_v<Type, float>)
+                return (std::bit_cast<std::uint32_t>(value) & 0x80000000U) != 0;
+            else if constexpr (std::is_same_v<Type, double>)
+                return (std::bit_cast<std::uint64_t>(value) & 0x8000000000000000ULL) != 0;
+            else
+                return value < Type{0};
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool neg_zero(const Type value) noexcept
+        {
+            return value == Type{0} && signbit(value);
+        }
+
+        template<class Type, class ExpType>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type pow_integral_compute(const Type base, const ExpType exp_term) noexcept;
+
+        template<class Type, class ExpType>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type pow_integral_compute_recur(const Type base, const Type value, const ExpType exp_term) noexcept
+        {
+            return exp_term > ExpType{1}
+                           ? is_odd(static_cast<llint_t>(exp_term))
+                                     ? pow_integral_compute_recur(base * base, value * base, exp_term / ExpType{2})
+                                     : pow_integral_compute_recur(base * base, value, exp_term / ExpType{2})
+                   : exp_term == ExpType{1} ? value * base
+                                            : value;
+        }
+
+        template<class Type, class ExpType>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type pow_integral_sgn_check(const Type base, const ExpType exp_term) noexcept
+        {
+            if constexpr (std::is_signed_v<ExpType>)
+                return exp_term < ExpType{0} ? Type{1} / pow_integral_compute(base, -exp_term)
+                                             : pow_integral_compute_recur(base, Type{1}, exp_term);
+            else
+                return pow_integral_compute_recur(base, Type{1}, exp_term);
+        }
+
+        template<class Type, class ExpType>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type pow_integral_compute(const Type base, const ExpType exp_term) noexcept
+        {
+            return exp_term == ExpType{3}               ? base * base * base
+                   : exp_term == ExpType{2}             ? base * base
+                   : exp_term == ExpType{1}             ? base
+                   : exp_term == ExpType{0}             ? Type{1}
+                   : exp_term == limits<ExpType>::min() ? Type{0}
+                   : exp_term == limits<ExpType>::max() ? limits<Type>::infinity()
+                                                        : pow_integral_sgn_check(base, exp_term);
+        }
+
+        template<class Type, class ExpType>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type pow_integral(const Type base, const ExpType exp_term) noexcept
+        {
+            return pow_integral_compute(base, exp_term);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type sqrt_recur(const Type x, const Type xn, const int count) noexcept
+        {
+            return abs(xn - x / xn) / (Type{1} + xn) < limits<Type>::min() ? xn
+                   : count < 100 ? sqrt_recur(x, Type{0.5} * (xn + x / xn), count + 1)
+                                 : xn;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type sqrt_simplify(const Type x, const Type m_val) noexcept
+        {
+            return x > Type{1e+08}   ? sqrt_simplify(x / Type{1e+08}, Type{1e+04} * m_val)
+                   : x > Type{1e+06} ? sqrt_simplify(x / Type{1e+06}, Type{1e+03} * m_val)
+                   : x > Type{1e+04} ? sqrt_simplify(x / Type{1e+04}, Type{1e+02} * m_val)
+                   : x > Type{100}   ? sqrt_simplify(x / Type{100}, Type{10} * m_val)
+                   : x > Type{4}     ? sqrt_simplify(x / Type{4}, Type{2} * m_val)
+                                     : m_val * sqrt_recur(x, x / Type{2}, 0);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type sqrt(const Type x) noexcept
+        {
+            return is_nan(x)                                ? limits<Type>::quiet_NaN()
+                   : x < Type{0}                            ? limits<Type>::quiet_NaN()
+                   : is_posinf(x)                           ? x
+                   : limits<Type>::min() > abs(x)           ? Type{0}
+                   : limits<Type>::min() > abs(Type{1} - x) ? x
+                                                            : sqrt_simplify(x, Type{1});
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type floor_int(const Type x, const Type x_whole) noexcept
+        {
+            return x_whole - static_cast<Type>((x < Type{0}) && (x < x_whole));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type floor_check_internal(const Type x) noexcept
+        {
+            if constexpr (std::is_same_v<Type, float>)
+                return abs(x) >= 8388608.f ? x : floor_int(x, static_cast<float>(static_cast<int>(x)));
+            else if constexpr (std::is_same_v<Type, double>)
+                return abs(x) >= 4503599627370496. ? x : floor_int(x, static_cast<double>(static_cast<llint_t>(x)));
+            else
+                return abs(x) >= 9223372036854775808.l
+                               ? x
+                               : static_cast<long double>(static_cast<ullint_t>(abs(x))) * sgn(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type floor(const Type x) noexcept
+        {
+            return is_nan(x)                      ? limits<Type>::quiet_NaN()
+                   : !is_finite(x)                ? x
+                   : limits<Type>::min() > abs(x) ? x
+                                                  : floor_check_internal(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type trunc_int(const Type x) noexcept
+        {
+            return static_cast<Type>(static_cast<llint_t>(x));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type trunc_check_internal(const Type x) noexcept
+        {
+            if constexpr (std::is_same_v<Type, float>)
+                return abs(x) >= 8388608.f ? x : trunc_int(x);
+            else if constexpr (std::is_same_v<Type, double>)
+                return abs(x) >= 4503599627370496. ? x : trunc_int(x);
+            else
+                return abs(x) >= 9223372036854775808.l
+                               ? x
+                               : static_cast<long double>(static_cast<ullint_t>(abs(x))) * sgn(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type trunc(const Type x) noexcept
+        {
+            return is_nan(x)                      ? limits<Type>::quiet_NaN()
+                   : !is_finite(x)                ? x
+                   : limits<Type>::min() > abs(x) ? x
+                                                  : trunc_check_internal(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type fmod(const Type x, const Type y) noexcept
+        {
+            return any_nan(x, y) || !all_finite(x, y) || limits<Type>::min() > abs(y) ? limits<Type>::quiet_NaN()
+                                                                                      : x - trunc(x / y) * y;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan_series_exp_long(const Type z) noexcept
+        {
+            return -Type{1} / z
+                   + (z / Type{3}
+                      + (pow_integral(z, 3) / Type{45}
+                         + (Type{2} * pow_integral(z, 5) / Type{945} + pow_integral(z, 7) / Type{4725})));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan_series_exp(const Type x) noexcept
+        {
+            return limits<Type>::min() > abs(x - half_pi<Type>) ? Type{1.633124e+16}
+                                                                : tan_series_exp_long(x - half_pi<Type>);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan_cf_recur(const Type xx, const int max_depth) noexcept
+        {
+            Type result = static_cast<Type>(2 * max_depth - 1);
+            for (int depth = max_depth - 1; depth >= 1; --depth)
+                result = static_cast<Type>(2 * depth - 1) - xx / result;
+
+            return result;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan_cf_main(const Type x) noexcept
+        {
+            return x > Type{1.55} && x < Type{1.60} ? tan_series_exp(x)
+                   : x > Type{1.4}                  ? x / tan_cf_recur(x * x, 45)
+                   : x > Type{1}                    ? x / tan_cf_recur(x * x, 35)
+                                                    : x / tan_cf_recur(x * x, 25);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan_begin(const Type x, const int count = 0) noexcept
+        {
+            return x > pi<Type> ? count > 1 ? limits<Type>::quiet_NaN()
+                                            : tan_begin(x - pi<Type> * floor(x / pi<Type>), count + 1)
+                                : tan_cf_main(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan(const Type x) noexcept
+        {
+            return is_nan(x)                      ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x) ? Type{0}
+                   : x < Type{0}                  ? -tan_begin(-x)
+                                                  : tan_begin(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type sin(const Type x) noexcept
+        {
+            return is_nan(x)                                      ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x)                 ? Type{0}
+                   : limits<Type>::min() > abs(x - half_pi<Type>) ? Type{1}
+                   : limits<Type>::min() > abs(x + half_pi<Type>) ? -Type{1}
+                   : limits<Type>::min() > abs(x - pi<Type>)      ? Type{0}
+                   : limits<Type>::min() > abs(x + pi<Type>)
+                           ? -Type{0}
+                           : (Type{2} * tan(x / Type{2})) / (Type{1} + tan(x / Type{2}) * tan(x / Type{2}));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type cos(const Type x) noexcept
+        {
+            return is_nan(x)                                      ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x)                 ? Type{1}
+                   : limits<Type>::min() > abs(x - half_pi<Type>) ? Type{0}
+                   : limits<Type>::min() > abs(x + half_pi<Type>) ? Type{0}
+                   : limits<Type>::min() > abs(x - pi<Type>)      ? -Type{1}
+                   : limits<Type>::min() > abs(x + pi<Type>)
+                           ? -Type{1}
+                           : (Type{1} - tan(x / Type{2}) * tan(x / Type{2}))
+                                     / (Type{1} + tan(x / Type{2}) * tan(x / Type{2}));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_series_order_calc(const Type xx, const Type x_pow, const uint_t order) noexcept
+        {
+            return Type{1} / (static_cast<Type>((order - 1) * 4 - 1) * x_pow)
+                   - Type{1} / (static_cast<Type>((order - 1) * 4 + 1) * x_pow * xx);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_series_order(const Type x, const uint_t order_begin, const uint_t max_order) noexcept
+        {
+            if (max_order == 1)
+                return half_pi<Type> - Type{1} / x;
+
+            const Type xx = x * x;
+            Type result = atan_series_order_calc(xx, pow_integral(x, 4 * max_order - 5), max_order);
+            auto depth = max_order - 1;
+
+            while (depth > order_begin)
+            {
+                result += atan_series_order_calc(xx, pow_integral(x, 4 * depth - 5), depth);
+                --depth;
+            }
+
+            return result + half_pi<Type> - Type{1} / x;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_series_main(const Type x) noexcept
+        {
+            return x < Type{3}      ? atan_series_order(x, 1U, 10U)
+                   : x < Type{4}    ? atan_series_order(x, 1U, 9U)
+                   : x < Type{5}    ? atan_series_order(x, 1U, 8U)
+                   : x < Type{7}    ? atan_series_order(x, 1U, 7U)
+                   : x < Type{11}   ? atan_series_order(x, 1U, 6U)
+                   : x < Type{25}   ? atan_series_order(x, 1U, 5U)
+                   : x < Type{100}  ? atan_series_order(x, 1U, 4U)
+                   : x < Type{1000} ? atan_series_order(x, 1U, 3U)
+                                    : atan_series_order(x, 1U, 2U);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_cf_recur(const Type xx, const uint_t depth_begin, const uint_t max_depth) noexcept
+        {
+            auto depth = max_depth - 1;
+            Type result = static_cast<Type>(2 * (depth + 1) - 1);
+
+            while (depth > depth_begin - 1)
+            {
+                result = static_cast<Type>(2 * depth - 1) + static_cast<Type>(depth * depth) * xx / result;
+                --depth;
+            }
+
+            return result;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_cf_main(const Type x) noexcept
+        {
+            return x < Type{0.5}   ? x / atan_cf_recur(x * x, 1U, 15U)
+                   : x < Type{1}   ? x / atan_cf_recur(x * x, 1U, 25U)
+                   : x < Type{1.5} ? x / atan_cf_recur(x * x, 1U, 35U)
+                   : x < Type{2}   ? x / atan_cf_recur(x * x, 1U, 45U)
+                                   : x / atan_cf_recur(x * x, 1U, 52U);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_begin(const Type x) noexcept
+        {
+            return x > Type{2.5} ? atan_series_main(x) : atan_cf_main(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan(const Type x) noexcept
+        {
+            return is_nan(x)                      ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x) ? Type{0}
+                   : x < Type{0}                  ? -atan_begin(-x)
+                                                  : atan_begin(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan2(const Type y, const Type x) noexcept
+        {
+            return any_nan(y, x)                  ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x) ? limits<Type>::min() > abs(y)
+                                                            ? neg_zero(y)   ? neg_zero(x) ? -pi<Type> : -Type{0}
+                                                                : neg_zero(x) ? pi<Type>
+                                                                            : Type{0}
+                                                    : y > Type{0} ? half_pi<Type>
+                                                                  : -half_pi<Type>
+                   : x < Type{0} ? y < Type{0} ? atan(y / x) - pi<Type> : atan(y / x) + pi<Type>
+                                 : atan(y / x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type asin_compute(const Type x) noexcept
+        {
+            return x > Type{1}                              ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x - Type{1}) ? half_pi<Type>
+                   : limits<Type>::min() > abs(x)           ? Type{0}
+                                                            : atan(x / sqrt(Type{1} - x * x));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type asin(const Type x) noexcept
+        {
+            return is_nan(x) ? limits<Type>::quiet_NaN() : x < Type{0} ? -asin_compute(-x) : asin_compute(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type acos_compute(const Type x) noexcept
+        {
+            return abs(x) > Type{1}                         ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x - Type{1}) ? Type{0}
+                   : limits<Type>::min() > abs(x)           ? half_pi<Type>
+                                                            : atan(sqrt(Type{1} - x * x) / x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type acos(const Type x) noexcept
+        {
+            return is_nan(x) ? limits<Type>::quiet_NaN() : x > Type{0} ? acos_compute(x) : pi<Type> - acos_compute(-x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type hypot(const Type x, const Type y) noexcept
+        {
+            return any_nan(x, y)                  ? limits<Type>::quiet_NaN()
+                   : any_inf(x, y)                ? limits<Type>::infinity()
+                   : limits<Type>::min() > abs(x) ? abs(y)
+                   : limits<Type>::min() > abs(y) ? abs(x)
+                                                  : abs(x) * sqrt(Type{1} + (y / x) * (y / x));
+        }
+    } // namespace math_detail
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type sin(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::sin(value);
+        }
+        return std::sin(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type cos(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::cos(value);
+        }
+        return std::cos(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type tan(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::tan(value);
+        }
+        return std::tan(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type atan(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::atan(value);
+        }
+        return std::atan(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type atan2(const Type& y, const Type& x) noexcept
+    {
+        if consteval
+        {
+            return math_detail::atan2(y, x);
+        }
+        return std::atan2(y, x);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type asin(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::asin(value);
+        }
+        return std::asin(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type acos(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::acos(value);
+        }
+        return std::acos(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type sqrt(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::sqrt(value);
+        }
+        return std::sqrt(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type hypot(const Type& x, const Type& y) noexcept
+    {
+        if consteval
+        {
+            return math_detail::hypot(x, y);
+        }
+        return std::hypot(x, y);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type hypot(const Type& x, const Type& y, const Type& z) noexcept
+    {
+        if consteval
+        {
+            return math_detail::sqrt(x * x + y * y + z * z);
+        }
+        return std::hypot(x, y, z);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type abs(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::abs(value);
+        }
+        return std::abs(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type fmod(const Type& dividend, const Type& divisor) noexcept
+    {
+        if consteval
+        {
+            return math_detail::fmod(dividend, divisor);
+        }
+        return std::fmod(dividend, divisor);
+    }
+} // namespace omath::internal

include/omath/linear_algebra/mat.hpp

@@ -2,13 +2,16 @@
 // Created by vlad on 9/29/2024.
 //
 #pragma once
+#include "omath/internal/constexpr_math.hpp"
 #include "vector3.hpp"
 #include <algorithm>
 #include <array>
+#include <cmath>
 #include <iomanip>
 #include <numeric>
 #include <sstream>
 #include <stdexcept>
+#include <type_traits>
 #include <utility>
 
 #ifdef OMATH_USE_AVX2
@@ -43,8 +46,8 @@ namespace omath
         ZERO_TO_ONE // DirectX / Vulkan: [0.0, 1.0]
     };
 
-    template<typename M1, typename M2> concept MatTemplateEqual
+    template<typename M1, typename M2> concept MatTemplateEqual =
-            = (M1::rows == M2::rows) && (M1::columns == M2::columns)
+            (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>
@@ -58,7 +61,7 @@ namespace omath
             clear();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use store ordering")]]
         consteval static MatStoreType get_store_ordering() noexcept
         {
             return StoreType;
@@ -93,13 +96,13 @@ namespace omath
             m_data = other.m_data;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use element reference")]]
         constexpr Type& operator[](const size_t row, const size_t col)
         {
             return at(row, col);
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use element reference")]]
         constexpr const Type& operator[](const size_t row, const size_t col) const
         {
             return at(row, col);
@@ -110,25 +113,25 @@ namespace omath
             m_data = std::move(other.m_data);
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use row count")]]
         static constexpr size_t row_count() noexcept
         {
             return Rows;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use column count")]]
         static constexpr size_t columns_count() noexcept
         {
             return Columns;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use matrix size")]]
-        static consteval MatSize size() noexcept
+        static constexpr MatSize size() noexcept
         {
             return {Rows, Columns};
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use element reference")]]
         constexpr const Type& at(const size_t row_index, const size_t column_index) const
         {
 #if !defined(NDEBUG) && defined(OMATH_SUPRESS_SAFETY_CHECKS)
@@ -148,12 +151,13 @@ namespace omath
             }
         }
 
-        [[nodiscard]] constexpr Type& at(const size_t row_index, const size_t column_index)
+        [[nodiscard("You must use element reference")]] 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]]
+        [[nodiscard("You must use sum of elements")]]
         constexpr Type sum() const noexcept
         {
             return std::accumulate(m_data.begin(), m_data.end(), static_cast<Type>(0));
@@ -170,11 +174,18 @@ namespace omath
         }
 
         // Operator overloading for multiplication with another Mat
-        template<size_t OtherColumns> [[nodiscard]]
+        template<size_t OtherColumns> [[nodiscard("You must use result matrix")]]
         constexpr Mat<Rows, OtherColumns, Type, StoreType>
         operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
         {
 #ifdef OMATH_USE_AVX2
+            if (std::is_constant_evaluated())
+            {
+                if constexpr (StoreType == MatStoreType::ROW_MAJOR)
+                    return cache_friendly_multiply_row_major(other);
+                else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
+                    return cache_friendly_multiply_col_major(other);
+            }
             if constexpr (StoreType == MatStoreType::ROW_MAJOR)
                 return avx_multiply_row_major(other);
             else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
@@ -191,7 +202,11 @@ namespace omath
 
         constexpr Mat& operator*=(const Type& f) noexcept
         {
-            std::ranges::for_each(m_data, [&f](auto& val) { val *= f; });
+            std::ranges::for_each(m_data,
+                                  [&f](auto& val)
+                                  {
+                                      val *= f;
+                                  });
             return *this;
         }
 
@@ -201,7 +216,7 @@ namespace omath
             return *this = *this * other;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use result matrix")]]
         constexpr Mat operator*(const Type& value) const noexcept
         {
             Mat result(*this);
@@ -211,11 +226,15 @@ namespace omath
 
         constexpr Mat& operator/=(const Type& value) noexcept
         {
-            std::ranges::for_each(m_data, [&value](auto& val) { val /= value; });
+            std::ranges::for_each(m_data,
+                                  [&value](auto& val)
+                                  {
+                                      val /= value;
+                                  });
             return *this;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use result matrix")]]
         constexpr Mat operator/(const Type& value) const noexcept
         {
             Mat result(*this);
@@ -239,7 +258,7 @@ namespace omath
             return *this;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use transposed matrix")]]
         constexpr Mat<Columns, Rows, Type, StoreType> transposed() const noexcept
         {
             Mat<Columns, Rows, Type, StoreType> transposed;
@@ -250,7 +269,7 @@ namespace omath
             return transposed;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use determinant")]]
         constexpr Type determinant() const
         {
             static_assert(Rows == Columns, "Determinant is only defined for square matrices.");
@@ -271,10 +290,11 @@ namespace omath
                 }
                 return det;
             }
+            else // For no reason MSVC triggers on it as unreachable code so we keep else here.
                 std::unreachable();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use stripped matrix")]]
         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);
@@ -295,32 +315,32 @@ namespace omath
             return result;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use minor")]]
         constexpr Type minor(const size_t row, const size_t column) const
         {
             return strip(row, column).determinant();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use algebraic complement")]]
         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]]
+        [[nodiscard("You must use raw array")]]
         constexpr const std::array<Type, Rows * Columns>& raw_array() const
         {
             return m_data;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use raw array")]]
         constexpr std::array<Type, Rows * Columns>& raw_array()
         {
             return m_data;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use string representation")]]
         std::string to_string() const noexcept
         {
             std::ostringstream oss;
@@ -342,14 +362,14 @@ namespace omath
             return oss.str();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use wide string representation")]]
         std::wstring to_wstring() const noexcept
         {
             const auto ascii_string = to_string();
             return {ascii_string.cbegin(), ascii_string.cend()};
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use UTF-8 string representation")]]
         // ReSharper disable once CppInconsistentNaming
         std::u8string to_u8string() const noexcept
         {
@@ -357,20 +377,20 @@ namespace omath
             return {ascii_string.cbegin(), ascii_string.cend()};
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
         bool operator==(const Mat& mat) const
         {
             return m_data == mat.m_data;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
         bool operator!=(const Mat& mat) const
         {
             return !operator==(mat);
         }
 
         // Static methods that return fixed-size matrices
-        [[nodiscard]]
+        [[nodiscard("You must use screen matrix")]]
         constexpr static Mat<4, 4> to_screen_mat(const Type& screen_width, const Type& screen_height) noexcept
         {
             return {
@@ -381,12 +401,12 @@ namespace omath
             };
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use inverted matrix")]]
         constexpr std::optional<Mat> inverted() const
         {
             const auto det = determinant();
 
-            if (std::abs(det) < std::numeric_limits<Type>::epsilon())
+            if (internal::abs(det) < std::numeric_limits<Type>::epsilon())
                 return std::nullopt;
 
             const auto transposed_mat = transposed();
@@ -404,7 +424,7 @@ namespace omath
     private:
         std::array<Type, Rows * Columns> m_data;
 
-        template<size_t OtherColumns> [[nodiscard]]
+        template<size_t OtherColumns> [[nodiscard("You must use result matrix")]]
         constexpr Mat<Rows, OtherColumns, Type, MatStoreType::ROW_MAJOR>
         cache_friendly_multiply_row_major(const Mat<Columns, OtherColumns, Type, MatStoreType::ROW_MAJOR>& other) const
         {
@@ -419,7 +439,7 @@ namespace omath
             return result;
         }
 
-        template<size_t OtherColumns> [[nodiscard]]
+        template<size_t OtherColumns> [[nodiscard("You must use result matrix")]]
         constexpr Mat<Rows, OtherColumns, Type, MatStoreType::COLUMN_MAJOR> cache_friendly_multiply_col_major(
                 const Mat<Columns, OtherColumns, Type, MatStoreType::COLUMN_MAJOR>& other) const
         {
@@ -434,7 +454,7 @@ namespace omath
             return result;
         }
 #ifdef OMATH_USE_AVX2
-        template<size_t OtherColumns> [[nodiscard]]
+        template<size_t OtherColumns> [[nodiscard("You must use result matrix")]]
         constexpr Mat<Rows, OtherColumns, Type, MatStoreType::COLUMN_MAJOR>
         avx_multiply_col_major(const Mat<Columns, OtherColumns, Type, MatStoreType::COLUMN_MAJOR>& other) const
         {
@@ -504,7 +524,7 @@ namespace omath
             return result;
         }
 
-        template<size_t OtherColumns> [[nodiscard]]
+        template<size_t OtherColumns> [[nodiscard("You must use result matrix")]]
         constexpr Mat<Rows, OtherColumns, Type, MatStoreType::ROW_MAJOR>
         avx_multiply_row_major(const Mat<Columns, OtherColumns, Type, MatStoreType::ROW_MAJOR>& other) const
         {
@@ -575,24 +595,23 @@ namespace omath
 #endif
     };
 
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard]]
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard("You must use row matrix")]]
-    constexpr static Mat<1, 4, Type, St> mat_row_from_vector(const Vector3<Type>& vector) noexcept
+    constexpr 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]]
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard("You must use column matrix")]]
-    constexpr static Mat<4, 1, Type, St> mat_column_from_vector(const Vector3<Type>& vector) noexcept
+    constexpr 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]]
+    [[nodiscard("You must use translation matrix")]]
     constexpr Mat<4, 4, Type, St> mat_translation(const Vector3<Type>& diff) noexcept
     {
-        return
+        return {
-        {
                 {1, 0, 0, diff.x},
                 {0, 1, 0, diff.y},
                 {0, 0, 1, diff.z},
@@ -600,7 +619,7 @@ namespace omath
         };
     }
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
-    [[nodiscard]]
+    [[nodiscard("You must use scale matrix")]]
     constexpr Mat<4, 4, Type, St> mat_scale(const Vector3<Type>& scale) noexcept
     {
         return {
@@ -611,67 +630,101 @@ namespace omath
         };
     }
 
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
-    [[nodiscard]]
+    [[nodiscard("You must use extracted origin")]]
-    Mat<4, 4, Type, St> mat_rotation_axis_x(const Angle& angle) noexcept
+    constexpr Vector3<Type> mat_extract_origin(const Mat<4, 4, Type, St>& mat) noexcept
     {
-        return
+        return {mat.at(0, 3), mat.at(1, 3), mat.at(2, 3)};
-        {
-            {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>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
-    [[nodiscard]]
+    [[nodiscard("You must use extracted scale")]]
-    Mat<4, 4, Type, St> mat_rotation_axis_y(const Angle& angle) noexcept
+    constexpr Vector3<Type> mat_extract_scale(const Mat<4, 4, Type, St>& mat) noexcept
     {
-        return
+        auto column_length = [](const Type x, const Type y, const Type z)
         {
-            {angle.cos(),  0, angle.sin(), 0},
+            return static_cast<Type>(internal::sqrt(x * x + y * y + z * z));
-            {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>
+        const auto scale_x = column_length(mat.at(0, 0), mat.at(1, 0), mat.at(2, 0));
-    [[nodiscard]]
+        const auto scale_y = column_length(mat.at(0, 1), mat.at(1, 1), mat.at(2, 1));
-    Mat<4, 4, Type, St> mat_rotation_axis_z(const Angle& angle) noexcept
+        const auto scale_z = column_length(mat.at(0, 2), mat.at(1, 2), mat.at(2, 2));
-    {
+
-        return
+        constexpr auto epsilon = std::numeric_limits<Type>::epsilon();
-        {
+
-            {angle.cos(), -angle.sin(), 0, 0},
+        return {
-            {angle.sin(),  angle.cos(), 0, 0},
+                internal::abs(scale_x) < epsilon ? Type{1} : scale_x,
-            {          0,        0,     1, 0},
+                internal::abs(scale_y) < epsilon ? Type{1} : scale_y,
-            {          0,        0,     0, 1},
+                internal::abs(scale_z) < epsilon ? Type{1} : scale_z,
         };
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
-    [[nodiscard]]
+    requires std::is_floating_point_v<Type>
-    static Mat<4, 4, Type, St> mat_camera_view(const Vector3<Type>& forward, const Vector3<Type>& right,
+    [[nodiscard("You must use extracted rotation")]]
+    constexpr Vector3<Type> mat_extract_rotation_zyx(const Mat<4, 4, Type, St>& mat) noexcept
+    {
+        const auto scale = mat_extract_scale(mat);
+        const auto m00 = mat.at(0, 0) / scale.x;
+        const auto m10 = mat.at(1, 0) / scale.x;
+        const auto m20 = mat.at(2, 0) / scale.x;
+        const auto m21 = mat.at(2, 1) / scale.y;
+        const auto m22 = mat.at(2, 2) / scale.z;
+
+        return {
+                angles::radians_to_degrees(internal::atan2(m21, m22)),
+                angles::radians_to_degrees(internal::asin(std::clamp(-m20, Type{-1}, Type{1}))),
+                angles::radians_to_degrees(internal::atan2(m10, m00)),
+        };
+    }
+
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
+    [[nodiscard("You must use rotation matrix")]]
+    constexpr 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("You must use rotation matrix")]]
+    constexpr 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("You must use rotation matrix")]]
+    constexpr 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("You must use camera view matrix")]]
+    constexpr 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>
+        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);
+               }
+               * mat_translation<Type, St>(-camera_origin);
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard]]
+    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
-    Mat<4, 4, Type, St> mat_perspective_left_handed(const Type field_of_view, const Type aspect_ratio,
+    mat_perspective_left_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near,
-                                                    const Type near, const Type far) noexcept
+                                             const Type far) noexcept
     {
-        const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2});
+        const auto fov_half_tan = internal::tan(angles::degrees_to_radians(field_of_view) / Type{2});
-
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
             return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}},
                     {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}},
@@ -688,11 +741,11 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard]]
+    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
-    Mat<4, 4, Type, St> mat_perspective_right_handed(const Type field_of_view, const Type aspect_ratio,
+    mat_perspective_right_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near,
-                                                     const Type near, const Type far) noexcept
+                                              const Type far) noexcept
     {
-        const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2});
+        const auto fov_half_tan = internal::tan(angles::degrees_to_radians(field_of_view) / Type{2});
 
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
             return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}},
@@ -713,12 +766,11 @@ namespace omath
     // X and Y scales derived as: X = 1 / tan(hfov/2), Y = aspect / tan(hfov/2).
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard]]
+    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
-    Mat<4, 4, Type, St> mat_perspective_left_handed_horizontal_fov(const Type horizontal_fov,
+    mat_perspective_left_handed_horizontal_fov(const Type horizontal_fov, const Type aspect_ratio, const Type near,
-                                                                   const Type aspect_ratio, const Type near,
                                                const Type far) noexcept
     {
-        const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
+        const auto inv_tan_half_hfov = Type{1} / internal::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
         const auto x_axis = inv_tan_half_hfov;
         const auto y_axis = inv_tan_half_hfov * aspect_ratio;
 
@@ -730,7 +782,7 @@ namespace omath
         else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
             return {{x_axis, Type{0}, Type{0}, Type{0}},
                     {Type{0}, y_axis, Type{0}, Type{0}},
-                    {Type{0}, Type{0}, (far + near) / (far - near), -(2.f * near * far) / (far - near)},
+                    {Type{0}, Type{0}, (far + near) / (far - near), -(Type{2} * near * far) / (far - near)},
                     {Type{0}, Type{0}, Type{1}, Type{0}}};
         else
             std::unreachable();
@@ -738,12 +790,12 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard]]
+    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
-    Mat<4, 4, Type, St> mat_perspective_right_handed_horizontal_fov(const Type horizontal_fov,
+    mat_perspective_right_handed_horizontal_fov(const Type horizontal_fov, const Type aspect_ratio, const Type near,
-                                                                    const Type aspect_ratio, const Type near,
                                                 const Type far) noexcept
     {
-        const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
+        const auto inv_tan_half_hfov = Type{1} / internal::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
+
         const auto x_axis = inv_tan_half_hfov;
         const auto y_axis = inv_tan_half_hfov * aspect_ratio;
 
@@ -755,63 +807,52 @@ namespace omath
         else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
             return {{x_axis, Type{0}, Type{0}, Type{0}},
                     {Type{0}, y_axis, Type{0}, Type{0}},
-                    {Type{0}, Type{0}, -(far + near) / (far - near), -(2.f * near * far) / (far - near)},
+                    {Type{0}, Type{0}, -(far + near) / (far - near), -(Type{2} * near * far) / (far - near)},
                     {Type{0}, Type{0}, -Type{1}, Type{0}}};
         else
             std::unreachable();
     }
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard]]
+    [[nodiscard("You must use ortho matrix")]] constexpr Mat<4, 4, Type, St>
-    Mat<4, 4, Type, St> mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top,
+    mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top, const Type near,
-                                              const Type near, const Type far) noexcept
+                          const Type far) noexcept
     {
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return
+            return {{static_cast<Type>(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)},
-            {
+                    {0.f, static_cast<Type>(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)},
-                { static_cast<Type>(2) / (right - left), 0.f,       0.f,    -(right + left) / (right - left)},
+                    {0.f, 0.f, static_cast<Type>(1) / (far - near), -near / (far - near)},
-                { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,    -(top + bottom) / (top - bottom)},
+                    {0.f, 0.f, 0.f, 1.f}};
-                { 0.f,      0.f,       static_cast<Type>(1) / (far - near), -near / (far - near)            },
-                { 0.f,      0.f,       0.f,                                 1.f                             }
-            };
         else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return
+            return {{static_cast<Type>(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)},
-            {
+                    {0.f, static_cast<Type>(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)},
-                { static_cast<Type>(2) / (right - left), 0.f,       0.f,    -(right + left) / (right - left)},
+                    {0.f, 0.f, static_cast<Type>(2) / (far - near), -(far + near) / (far - near)},
-                { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,    -(top + bottom) / (top - bottom)},
+                    {0.f, 0.f, 0.f, 1.f}};
-                { 0.f,      0.f,       static_cast<Type>(2) / (far - near), -(far + near) / (far - near)    },
-                { 0.f,      0.f,       0.f,                                 1.f                             }
-            };
         else
             std::unreachable();
     }
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard]]
+    [[nodiscard("You must use ortho matrix")]] constexpr Mat<4, 4, Type, St>
-    Mat<4, 4, Type, St> mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top,
+    mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top, const Type near,
-                                               const Type near, const Type far) noexcept
+                           const Type far) noexcept
     {
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return
+            return {{static_cast<Type>(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)},
-            {
+                    {0.f, static_cast<Type>(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)},
-                    { static_cast<Type>(2) / (right - left), 0.f,       0.f,     -(right + left) / (right - left)},
+                    {0.f, 0.f, -static_cast<Type>(1) / (far - near), -near / (far - near)},
-                    { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,     -(top + bottom) / (top - bottom)},
+                    {0.f, 0.f, 0.f, 1.f}};
-                    { 0.f,      0.f,       -static_cast<Type>(1) / (far - near), -near / (far - near)            },
-                    { 0.f,      0.f,       0.f,                                  1.f                             }
-            };
         else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return
+            return {{static_cast<Type>(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)},
-            {
+                    {0.f, static_cast<Type>(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)},
-                    { static_cast<Type>(2) / (right - left), 0.f,       0.f,     -(right + left) / (right - left)},
+                    {0.f, 0.f, -static_cast<Type>(2) / (far - near), -(far + near) / (far - near)},
-                    { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,     -(top + bottom) / (top - bottom)},
+                    {0.f, 0.f, 0.f, 1.f}};
-                    { 0.f,      0.f,       -static_cast<Type>(2) / (far - near), -(far + near) / (far - near)    },
-                    { 0.f,      0.f,       0.f,                                  1.f                             }
-            };
         else
             std::unreachable();
     }
     template<class T = float, MatStoreType St = MatStoreType::COLUMN_MAJOR>
-   Mat<4, 4, T, St> mat_look_at_left_handed(const Vector3<T>& eye, const Vector3<T>& center, const Vector3<T>& up)
+    constexpr Mat<4, 4, T, St> mat_look_at_left_handed(const Vector3<T>& eye, const Vector3<T>& center,
+                                                       const Vector3<T>& up)
     {
         const Vector3<T> f = (center - eye).normalized();
         const Vector3<T> s = f.cross(up).normalized();
@@ -820,7 +861,8 @@ namespace omath
     }
 
     template<class T = float, MatStoreType St = MatStoreType::COLUMN_MAJOR>
-    Mat<4, 4, T, St>mat_look_at_right_handed(const Vector3<T>& eye, const Vector3<T>& center, const Vector3<T>& up)
+    constexpr Mat<4, 4, T, St> mat_look_at_right_handed(const Vector3<T>& eye, const Vector3<T>& center,
+                                                        const Vector3<T>& up)
     {
         const Vector3<T> f = (center - eye).normalized();
         const Vector3<T> s = f.cross(up).normalized();
@@ -834,14 +876,14 @@ template<size_t Rows, size_t Columns, class Type, omath::MatStoreType StoreType>
 struct std::formatter<omath::Mat<Rows, Columns, Type, StoreType>> // NOLINT(*-dcl58-cpp)
 {
     using MatType = omath::Mat<Rows, Columns, Type, StoreType>;
-    [[nodiscard]]
+    [[nodiscard("You must use parse iterator")]]
     static constexpr auto parse(std::format_parse_context& ctx)
     {
         return ctx.begin();
     }
 
     template<class FormatContext>
-    [[nodiscard]]
+    [[nodiscard("You must use format iterator")]]
     static auto format(const MatType& mat, FormatContext& ctx)
     {
         if constexpr (std::is_same_v<typename FormatContext::char_type, char>)

include/omath/linear_algebra/triangle.hpp

@@ -2,8 +2,8 @@
 // Created by Orange on 11/13/2024.
 //
 #pragma once
+#include "omath/internal/constexpr_math.hpp"
 #include "vector3.hpp"
-
 namespace omath
 {
     /*
@@ -40,13 +40,13 @@ namespace omath
         }
 
         [[nodiscard]]
-        Vector::ContainedType side_a_length() const
+        constexpr Vector::ContainedType side_a_length() const
         {
             return m_vertex1.distance_to(m_vertex2);
         }
 
         [[nodiscard]]
-        Vector::ContainedType side_b_length() const
+        constexpr Vector::ContainedType side_b_length() const
         {
             return m_vertex3.distance_to(m_vertex2);
         }
@@ -69,7 +69,7 @@ namespace omath
             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;
+            return internal::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f;
         }
         [[nodiscard]]
         constexpr Vector side_b_vector() const

include/omath/linear_algebra/vector2.hpp

@@ -3,6 +3,7 @@
 //
 
 #pragma once
+#include "omath/internal/constexpr_math.hpp"
 #include <cmath>
 #include <format>
 #include <tuple>
@@ -28,7 +29,7 @@ namespace omath
 
         template<class CastedType>
         requires std::is_arithmetic_v<CastedType>
-        [[nodiscard]] constexpr explicit operator Vector2<CastedType>() const noexcept
+        [[nodiscard("You must use casted vector")]] constexpr explicit operator Vector2<CastedType>() const noexcept
         {
             return {static_cast<CastedType>(x), static_cast<CastedType>(y)};
         }
@@ -37,13 +38,13 @@ namespace omath
         }
 
         // Equality operators
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
         constexpr bool operator==(const Vector2& other) const noexcept
         {
             return x == other.x && y == other.y;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
         constexpr bool operator!=(const Vector2& other) const noexcept
         {
             return !(*this == other);
@@ -115,45 +116,51 @@ namespace omath
         }
 
         // Basic vector operations
-        [[nodiscard]] Type distance_to(const Vector2& other) const noexcept
+        [[nodiscard("You must use distance")]]
+        constexpr Type distance_to(const Vector2& other) const noexcept
         {
-            return std::sqrt(distance_to_sqr(other));
+            return internal::sqrt(distance_to_sqr(other));
         }
 
-        [[nodiscard]] constexpr Type distance_to_sqr(const Vector2& other) const noexcept
+        [[nodiscard("You must use squared distance")]]
+        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
+        [[nodiscard("You must use dot product")]]
+        constexpr Type dot(const Vector2& other) const noexcept
         {
             return x * other.x + y * other.y;
         }
 
 #ifndef _MSC_VER
-        [[nodiscard]] constexpr Type length() const noexcept
+        [[nodiscard("You must use length")]] constexpr Type length() const noexcept
         {
-            return std::hypot(this->x, this->y);
+            return internal::hypot(this->x, this->y);
         }
 
-        [[nodiscard]] constexpr Vector2 normalized() const noexcept
+        [[nodiscard("You must use normalized vector")]] constexpr Vector2 normalized() const noexcept
         {
             const Type len = length();
             return len > 0.f ? *this / len : *this;
         }
 #else
-        [[nodiscard]] Type length() const noexcept
+        [[nodiscard("You must use length")]]
+        constexpr Type length() const noexcept
         {
-            return std::hypot(x, y);
+            return internal::hypot(x, y);
         }
 
-        [[nodiscard]] Vector2 normalized() const noexcept
+        [[nodiscard("You must use normalized vector")]]
+        constexpr 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
+        [[nodiscard("You must use squared length")]]
+        constexpr Type length_sqr() const noexcept
         {
             return x * x + y * y;
         }
@@ -165,80 +172,91 @@ namespace omath
             y = y < static_cast<Type>(0) ? -y : y;
             return *this;
         }
+        [[nodiscard("You must use absed vector")]]
+        constexpr Vector2 abs() const noexcept
+        {
+            return Vector2{*this}.abs();
+        }
 
-        [[nodiscard]] constexpr Vector2 operator-() const noexcept
+        [[nodiscard("You must use negated vector")]]
+        constexpr Vector2 operator-() const noexcept
         {
             return {-x, -y};
         }
 
         // Binary arithmetic operators
-        [[nodiscard]] constexpr Vector2 operator+(const Vector2& other) const noexcept
+        [[nodiscard("You must use result vector")]]
+        constexpr Vector2 operator+(const Vector2& other) const noexcept
         {
             return {x + other.x, y + other.y};
         }
 
-        [[nodiscard]] constexpr Vector2 operator-(const Vector2& other) const noexcept
+        [[nodiscard("You must use result vector")]]
+        constexpr Vector2 operator-(const Vector2& other) const noexcept
         {
             return {x - other.x, y - other.y};
         }
 
-        [[nodiscard]] constexpr Vector2 operator*(const Type& value) const noexcept
+        [[nodiscard("You must use result vector")]]
+        constexpr Vector2 operator*(const Type& value) const noexcept
         {
             return {x * value, y * value};
         }
 
-        [[nodiscard]] constexpr Vector2 operator/(const Type& value) const noexcept
+        [[nodiscard("You must use result vector")]]
+        constexpr Vector2 operator/(const Type& value) const noexcept
         {
             return {x / value, y / value};
         }
 
         // Sum of elements
-        [[nodiscard]] constexpr Type sum() const noexcept
+        [[nodiscard("You must use sum of elements")]]
+        constexpr Type sum() const noexcept
         {
             return x + y;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
-        bool operator<(const Vector2& other) const noexcept
+        constexpr bool operator<(const Vector2& other) const noexcept
         {
             return length() < other.length();
         }
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
-        bool operator>(const Vector2& other) const noexcept
+        constexpr bool operator>(const Vector2& other) const noexcept
         {
             return length() > other.length();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
-        bool operator<=(const Vector2& other) const noexcept
+        constexpr bool operator<=(const Vector2& other) const noexcept
         {
             return length() <= other.length();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
-        bool operator>=(const Vector2& other) const noexcept
+        constexpr bool operator>=(const Vector2& other) const noexcept
         {
             return length() >= other.length();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use tuple")]]
         constexpr std::tuple<Type, Type> as_tuple() const noexcept
         {
             return std::make_tuple(x, y);
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use array")]]
         constexpr std::array<Type, 2> as_array() const noexcept
         {
             return {x, y};
         }
 #ifdef OMATH_IMGUI_INTEGRATION
-        [[nodiscard]]
+        [[nodiscard("You must use ImVec2")]]
         constexpr ImVec2 to_im_vec2() const noexcept
         {
             return {static_cast<float>(this->x), static_cast<float>(this->y)};
         }
-        [[nodiscard]]
+        [[nodiscard("You must use vector from ImVec2")]]
         static Vector2 from_im_vec2(const ImVec2& other) noexcept
         {
             return {static_cast<Type>(other.x), static_cast<Type>(other.y)};
@@ -249,7 +267,7 @@ namespace omath
 
 template<> struct std::hash<omath::Vector2<float>>
 {
-    [[nodiscard]]
+    [[nodiscard("You must use hash value")]]
     std::size_t operator()(const omath::Vector2<float>& vec) const noexcept
     {
         std::size_t hash = 0;
@@ -265,14 +283,14 @@ template<> struct std::hash<omath::Vector2<float>>
 template<class Type>
 struct std::formatter<omath::Vector2<Type>> // NOLINT(*-dcl58-cpp)
 {
-    [[nodiscard]]
+    [[nodiscard("You must use parse iterator")]]
     static constexpr auto parse(std::format_parse_context& ctx)
     {
         return ctx.begin();
     }
 
     template<class FormatContext>
-    [[nodiscard]]
+    [[nodiscard("You must use format iterator")]]
     static auto format(const omath::Vector2<Type>& vec, FormatContext& ctx)
     {
         if constexpr (std::is_same_v<typename FormatContext::char_type, char>)

include/omath/linear_algebra/vector3.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/linear_algebra/vector2.hpp"
 #include "omath/trigonometry/angle.hpp"
 #include <cstdint>
@@ -32,17 +33,20 @@ namespace omath
 
         template<class CastedType>
         requires std::is_arithmetic_v<CastedType>
-        [[nodiscard]] constexpr explicit operator Vector3<CastedType>() const noexcept
+        [[nodiscard("You must use casted vector")]]
+        constexpr explicit operator Vector3<CastedType>() const noexcept
         {
             return {static_cast<CastedType>(this->x), static_cast<CastedType>(this->y),
                     static_cast<CastedType>(this->z)};
         }
-        [[nodiscard]] constexpr bool operator==(const Vector3& other) const noexcept
+        [[nodiscard("You must use comparison result")]]
+        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
+        [[nodiscard("You must use comparison result")]]
+        constexpr bool operator!=(const Vector3& other) const noexcept
         {
             return !(*this == other);
         }
@@ -118,130 +122,151 @@ namespace omath
 
             return *this;
         }
+        [[nodiscard("You must use absed vector")]]
+        constexpr Vector3 abs() const noexcept
+        {
+            return Vector3{*this}.abs();
+        }
 
-        [[nodiscard]] constexpr Type distance_to_sqr(const Vector3& other) const noexcept
+        [[nodiscard("You must use squared distance")]]
+        constexpr Type distance_to_sqr(const Vector3& other) const noexcept
         {
             return (*this - other).length_sqr();
         }
 
-        [[nodiscard]] constexpr Type dot(const Vector3& other) const noexcept
+        [[nodiscard("You must use dot product")]]
+        constexpr Type dot(const Vector3& other) const noexcept
         {
             return Vector2<Type>::dot(other) + z * other.z;
         }
 
 #ifndef _MSC_VER
-        [[nodiscard]] constexpr Type length() const
+        [[nodiscard("You must use length")]] constexpr Type length() const noexcept
         {
-            return std::hypot(this->x, this->y, z);
+            return internal::hypot(this->x, this->y, z);
         }
 
-        [[nodiscard]] constexpr Type length_2d() const
+        [[nodiscard("You must use 2D length")]] constexpr Type length_2d() const noexcept
         {
             return Vector2<Type>::length();
         }
-        [[nodiscard]] Type distance_to(const Vector3& other) const
+        [[nodiscard("You must use distance")]] constexpr Type distance_to(const Vector3& other) const noexcept
         {
             return (*this - other).length();
         }
-        [[nodiscard]] constexpr Vector3 normalized() const
+        [[nodiscard("You must use normalized vector")]] constexpr Vector3 normalized() const noexcept
         {
             const Type length_value = this->length();
 
             return length_value != 0 ? *this / length_value : *this;
         }
 #else
-        [[nodiscard]] Type length() const noexcept
+        [[nodiscard("You must use length")]]
+        constexpr Type length() const noexcept
         {
-            return std::hypot(this->x, this->y, z);
+            return internal::hypot(this->x, this->y, this->z);
         }
 
-        [[nodiscard]] Vector3 normalized() const noexcept
+        [[nodiscard("You must use normalized vector")]]
+        constexpr Vector3 normalized() const noexcept
         {
             const Type len = this->length();
 
             return len != static_cast<Type>(0) ? *this / len : *this;
         }
 
-        [[nodiscard]] Type length_2d() const noexcept
+        [[nodiscard("You must use 2D length")]]
+        constexpr Type length_2d() const noexcept
         {
             return Vector2<Type>::length();
         }
 
-        [[nodiscard]] Type distance_to(const Vector3& v_other) const noexcept
+        [[nodiscard("You must use distance")]]
+        constexpr Type distance_to(const Vector3& v_other) const noexcept
         {
             return (*this - v_other).length();
         }
 #endif
 
-        [[nodiscard]] constexpr Type length_sqr() const noexcept
+        [[nodiscard("You must use squared length")]]
+        constexpr Type length_sqr() const noexcept
         {
             return Vector2<Type>::length_sqr() + z * z;
         }
 
-        [[nodiscard]] constexpr Vector3 operator-() const noexcept
+        [[nodiscard("You must use negated vector")]]
+        constexpr Vector3 operator-() const noexcept
         {
             return {-this->x, -this->y, -z};
         }
 
-        [[nodiscard]] constexpr Vector3 operator+(const Vector3& other) const noexcept
+        [[nodiscard("You must use result vector")]]
+        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
+        [[nodiscard("You must use result vector")]]
+        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
+        [[nodiscard("You must use result vector")]]
+        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
+        [[nodiscard("You must use result vector")]]
+        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
+        [[nodiscard("You must use result vector")]]
+        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
+        [[nodiscard("You must use result vector")]]
+        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
+        [[nodiscard("You must use cross product")]]
+        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
+        [[nodiscard("You must use sum of elements")]]
+        constexpr Type sum() const noexcept
         {
             return sum_2d() + z;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use direction check result")]]
-        bool point_to_same_direction(const Vector3& other) const
+        constexpr bool point_to_same_direction(const Vector3& other) const
         {
             return dot(other) > static_cast<Type>(0);
         }
-        [[nodiscard]] std::expected<Angle<float, 0.f, 180.f, AngleFlags::Clamped>, Vector3Error>
+        [[nodiscard("You must use angle between vectors")]]
+        constexpr 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(internal::acos(dot(other) / bottom));
-            return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::from_radians(std::acos(dot(other) / bottom));
         }
 
-        [[nodiscard]] bool is_perpendicular(const Vector3& other,
+        [[nodiscard("You must use perpendicularity check result")]]
-                                            Type epsilon = static_cast<Type>(0.0001)) const noexcept
+        constexpr bool is_perpendicular(const Vector3& other, Type epsilon = static_cast<Type>(0.0001)) const noexcept
         {
             if (const auto angle = angle_between(other))
                 return std::abs(angle->as_degrees() - static_cast<Type>(90)) <= epsilon;
@@ -249,41 +274,43 @@ namespace omath
             return false;
         }
 
-        [[nodiscard]] constexpr Type sum_2d() const noexcept
+        [[nodiscard("You must use 2D sum")]]
+        constexpr Type sum_2d() const noexcept
         {
             return Vector2<Type>::sum();
         }
 
-        [[nodiscard]] constexpr std::tuple<Type, Type, Type> as_tuple() const noexcept
+        [[nodiscard("You must use tuple")]]
+        constexpr std::tuple<Type, Type, Type> as_tuple() const noexcept
         {
             return std::make_tuple(this->x, this->y, z);
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
-        bool operator<(const Vector3& other) const noexcept
+        constexpr bool operator<(const Vector3& other) const noexcept
         {
             return length() < other.length();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
-        bool operator>(const Vector3& other) const noexcept
+        constexpr bool operator>(const Vector3& other) const noexcept
         {
             return length() > other.length();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
-        bool operator<=(const Vector3& other) const noexcept
+        constexpr bool operator<=(const Vector3& other) const noexcept
         {
             return length() <= other.length();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
-        bool operator>=(const Vector3& other) const noexcept
+        constexpr bool operator>=(const Vector3& other) const noexcept
         {
             return length() >= other.length();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use array")]]
         constexpr std::array<Type, 3> as_array() const noexcept
         {
             return {this->x, this->y, z};
@@ -293,7 +320,8 @@ namespace omath
 
 template<> struct std::hash<omath::Vector3<float>>
 {
-    [[nodiscard]]
+    // NOTE: Cannot be constexpr because of MSVC
+    [[nodiscard("You must use hash value")]]
     std::size_t operator()(const omath::Vector3<float>& vec) const noexcept
     {
         std::size_t hash = 0;
@@ -310,14 +338,14 @@ template<> struct std::hash<omath::Vector3<float>>
 template<class Type>
 struct std::formatter<omath::Vector3<Type>> // NOLINT(*-dcl58-cpp)
 {
-    [[nodiscard]]
+    [[nodiscard("You must use parse iterator")]]
     static constexpr auto parse(std::format_parse_context& ctx)
     {
         return ctx.begin();
     }
 
     template<class FormatContext>
-    [[nodiscard]]
+    [[nodiscard("You must use format iterator")]]
     static auto format(const omath::Vector3<Type>& vec, FormatContext& ctx)
     {
         if constexpr (std::is_same_v<typename FormatContext::char_type, char>)

include/omath/linear_algebra/vector4.hpp

@@ -24,19 +24,19 @@ namespace omath
 
         template<class CastedType>
         requires std::is_arithmetic_v<CastedType>
-        [[nodiscard]] constexpr explicit operator Vector4<CastedType>() const noexcept
+        [[nodiscard("You must use casted vector")]] constexpr explicit operator Vector4<CastedType>() const noexcept
         {
             return {static_cast<CastedType>(this->x), static_cast<CastedType>(this->y),
                     static_cast<CastedType>(this->z), static_cast<CastedType>(this->w)};
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
         constexpr bool operator==(const Vector4& other) const noexcept
         {
             return Vector3<Type>::operator==(other) && w == other.w;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
         constexpr bool operator!=(const Vector4& other) const noexcept
         {
             return !(*this == other);
@@ -89,17 +89,19 @@ namespace omath
             return *this;
         }
 
-        [[nodiscard]] constexpr Type length_sqr() const noexcept
+        [[nodiscard("You must use squared length")]]
+        constexpr Type length_sqr() const noexcept
         {
             return Vector3<Type>::length_sqr() + w * w;
         }
 
-        [[nodiscard]] constexpr Type dot(const Vector4& other) const noexcept
+        [[nodiscard("You must use dot product")]]
+        constexpr Type dot(const Vector4& other) const noexcept
         {
             return Vector3<Type>::dot(other) + w * other.w;
         }
 
-        [[nodiscard]] Type length() const noexcept
+        [[nodiscard("You must use length")]] Type length() const noexcept
         {
             return std::sqrt(length_sqr());
         }
@@ -111,6 +113,11 @@ namespace omath
 
             return *this;
         }
+        [[nodiscard("You must use absed vector")]]
+        constexpr Vector4 abs() const noexcept
+        {
+            return Vector4{*this}.abs();
+        }
         constexpr Vector4& clamp(const Type& min, const Type& max) noexcept
         {
             this->x = std::clamp(this->x, min, max);
@@ -120,86 +127,86 @@ namespace omath
             return *this;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use negated vector")]]
         constexpr Vector4 operator-() const noexcept
         {
             return {-this->x, -this->y, -this->z, -w};
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use result vector")]]
         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]]
+        [[nodiscard("You must use result vector")]]
         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]]
+        [[nodiscard("You must use result vector")]]
         constexpr Vector4 operator*(const Type& value) const noexcept
         {
             return {this->x * value, this->y * value, this->z * value, w * value};
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use result vector")]]
         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]]
+        [[nodiscard("You must use result vector")]]
         constexpr Vector4 operator/(const Type& value) const noexcept
         {
             return {this->x / value, this->y / value, this->z / value, w / value};
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use result vector")]]
         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]]
+        [[nodiscard("You must use sum of elements")]]
         constexpr Type sum() const noexcept
         {
             return Vector3<Type>::sum() + w;
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
         bool operator<(const Vector4& other) const noexcept
         {
             return length() < other.length();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
         bool operator>(const Vector4& other) const noexcept
         {
             return length() > other.length();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
         bool operator<=(const Vector4& other) const noexcept
         {
             return length() <= other.length();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use comparison result")]]
         bool operator>=(const Vector4& other) const noexcept
         {
             return length() >= other.length();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use array")]]
         constexpr std::array<Type, 4> as_array() const noexcept
         {
             return {this->x, this->y, this->z, w};
         }
 
 #ifdef OMATH_IMGUI_INTEGRATION
-        [[nodiscard]]
+        [[nodiscard("You must use ImVec4")]]
         constexpr ImVec4 to_im_vec4() const noexcept
         {
             return {
@@ -209,7 +216,7 @@ namespace omath
                     static_cast<float>(w),
             };
         }
-        [[nodiscard]]
+        [[nodiscard("You must use vector from ImVec4")]]
         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)};
@@ -220,7 +227,7 @@ namespace omath
 
 template<> struct std::hash<omath::Vector4<float>>
 {
-    [[nodiscard]]
+    [[nodiscard("You must use hash value")]]
     std::size_t operator()(const omath::Vector4<float>& vec) const noexcept
     {
         std::size_t hash = 0;
@@ -237,13 +244,13 @@ template<> struct std::hash<omath::Vector4<float>>
 template<class Type>
 struct std::formatter<omath::Vector4<Type>> // NOLINT(*-dcl58-cpp)
 {
-    [[nodiscard]]
+    [[nodiscard("You must use parse iterator")]]
     static constexpr auto parse(std::format_parse_context& ctx)
     {
         return ctx.begin();
     }
     template<class FormatContext>
-    [[nodiscard]]
+    [[nodiscard("You must use format iterator")]]
     static auto format(const omath::Vector4<Type>& vec, FormatContext& ctx)
     {
         if constexpr (std::is_same_v<typename FormatContext::char_type, char>)

include/omath/lua/lua.hpp

@@ -15,8 +15,13 @@ namespace omath::lua
         static void register_vec2(sol::table& omath_table);
         static void register_vec3(sol::table& omath_table);
         static void register_vec4(sol::table& omath_table);
+        static void register_matrices(sol::table& omath_table);
+        static void register_quaternion(sol::table& omath_table);
         static void register_color(sol::table& omath_table);
+        static void register_hud(sol::table& omath_table);
         static void register_triangle(sol::table& omath_table);
+        static void register_3d_primitives(sol::table& omath_table);
+        static void register_collision(sol::table& omath_table);
         static void register_shared_types(sol::table& omath_table);
         static void register_engines(sol::table& omath_table);
         static void register_pattern_scan(sol::table& omath_table);

include/omath/omath.hpp

@@ -87,6 +87,12 @@
 #include "omath/engines/frostbite_engine/traits/camera_trait.hpp"
 #include "omath/engines/frostbite_engine/traits/pred_engine_trait.hpp"
 
+// RAGE Engine
+#include "omath/engines/rage_engine/constants.hpp"
+#include "omath/engines/rage_engine/formulas.hpp"
+#include "omath/engines/rage_engine/camera.hpp"
+#include "omath/engines/rage_engine/traits/camera_trait.hpp"
+#include "omath/engines/rage_engine/traits/pred_engine_trait.hpp"
 
 // Unreal Engine
 #include "omath/engines/unreal_engine/constants.hpp"

include/omath/projection/camera.hpp

@@ -5,6 +5,8 @@
 #pragma once
 
 #include "omath/3d_primitives/aabb.hpp"
+#include "omath/3d_primitives/obb.hpp"
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
@@ -31,7 +33,7 @@ namespace omath::projection
         float m_width;
         float m_height;
 
-        [[nodiscard]] constexpr float aspect_ratio() const
+        [[nodiscard("You must use aspect ratio")]] constexpr float aspect_ratio() const
         {
             return m_width / m_height;
         }
@@ -83,8 +85,9 @@ namespace omath::projection
         };
 
         ~Camera() = default;
-        Camera(const Vector3<NumericType>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
+        constexpr Camera(const Vector3<NumericType>& position, const ViewAnglesType& view_angles,
-               const FieldOfView& fov, const NumericType near, const NumericType far) noexcept
+                         const ViewPort& view_port, const FieldOfView& fov, const NumericType near,
+                         const NumericType 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)
         {
@@ -100,18 +103,19 @@ namespace omath::projection
         // built by any of the engine traits.  Both variants (ZERO_TO_ONE and
         // NEGATIVE_ONE_TO_ONE) share the same m[0,0]/m[1,1] layout, so this works
         // regardless of the NDC depth range.
-        [[nodiscard]]
+        [[nodiscard("You must use extracted projection params")]]
-        static ProjectionParams extract_projection_params(const Mat4X4Type& proj_matrix) noexcept
+        constexpr static ProjectionParams extract_projection_params(const Mat4X4Type& proj_matrix) noexcept
         {
             // m[1,1] == 1 / tan(fov/2)  =>  fov = 2 * atan(1 / m[1,1])
             const auto f = proj_matrix.at(1, 1);
             // m[0,0] == m[1,1] / aspect_ratio  =>  aspect = m[1,1] / m[0,0]
-            return {FieldOfView::from_radians(NumericType{2} * std::atan(NumericType{1} / f)),
+            const auto fov_radians = NumericType{2} * internal::atan(NumericType{1} / f);
+            return {FieldOfView::from_radians(static_cast<typename FieldOfView::ArithmeticType>(fov_radians)),
                     f / proj_matrix.at(0, 0)};
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use calculated view angles")]]
-        static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept
+        constexpr static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept
         {
             Vector3<NumericType> forward_vector = {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]};
             if constexpr (axes.inverted_forward)
@@ -119,8 +123,8 @@ namespace omath::projection
             return TraitClass::calc_look_at_angle({}, forward_vector);
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use calculated origin")]]
-        static Vector3<NumericType> calc_origin_from_view_matrix(const Mat4X4Type& view_matrix) noexcept
+        constexpr static Vector3<NumericType> calc_origin_from_view_matrix(const Mat4X4Type& view_matrix) noexcept
         {
             // The view matrix is R * T(-origin), so the last column stores t = -R * origin.
             // Recovering origin: origin = -R^T * t
@@ -134,61 +138,99 @@ namespace omath::projection
             };
         }
 
-        void look_at(const Vector3<NumericType>& target)
+        constexpr void look_at(const Vector3<NumericType>& target)
         {
             m_view_angles = TraitClass::calc_look_at_angle(m_origin, target);
             m_view_projection_matrix = std::nullopt;
             m_view_matrix = std::nullopt;
         }
-        [[nodiscard]]
+        [[nodiscard("You must use calculated look-at angles")]]
-        ViewAnglesType calc_look_at_angles(const Vector3<NumericType>& look_to) const
+        constexpr ViewAnglesType calc_look_at_angles(const Vector3<NumericType>& look_to) const
         {
             return TraitClass::calc_look_at_angle(m_origin, look_to);
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use forward vector")]]
-        Vector3<NumericType> get_forward() const noexcept
+        constexpr Vector3<NumericType> get_forward() const noexcept
         {
+            if consteval
+            {
+                const auto view_matrix = calc_view_matrix();
+                return {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]};
+            }
+
             const auto& view_matrix = get_view_matrix();
             return {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]};
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use right vector")]]
-        Vector3<NumericType> get_right() const noexcept
+        constexpr Vector3<NumericType> get_right() const noexcept
         {
+            if consteval
+            {
+                const auto view_matrix = calc_view_matrix();
+                return {view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]};
+            }
+
             const auto& view_matrix = get_view_matrix();
             return {view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]};
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use up vector")]]
-        Vector3<NumericType> get_up() const noexcept
+        constexpr Vector3<NumericType> get_up() const noexcept
         {
+            if consteval
+            {
+                const auto view_matrix = calc_view_matrix();
+                return {view_matrix[1, 0], view_matrix[1, 1], view_matrix[1, 2]};
+            }
+
             const auto& view_matrix = get_view_matrix();
             return {view_matrix[1, 0], view_matrix[1, 1], view_matrix[1, 2]};
         }
-        [[nodiscard]]
+        [[nodiscard("You must use absolute forward vector")]]
-        Vector3<NumericType> get_abs_forward() const noexcept
+        constexpr Vector3<NumericType> get_abs_forward() const noexcept
         {
             if constexpr (axes.inverted_forward)
                 return -get_forward();
             return get_forward();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use absolute right vector")]]
-        Vector3<NumericType> get_abs_right() const noexcept
+        constexpr Vector3<NumericType> get_abs_right() const noexcept
         {
             if constexpr (axes.inverted_right)
                 return -get_right();
             return get_right();
         }
 
-        [[nodiscard]]
+        [[nodiscard("You must use absolute up vector")]]
-        Vector3<NumericType> get_abs_up() const noexcept
+        constexpr Vector3<NumericType> get_abs_up() const noexcept
         {
             return get_up();
         }
 
-        [[nodiscard]] const Mat4X4Type& get_view_projection_matrix() const noexcept
+        [[nodiscard("You must use calculated view-projection matrix")]]
+        constexpr Mat4X4Type calc_view_projection_matrix() const noexcept
+        {
+            return calc_projection_matrix() * calc_view_matrix();
+        }
+
+        [[nodiscard("You must use calculated view matrix")]]
+        constexpr Mat4X4Type calc_view_matrix() const noexcept
+        {
+            return TraitClass::calc_view_matrix(m_view_angles, m_origin);
+        }
+
+        [[nodiscard("You must use calculated projection matrix")]]
+        constexpr Mat4X4Type calc_projection_matrix() const noexcept
+        {
+            return TraitClass::calc_projection_matrix(m_field_of_view, m_view_port, m_near_plane_distance,
+                                                      m_far_plane_distance, depth_range);
+        }
+
+        [[nodiscard("You must use view-projection matrix")]]
+        constexpr const Mat4X4Type& get_view_projection_matrix() const noexcept
         {
             if (!m_view_projection_matrix.has_value())
                 m_view_projection_matrix = get_projection_matrix() * get_view_matrix();
@@ -196,90 +238,90 @@ namespace omath::projection
             return m_view_projection_matrix.value();
         }
 
-        [[nodiscard]] const Mat4X4Type& get_view_matrix() const noexcept
+        [[nodiscard("You must use view matrix")]] constexpr const Mat4X4Type& get_view_matrix() const noexcept
         {
             if (!m_view_matrix.has_value())
-                m_view_matrix = TraitClass::calc_view_matrix(m_view_angles, m_origin);
+                m_view_matrix = calc_view_matrix();
 
             return m_view_matrix.value();
         }
-        [[nodiscard]] const Mat4X4Type& get_projection_matrix() const noexcept
+        [[nodiscard("You must use projection matrix")]] constexpr const Mat4X4Type&
+        get_projection_matrix() const noexcept
         {
             if (!m_projection_matrix.has_value())
-                m_projection_matrix = TraitClass::calc_projection_matrix(
+                m_projection_matrix = calc_projection_matrix();
-                        m_field_of_view, m_view_port, m_near_plane_distance, m_far_plane_distance, depth_range);
 
             return m_projection_matrix.value();
         }
 
-        void set_field_of_view(const FieldOfView& fov) noexcept
+        constexpr void set_field_of_view(const FieldOfView& fov) noexcept
         {
             m_field_of_view = fov;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
 
-        void set_near_plane(const NumericType near_plane) noexcept
+        constexpr void set_near_plane(const NumericType near_plane) noexcept
         {
             m_near_plane_distance = near_plane;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
 
-        void set_far_plane(const NumericType far_plane) noexcept
+        constexpr void set_far_plane(const NumericType far_plane) noexcept
         {
             m_far_plane_distance = far_plane;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
 
-        void set_view_angles(const ViewAnglesType& view_angles) noexcept
+        constexpr void set_view_angles(const ViewAnglesType& view_angles) noexcept
         {
             m_view_angles = view_angles;
             m_view_projection_matrix = std::nullopt;
             m_view_matrix = std::nullopt;
         }
 
-        void set_origin(const Vector3<NumericType>& origin) noexcept
+        constexpr void set_origin(const Vector3<NumericType>& origin) noexcept
         {
             m_origin = origin;
             m_view_projection_matrix = std::nullopt;
             m_view_matrix = std::nullopt;
         }
-        void set_view_port(const ViewPort& view_port) noexcept
+        constexpr void set_view_port(const ViewPort& view_port) noexcept
         {
             m_view_port = view_port;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
 
-        [[nodiscard]] const FieldOfView& get_field_of_view() const noexcept
+        [[nodiscard("You must use field of view")]] constexpr const FieldOfView& get_field_of_view() const noexcept
         {
             return m_field_of_view;
         }
 
-        [[nodiscard]] const NumericType& get_near_plane() const noexcept
+        [[nodiscard("You must use near plane")]] constexpr const NumericType& get_near_plane() const noexcept
         {
             return m_near_plane_distance;
         }
 
-        [[nodiscard]] const NumericType& get_far_plane() const noexcept
+        [[nodiscard("You must use far plane")]] constexpr const NumericType& get_far_plane() const noexcept
         {
             return m_far_plane_distance;
         }
 
-        [[nodiscard]] const ViewAnglesType& get_view_angles() const noexcept
+        [[nodiscard("You must use view angles")]] constexpr const ViewAnglesType& get_view_angles() const noexcept
         {
             return m_view_angles;
         }
 
-        [[nodiscard]] const Vector3<NumericType>& get_origin() const noexcept
+        [[nodiscard("You must use origin")]] constexpr const Vector3<NumericType>& get_origin() const noexcept
         {
             return m_origin;
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard]] std::expected<Vector3<NumericType>, Error>
+        [[nodiscard("You must use screen position")]] constexpr std::expected<Vector3<NumericType>, Error>
         world_to_screen(const Vector3<NumericType>& world_position) const noexcept
         {
             const auto normalized_cords = world_to_view_port(world_position);
@@ -295,7 +337,7 @@ namespace omath::projection
                 std::unreachable();
         }
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard]] std::expected<Vector3<NumericType>, Error>
+        [[nodiscard("You must use unclipped screen position")]] constexpr std::expected<Vector3<NumericType>, Error>
         world_to_screen_unclipped(const Vector3<NumericType>& world_position) const noexcept
         {
             const auto normalized_cords = world_to_view_port(world_position, ViewPortClipping::MANUAL);
@@ -311,7 +353,8 @@ namespace omath::projection
                 std::unreachable();
         }
 
-        [[nodiscard]] bool is_culled_by_frustum(const Triangle<Vector3<NumericType>>& triangle) const noexcept
+        [[nodiscard("You must use frustum culling result")]] constexpr bool
+        is_culled_by_frustum(const Triangle<Vector3<NumericType>>& triangle) const noexcept
         {
             // Transform to clip space (before perspective divide)
             auto to_clip = [this](const Vector3<NumericType>& point)
@@ -378,51 +421,12 @@ namespace omath::projection
             return false;
         }
 
-        [[nodiscard]] bool is_aabb_culled_by_frustum(const primitives::Aabb<NumericType>& aabb) const noexcept
+        [[nodiscard("You must use AABB frustum culling result")]] constexpr bool
+        is_aabb_culled_by_frustum(const primitives::Aabb<NumericType>& aabb) const noexcept
         {
-            const auto& m = get_view_projection_matrix();
-
-            // Gribb-Hartmann: extract 6 frustum planes from the view-projection matrix.
-            // Each plane is (a, b, c, d) such that ax + by + cz + d >= 0 means inside.
-            // For a 4x4 matrix with rows r0..r3:
-            //   Left   = r3 + r0
-            //   Right  = r3 - r0
-            //   Bottom = r3 + r1
-            //   Top    = r3 - r1
-            //   Near   = r3 + r2  ([-1,1]) or r2 ([0,1])
-            //   Far    = r3 - r2
-            struct Plane final
-            {
-                NumericType a, b, c, d;
-            };
-
-            const auto extract_plane = [&m](const int sign, const int row) -> Plane
-            {
-                return {
-                        m.at(3, 0) + static_cast<NumericType>(sign) * m.at(row, 0),
-                        m.at(3, 1) + static_cast<NumericType>(sign) * m.at(row, 1),
-                        m.at(3, 2) + static_cast<NumericType>(sign) * m.at(row, 2),
-                        m.at(3, 3) + static_cast<NumericType>(sign) * m.at(row, 3),
-                };
-            };
-
-            std::array<Plane, 6> planes = {
-                    extract_plane(1, 0), // left
-                    extract_plane(-1, 0), // right
-                    extract_plane(1, 1), // bottom
-                    extract_plane(-1, 1), // top
-                    extract_plane(-1, 2), // far
-            };
-
-            // Near plane depends on NDC depth range
-            if constexpr (depth_range == NDCDepthRange::ZERO_TO_ONE)
-                planes[5] = {m.at(2, 0), m.at(2, 1), m.at(2, 2), m.at(2, 3)};
-            else
-                planes[5] = extract_plane(1, 2);
-
             // For each plane, find the AABB corner most in the direction of the plane normal
             // (the "positive vertex"). If it's outside, the entire AABB is outside.
-            for (const auto& [a, b, c, d] : planes)
+            for (const auto& [a, b, c, d] : extract_frustum_planes())
             {
                 const auto px = a >= NumericType{0} ? aabb.max.x : aabb.min.x;
                 const auto py = b >= NumericType{0} ? aabb.max.y : aabb.min.y;
@@ -435,13 +439,33 @@ namespace omath::projection
             return false;
         }
 
-        [[nodiscard]] std::expected<Vector3<NumericType>, Error>
+        [[nodiscard("You must use OBB frustum culling result")]] constexpr bool
+        is_obb_culled_by_frustum(const primitives::Obb<NumericType>& obb) const noexcept
+        {
+            // For each plane, project the OBB extents onto the plane normal to get the
+            // effective radius, then test the center's signed distance against it.
+            for (const auto& [a, b, c, d] : extract_frustum_planes())
+            {
+                const Vector3<NumericType> normal{a, b, c};
+
+                const auto center_distance = normal.dot(obb.center) + d;
+                const auto radius = obb.half_extents.x * internal::abs(normal.dot(obb.axis_x))
+                                    + obb.half_extents.y * internal::abs(normal.dot(obb.axis_y))
+                                    + obb.half_extents.z * internal::abs(normal.dot(obb.axis_z));
+
+                if (center_distance + radius < NumericType{0})
+                    return true;
+            }
+
+            return false;
+        }
+
+        [[nodiscard("You must use view port position")]] constexpr std::expected<Vector3<NumericType>, Error>
         world_to_view_port(const Vector3<NumericType>& world_position,
                            const ViewPortClipping& clipping = ViewPortClipping::AUTO) const noexcept
         {
-            auto projected = get_view_projection_matrix()
+            auto project_to_view_port = [&clipping](auto projected) -> std::expected<Vector3<NumericType>, Error>
-                             * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(world_position);
+            {
-
                 const auto& w = projected.at(3, 0);
                 constexpr auto eps = std::numeric_limits<NumericType>::epsilon();
                 if (w <= eps)
@@ -450,7 +474,8 @@ namespace omath::projection
                 projected /= w;
 
                 // ReSharper disable once CppTooWideScope
-            const auto clipped_automatically = clipping == ViewPortClipping::AUTO && is_ndc_out_of_bounds(projected);
+                const auto clipped_automatically =
+                        clipping == ViewPortClipping::AUTO && is_ndc_out_of_bounds(projected);
                 if (clipped_automatically)
                     return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
@@ -463,40 +488,65 @@ namespace omath::projection
                     return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
                 return Vector3<NumericType>{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)};
-        }
+            };
-        [[nodiscard]]
+
-        std::expected<Vector3<NumericType>, Error> view_port_to_world(const Vector3<NumericType>& ndc) const noexcept
+            if consteval
             {
-            const auto inv_view_proj = get_view_projection_matrix().inverted();
+                auto projected =
+                        calc_view_projection_matrix()
+                        * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(world_position);
+                return project_to_view_port(projected);
+            }
+
+            auto projected = get_view_projection_matrix()
+                             * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(world_position);
+            return project_to_view_port(projected);
+        }
+        [[nodiscard("You must use world position")]]
+        constexpr std::expected<Vector3<NumericType>, Error>
+        view_port_to_world(const Vector3<NumericType>& ndc) const noexcept
+        {
+            auto view_port_to_world =
+                    [&ndc](const Mat4X4Type& view_projection) -> std::expected<Vector3<NumericType>, Error>
+            {
+                const auto inv_view_proj = view_projection.inverted();
 
                 if (!inv_view_proj)
                     return std::unexpected(Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO);
 
-            auto inverted_projection =
+                auto inverted_projection = inv_view_proj.value()
-                    inv_view_proj.value() * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(ndc);
+                                           * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(ndc);
 
                 const auto& w = inverted_projection.at(3, 0);
 
-            if (std::abs(w) < std::numeric_limits<NumericType>::epsilon())
+                if (internal::abs(w) < std::numeric_limits<NumericType>::epsilon())
                     return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
                 inverted_projection /= w;
 
                 return Vector3<NumericType>{inverted_projection.at(0, 0), inverted_projection.at(1, 0),
                                             inverted_projection.at(2, 0)};
+            };
+
+            if consteval
+            {
+                return view_port_to_world(calc_view_projection_matrix());
+            }
+
+            return view_port_to_world(get_view_projection_matrix());
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard]]
+        [[nodiscard("You must use world position")]]
-        std::expected<Vector3<NumericType>, Error>
+        constexpr std::expected<Vector3<NumericType>, Error>
         screen_to_world(const Vector3<NumericType>& screen_pos) const noexcept
         {
             return view_port_to_world(screen_to_ndc<screen_start>(screen_pos));
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard]]
+        [[nodiscard("You must use world position")]]
-        std::expected<Vector3<NumericType>, Error>
+        constexpr std::expected<Vector3<NumericType>, Error>
         screen_to_world(const Vector2<NumericType>& screen_pos) const noexcept
         {
             const auto& [x, y] = screen_pos;
@@ -517,8 +567,55 @@ namespace omath::projection
         Vector3<NumericType> m_origin;
 
     private:
+        struct FrustumPlane final
+        {
+            NumericType a, b, c, d;
+        };
+
+        // Gribb-Hartmann: extract 6 frustum planes from the view-projection matrix.
+        // Each plane is (a, b, c, d) such that ax + by + cz + d >= 0 means inside.
+        // For a 4x4 matrix with rows r0..r3:
+        //   Left   = r3 + r0
+        //   Right  = r3 - r0
+        //   Bottom = r3 + r1
+        //   Top    = r3 - r1
+        //   Near   = r3 + r2  ([-1,1]) or r2 ([0,1])
+        //   Far    = r3 - r2
+        [[nodiscard("You must use frustum planes")]] constexpr std::array<FrustumPlane, 6>
+        extract_frustum_planes() const noexcept
+        {
+            const auto& m = get_view_projection_matrix();
+
+            const auto extract_plane = [&m](const int sign, const int row) -> FrustumPlane
+            {
+                return {
+                        m.at(3, 0) + static_cast<NumericType>(sign) * m.at(row, 0),
+                        m.at(3, 1) + static_cast<NumericType>(sign) * m.at(row, 1),
+                        m.at(3, 2) + static_cast<NumericType>(sign) * m.at(row, 2),
+                        m.at(3, 3) + static_cast<NumericType>(sign) * m.at(row, 3),
+                };
+            };
+
+            std::array<FrustumPlane, 6> planes = {
+                    extract_plane(1, 0), // left
+                    extract_plane(-1, 0), // right
+                    extract_plane(1, 1), // bottom
+                    extract_plane(-1, 1), // top
+                    extract_plane(-1, 2), // far
+            };
+
+            // Near plane depends on NDC depth range
+            if constexpr (depth_range == NDCDepthRange::ZERO_TO_ONE)
+                planes[5] = {m.at(2, 0), m.at(2, 1), m.at(2, 2), m.at(2, 3)};
+            else
+                planes[5] = extract_plane(1, 2);
+
+            return planes;
+        }
+
         template<class Type>
-        [[nodiscard]] constexpr static bool is_ndc_out_of_bounds(const Type& ndc) noexcept
+        [[nodiscard("You must use NDC bounds check result")]] constexpr static bool
+        is_ndc_out_of_bounds(const Type& ndc) noexcept
         {
             constexpr auto eps = std::numeric_limits<NumericType>::epsilon();
 
@@ -531,7 +628,7 @@ namespace omath::projection
             return is_ndc_z_value_out_of_bounds(data[2]);
         }
         template<class ZType>
-        [[nodiscard]]
+        [[nodiscard("You must use NDC z bounds check result")]]
         constexpr static bool is_ndc_z_value_out_of_bounds(const ZType& z_ndc) noexcept
         {
             constexpr auto eps = std::numeric_limits<NumericType>::epsilon();
@@ -557,7 +654,7 @@ namespace omath::projection
                                 v
             */
 
-        [[nodiscard]] Vector3<NumericType>
+        [[nodiscard("You must use screen position")]] constexpr Vector3<NumericType>
         ndc_to_screen_position_from_top_left_corner(const Vector3<NumericType>& ndc) const noexcept
         {
             /*
@@ -575,7 +672,7 @@ namespace omath::projection
                     (ndc.y / -NumericType{2} + NumericType{0.5}) * m_view_port.m_height, ndc.z};
         }
 
-        [[nodiscard]] Vector3<NumericType>
+        [[nodiscard("You must use screen position")]] constexpr Vector3<NumericType>
         ndc_to_screen_position_from_bottom_left_corner(const Vector3<NumericType>& ndc) const noexcept
         {
             /*
@@ -594,7 +691,8 @@ namespace omath::projection
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard]] Vector3<NumericType> screen_to_ndc(const Vector3<NumericType>& screen_pos) const noexcept
+        [[nodiscard("You must use NDC position")]] constexpr Vector3<NumericType>
+        screen_to_ndc(const Vector3<NumericType>& screen_pos) const noexcept
         {
             if constexpr (screen_start == ScreenStart::TOP_LEFT_CORNER)
                 return {screen_pos.x / m_view_port.m_width * NumericType{2} - NumericType{1},

include/omath/trigonometry/angle.hpp

@@ -3,6 +3,7 @@
 //
 
 #pragma once
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/trigonometry/angles.hpp"
 #include <algorithm>
 #include <format>
@@ -70,31 +71,31 @@ namespace omath
         }
 
         [[nodiscard]]
-        Type sin() const noexcept
+        constexpr Type sin() const noexcept
         {
-            return std::sin(as_radians());
+            return internal::sin(as_radians());
         }
 
         [[nodiscard]]
-        Type cos() const noexcept
+        constexpr Type cos() const noexcept
         {
-            return std::cos(as_radians());
+            return internal::cos(as_radians());
         }
 
         [[nodiscard]]
-        Type tan() const noexcept
+        constexpr Type tan() const noexcept
         {
-            return std::tan(as_radians());
+            return internal::tan(as_radians());
         }
 
         [[nodiscard]]
-        Type atan() const noexcept
+        constexpr Type atan() const noexcept
         {
-            return std::atan(as_radians());
+            return internal::atan(as_radians());
         }
 
         [[nodiscard]]
-        Type cot() const noexcept
+        constexpr Type cot() const noexcept
         {
             return cos() / sin();
         }

include/omath/trigonometry/angles.hpp

@@ -3,6 +3,7 @@
 //
 
 #pragma once
+#include "omath/internal/constexpr_math.hpp"
 #include <cmath>
 #include <numbers>
 
@@ -24,37 +25,38 @@ namespace omath::angles
 
     template<class Type>
     requires std::is_floating_point_v<Type>
-    [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect) noexcept
+    [[nodiscard]] constexpr 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);
+        const auto vert_fov =
+                static_cast<Type>(2) * internal::atan(internal::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
+    [[nodiscard]] constexpr 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);
+                static_cast<Type>(2) * internal::atan(internal::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
+    [[nodiscard]] constexpr 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);
+        Type wrapped_angle = internal::fmod(angle - min, range);
 
         if (wrapped_angle < 0)
             wrapped_angle += range;

include/omath/trigonometry/view_angles.hpp

@@ -18,7 +18,7 @@ namespace omath
         RollType roll;
 
         [[nodiscard]]
-        Vector3<ArithmeticType> as_vector3() const
+        constexpr Vector3<ArithmeticType> as_vector3() const
         {
             return {pitch.as_degrees(), yaw.as_degrees(), roll.as_degrees()};
         }

include/omath/utility/color.hpp

@@ -34,13 +34,13 @@ namespace omath
             m_value.clamp(0.f, 1.f);
         }
         constexpr explicit Color() noexcept = default;
-        [[nodiscard]]
+        [[nodiscard("color result should not be discarded")]]
         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<float>(r, g, b, a) / 255.f);
         }
 
-        [[nodiscard]]
+        [[nodiscard("color result should not be discarded")]]
         constexpr static Color from_hsv(float hue, const float saturation, const float value) noexcept
         {
             float r{}, g{}, b{};
@@ -80,13 +80,13 @@ namespace omath
             return {r, g, b, 1.f};
         }
 
-        [[nodiscard]]
+        [[nodiscard("color result should not be discarded")]]
         constexpr static Color from_hsv(const Hsv& hsv) noexcept
         {
             return from_hsv(hsv.hue, hsv.saturation, hsv.value);
         }
 
-        [[nodiscard]]
+        [[nodiscard("hsv result should not be discarded")]]
         constexpr Hsv to_hsv() const noexcept
         {
             Hsv hsv_data;
@@ -141,33 +141,33 @@ namespace omath
 
             *this = from_hsv(hsv);
         }
-        [[nodiscard]]
+        [[nodiscard("blended color result should not be discarded")]]
         constexpr Color blend(const Color& other, float ratio) const noexcept
         {
             ratio = std::clamp(ratio, 0.f, 1.f);
             return Color(this->m_value * (1.f - ratio) + other.m_value * ratio);
         }
 
-        [[nodiscard]] static constexpr Color red()
+        [[nodiscard("color result should not be discarded")]] static constexpr Color red()
         {
             return {1.f, 0.f, 0.f, 1.f};
         }
-        [[nodiscard]] static constexpr Color green()
+        [[nodiscard("color result should not be discarded")]] static constexpr Color green()
         {
             return {0.f, 1.f, 0.f, 1.f};
         }
-        [[nodiscard]] static constexpr Color blue()
+        [[nodiscard("color result should not be discarded")]] static constexpr Color blue()
         {
             return {0.f, 0.f, 1.f, 1.f};
         }
 #ifdef OMATH_IMGUI_INTEGRATION
-        [[nodiscard]]
+        [[nodiscard("ImColor result should not be discarded")]]
         ImColor to_im_color() const noexcept
         {
             return {m_value.to_im_vec4()};
         }
 #endif
-        [[nodiscard]] std::string to_string() const noexcept
+        [[nodiscard("string result should not be discarded")]] std::string to_string() const noexcept
         {
             return std::format("[r:{}, g:{}, b:{}, a:{}]",
                             static_cast<int>(m_value.x * 255.f),
@@ -175,24 +175,24 @@ namespace omath
                             static_cast<int>(m_value.z * 255.f),
                             static_cast<int>(m_value.w * 255.f));
         }
-        [[nodiscard]] std::string to_rgbf_string() const noexcept
+        [[nodiscard("string result should not be discarded")]] std::string to_rgbf_string() const noexcept
         {
             return std::format("[r:{}, g:{}, b:{}, a:{}]",
                             m_value.x, m_value.y, m_value.z, m_value.w);
         }
-        [[nodiscard]] std::string to_hsv_string() const noexcept
+        [[nodiscard("string result should not be discarded")]] std::string to_hsv_string() const noexcept
         {
             const auto [hue, saturation, value] = to_hsv();
             return std::format("[h:{}, s:{}, v:{}]", hue, saturation, value);
         }
-        [[nodiscard]] std::wstring to_wstring() const noexcept
+        [[nodiscard("wide string result should not be discarded")]] std::wstring to_wstring() const noexcept
         {
             const auto ascii_string = to_string();
             return {ascii_string.cbegin(), ascii_string.cend()};
         }
 
         // ReSharper disable once CppInconsistentNaming
-        [[nodiscard]] std::u8string to_u8string() const noexcept
+        [[nodiscard("UTF-8 string result should not be discarded")]] std::u8string to_u8string() const noexcept
         {
             const auto ascii_string = to_string();
             return {ascii_string.cbegin(), ascii_string.cend()};

include/omath/utility/elf_pattern_scan.hpp

@@ -2,12 +2,13 @@
 // Created by Vladislav on 30.12.2025.
 //
 #pragma once
+#include "pattern_scan.hpp"
+#include "section_scan_result.hpp"
 #include <cstdint>
 #include <filesystem>
 #include <optional>
 #include <span>
 #include <string_view>
-#include "section_scan_result.hpp"
 namespace omath
 {
     class ElfPatternScanner final
@@ -18,14 +19,74 @@ namespace omath
         scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& pattern,
                                           const std::string_view& target_section_name = ".text");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address,
+                                          const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_loaded_module(module_base_address, target_section_name,
+                                                     &ElfPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[nodiscard]]
         static std::optional<SectionScanResult>
         scan_for_pattern_in_file(const std::filesystem::path& path_to_file, const std::string_view& pattern,
                                  const std::string_view& target_section_name = ".text");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                 const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_file(path_to_file, target_section_name,
+                                            &ElfPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[nodiscard]]
         static std::optional<SectionScanResult>
         scan_for_pattern_in_memory_file(std::span<const std::byte> file_data, const std::string_view& pattern,
                                         const std::string_view& target_section_name = ".text");
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_memory_file(file_data, target_section_name,
+                                                   &ElfPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
+    private:
+        using SectionScanFunction = std::optional<std::ptrdiff_t> (*)(std::span<const std::byte>);
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::ptrdiff_t> scan_section_for_pattern(const std::span<const std::byte> section_data)
+        {
+            const auto result = PatternScanner::scan_for_pattern<Pattern>(section_data.begin(), section_data.end());
+
+            if (result == section_data.end())
+                return std::nullopt;
+
+            return result - section_data.begin();
+        }
+
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& target_section_name,
+                                          SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult> scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                                                         const std::string_view& target_section_name,
+                                                                         SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name, SectionScanFunction scan_pattern);
     };
 } // namespace omath

include/omath/utility/macho_pattern_scan.hpp

@@ -2,12 +2,13 @@
 // Created by Copilot on 04.02.2026.
 //
 #pragma once
+#include "pattern_scan.hpp"
+#include "section_scan_result.hpp"
 #include <cstdint>
 #include <filesystem>
 #include <optional>
 #include <span>
 #include <string_view>
-#include "section_scan_result.hpp"
 namespace omath
 {
     class MachOPatternScanner final
@@ -18,14 +19,74 @@ namespace omath
         scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& pattern,
                                           const std::string_view& target_section_name = "__text");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address,
+                                          const std::string_view& target_section_name = "__text")
+        {
+            return scan_for_pattern_in_loaded_module(module_base_address, target_section_name,
+                                                     &MachOPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[nodiscard]]
         static std::optional<SectionScanResult>
         scan_for_pattern_in_file(const std::filesystem::path& path_to_file, const std::string_view& pattern,
                                  const std::string_view& target_section_name = "__text");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                 const std::string_view& target_section_name = "__text")
+        {
+            return scan_for_pattern_in_file(path_to_file, target_section_name,
+                                            &MachOPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[nodiscard]]
         static std::optional<SectionScanResult>
         scan_for_pattern_in_memory_file(std::span<const std::byte> file_data, const std::string_view& pattern,
                                         const std::string_view& target_section_name = "__text");
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name = "__text")
+        {
+            return scan_for_pattern_in_memory_file(file_data, target_section_name,
+                                                   &MachOPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
+    private:
+        using SectionScanFunction = std::optional<std::ptrdiff_t> (*)(std::span<const std::byte>);
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::ptrdiff_t> scan_section_for_pattern(const std::span<const std::byte> section_data)
+        {
+            const auto result = PatternScanner::scan_for_pattern<Pattern>(section_data.begin(), section_data.end());
+
+            if (result == section_data.end())
+                return std::nullopt;
+
+            return result - section_data.begin();
+        }
+
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& target_section_name,
+                                          SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult> scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                                                         const std::string_view& target_section_name,
+                                                                         SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name, SectionScanFunction scan_pattern);
     };
 } // namespace omath

include/omath/utility/pattern_scan.hpp

@@ -3,9 +3,12 @@
 //
 
 #pragma once
+#include <algorithm>
+#include <array>
 #include <expected>
 #include <optional>
 #include <span>
+#include <stdexcept>
 #include <string_view>
 #include <vector>
 
@@ -15,6 +18,8 @@ class unit_test_pattern_scan_corner_case_1_Test;
 class unit_test_pattern_scan_corner_case_2_Test;
 class unit_test_pattern_scan_corner_case_3_Test;
 class unit_test_pattern_scan_corner_case_4_Test;
+class unit_test_pattern_scan_consteval_read_test_Test;
+class unit_test_pattern_scan_consteval_spacing_and_case_Test;
 // ReSharper restore CppInconsistentNaming
 namespace omath
 {
@@ -29,8 +34,22 @@ namespace omath
         friend unit_test_pattern_scan_corner_case_2_Test;
         friend unit_test_pattern_scan_corner_case_3_Test;
         friend unit_test_pattern_scan_corner_case_4_Test;
+        friend unit_test_pattern_scan_consteval_read_test_Test;
+        friend unit_test_pattern_scan_consteval_spacing_and_case_Test;
 
     public:
+        template<std::size_t N>
+        struct ConstevalPattern final
+        {
+            char value[N]{};
+
+            // ReSharper disable once CppNonExplicitConvertingConstructor
+            constexpr ConstevalPattern(const char (&text)[N]) // NOLINT(*-explicit-constructor)
+            {
+                std::ranges::copy(text, value);
+            }
+        };
+
         [[nodiscard]]
         static std::span<std::byte>::iterator scan_for_pattern(const std::span<std::byte>& range,
                                                                const std::string_view& pattern);
@@ -49,9 +68,26 @@ namespace omath
             if (!parsed_pattern) [[unlikely]]
                 return end;
 
+            return scan_for_parsed_pattern(begin, end, parsed_pattern.value());
+        }
+        template<ConstevalPattern Pattern, class IteratorType>
+        requires std::input_or_output_iterator<std::remove_cvref_t<IteratorType>>
+        static IteratorType scan_for_pattern(const IteratorType& begin, const IteratorType& end)
+        {
+            constexpr auto parsed_pattern = parse_pattern<Pattern>();
+
+            return scan_for_parsed_pattern(begin, end, parsed_pattern);
+        }
+
+    private:
+        template<class IteratorType, class ParsedPattern>
+        requires std::input_or_output_iterator<std::remove_cvref_t<IteratorType>>
+        static IteratorType scan_for_parsed_pattern(const IteratorType& begin, const IteratorType& end,
+                                                    const ParsedPattern& parsed_pattern)
+        {
             const auto whole_range_size = static_cast<std::ptrdiff_t>(std::distance(begin, end));
 
-            const auto pattern_size = static_cast<std::ptrdiff_t>(parsed_pattern->size());
+            const auto pattern_size = static_cast<std::ptrdiff_t>(parsed_pattern.size());
             const std::ptrdiff_t scan_size = whole_range_size - pattern_size;
 
             if (scan_size < 0)
@@ -61,9 +97,9 @@ namespace omath
             {
                 bool found = true;
 
-                for (std::ptrdiff_t j = 0; j < static_cast<std::ptrdiff_t>(parsed_pattern->size()); j++)
+                for (std::ptrdiff_t j = 0; j < static_cast<std::ptrdiff_t>(parsed_pattern.size()); j++)
                 {
-                    found = parsed_pattern->at(j) == std::nullopt || parsed_pattern->at(j) == *(begin + i + j);
+                    found = parsed_pattern.at(j) == std::nullopt || parsed_pattern.at(j) == *(begin + i + j);
 
                     if (!found)
                         break;
@@ -73,10 +109,97 @@ namespace omath
             }
             return end;
         }
-
-    private:
         [[nodiscard]]
         static std::expected<std::vector<std::optional<std::byte>>, PatternScanError>
         parse_pattern(const std::string_view& pattern_string);
+
+        [[nodiscard]]
+        constexpr static bool is_space(const char c)
+        {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+        }
+
+        [[nodiscard]]
+        constexpr static int hex_value(const char c)
+        {
+            if (c >= '0' && c <= '9')
+                return c - '0';
+            if (c >= 'A' && c <= 'F')
+                return c - 'A' + 10;
+            if (c >= 'a' && c <= 'f')
+                return c - 'a' + 10;
+            return -1;
+        }
+        template<ConstevalPattern Pattern>
+        [[nodiscard]]
+        static consteval std::size_t signature_size()
+        {
+            std::size_t count = 0;
+            bool in_token = false;
+
+            for (std::size_t i = 0; i + 1 < sizeof(Pattern.value); ++i)
+            {
+                if (is_space(Pattern.value[i]))
+                {
+                    in_token = false;
+                }
+                else if (!in_token)
+                {
+                    ++count;
+                    in_token = true;
+                }
+            }
+
+            return count;
+        }
+
+        template<ConstevalPattern Pattern>
+        static consteval std::array<std::optional<std::byte>, signature_size<Pattern>()> parse_pattern()
+        {
+            std::array<std::optional<std::byte>, signature_size<Pattern>()> result{};
+            std::size_t out = 0;
+            std::size_t i = 0;
+
+            while (i + 1 < sizeof(Pattern.value))
+            {
+                while (i + 1 < sizeof(Pattern.value) && is_space(Pattern.value[i]))
+                    ++i;
+
+                const std::size_t token_start = i;
+
+                while (i + 1 < sizeof(Pattern.value) && !is_space(Pattern.value[i]))
+                    ++i;
+
+                const std::size_t token_size = i - token_start;
+
+                if (token_size == 0)
+                    continue;
+
+                // ReSharper disable once CppTooWideScope
+                const bool is_wildcard = (token_size == 1 || token_size == 2) && Pattern.value[token_start] == '?';
+
+                if (is_wildcard)
+                {
+                    if (token_size == 2 && Pattern.value[token_start + 1] != '?')
+                        throw std::logic_error("invalid wildcard token");
+
+                    result[out++] = std::nullopt;
+                    continue;
+                }
+
+                if (token_size != 2)
+                    throw std::logic_error("invalid byte token");
+
+                const int high = hex_value(Pattern.value[token_start]);
+                const int low = hex_value(Pattern.value[token_start + 1]);
+
+                if (high < 0 || low < 0)
+                    throw std::logic_error("invalid hex byte");
+
+                result[out++] = static_cast<std::byte>((high << 4) | low);
+            }
+
+            return result;
+        }
     };
 } // namespace omath

include/omath/utility/pe_pattern_scan.hpp

@@ -3,12 +3,13 @@
 //
 
 #pragma once
+#include "pattern_scan.hpp"
+#include "section_scan_result.hpp"
 #include <cstdint>
 #include <filesystem>
 #include <optional>
 #include <span>
 #include <string_view>
-#include "section_scan_result.hpp"
 namespace omath
 {
 
@@ -20,14 +21,74 @@ namespace omath
         scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& pattern,
                                           const std::string_view& target_section_name = ".text");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address,
+                                          const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_loaded_module(module_base_address, target_section_name,
+                                                     &PePatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[nodiscard]]
         static std::optional<SectionScanResult>
         scan_for_pattern_in_file(const std::filesystem::path& path_to_file, const std::string_view& pattern,
                                  const std::string_view& target_section_name = ".text");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                 const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_file(path_to_file, target_section_name,
+                                            &PePatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[nodiscard]]
         static std::optional<SectionScanResult>
         scan_for_pattern_in_memory_file(std::span<const std::byte> file_data, const std::string_view& pattern,
                                         const std::string_view& target_section_name = ".text");
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_memory_file(file_data, target_section_name,
+                                                   &PePatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
+    private:
+        using SectionScanFunction = std::optional<std::ptrdiff_t> (*)(std::span<const std::byte>);
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::ptrdiff_t> scan_section_for_pattern(const std::span<const std::byte> section_data)
+        {
+            const auto result = PatternScanner::scan_for_pattern<Pattern>(section_data.begin(), section_data.end());
+
+            if (result == section_data.end())
+                return std::nullopt;
+
+            return result - section_data.begin();
+        }
+
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& target_section_name,
+                                          SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult> scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                                                         const std::string_view& target_section_name,
+                                                                         SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name, SectionScanFunction scan_pattern);
     };
 } // namespace omath

modules/omath.cppm

@@ -0,0 +1,59 @@
+module;
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <expected>
+#include <filesystem>
+#include <format>
+#include <functional>
+#include <initializer_list>
+#include <iomanip>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <memory_resource>
+#include <numbers>
+#include <numeric>
+#include <optional>
+#include <queue>
+#include <ranges>
+#include <span>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#if defined(OMATH_USE_AVX2)
+#include <immintrin.h>
+#endif
+
+#if defined(OMATH_IMGUI_INTEGRATION)
+#include <imgui.h>
+#endif
+
+#if defined(_WIN32)
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <mach-o/dyld.h>
+#elif defined(__linux__) || defined(__unix__)
+#include <link.h>
+#endif
+
+export module omath;
+
+export {
+#include "omath/omath.hpp"
+}

source/engines/cry_engine/formulas.cpp

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

source/engines/cry_engine/traits/camera_trait.cpp

@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/cry_engine/traits/camera_trait.hpp"
-
-namespace omath::cry_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(std::asin(direction.z)),
-                YawAngle::from_radians(-std::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return cry_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, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::unity_engine

source/engines/frostbite_engine/formulas.cpp

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

source/engines/frostbite_engine/traits/camera_trait.cpp

@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/frostbite_engine/traits/camera_trait.hpp"
-
-namespace omath::frostbite_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(-std::asin(direction.y)),
-                YawAngle::from_radians(std::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return frostbite_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::unity_engine

source/engines/iw_engine/formulas.cpp

@@ -1,61 +0,0 @@
-//
-// 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, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        // InfinityWard Engine (inherited from Quake) stores FOV as horizontal FOV at a 4:3
-        // reference aspect. Convert to true vertical FOV, then delegate to the
-        // standard vertical-FOV left-handed builder with the caller's actual
-        // aspect ratio.
-        //   vfov = 2 · atan( tan(hfov_4:3 / 2) / (4/3) )
-        constexpr float k_source_reference_aspect = 4.f / 3.f;
-        const float half_hfov_4_3 = angles::degrees_to_radians(field_of_view) / 2.f;
-        const float vfov_deg = angles::radians_to_degrees(
-                2.f * std::atan(std::tan(half_hfov_4_3) / k_source_reference_aspect));
-
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return mat_perspective_left_handed<
-                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    vfov_deg, aspect_ratio, near, far);
-        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return mat_perspective_left_handed<
-                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-                    vfov_deg, aspect_ratio, near, far);
-        std::unreachable();
-    };
-} // namespace omath::iw_engine

source/engines/iw_engine/traits/camera_trait.cpp

@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/iw_engine/traits/camera_trait.hpp"
-#include "omath/engines/iw_engine/formulas.hpp"
-namespace omath::iw_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(-std::asin(direction.z)),
-                YawAngle::from_radians(std::atan2(direction.y, direction.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, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::iw_engine

source/engines/opengl_engine/formulas.cpp

@@ -1,52 +0,0 @@
-//
-// 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_look_at_right_handed(cam_origin, cam_origin + forward_vector(angles), up_vector(angles));
-    }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll)
-               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(angles.yaw)
-               * mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(angles.pitch);
-    }
-    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return mat_perspective_right_handed<float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-                    field_of_view, aspect_ratio, near, far);
-
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return mat_perspective_right_handed<float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                        field_of_view, aspect_ratio, near, far);
-
-        std::unreachable();
-    }
-} // namespace omath::opengl_engine

source/engines/opengl_engine/traits/camera_trait.cpp

@@ -1,28 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/opengl_engine/traits/camera_trait.hpp"
-#include "omath/engines/opengl_engine/formulas.hpp"
-
-namespace omath::opengl_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(std::asin(direction.y)),
-                YawAngle::from_radians(-std::atan2(direction.x, -direction.z)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return 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, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::opengl_engine

source/engines/source_engine/formulas.cpp

@@ -1,61 +0,0 @@
-//
-// 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, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        // Source (inherited from Quake) stores FOV as horizontal FOV at a 4:3
-        // reference aspect. Convert to true vertical FOV, then delegate to the
-        // standard vertical-FOV left-handed builder with the caller's actual
-        // aspect ratio.
-        //   vfov = 2 · atan( tan(hfov_4:3 / 2) / (4/3) )
-        constexpr float k_source_reference_aspect = 4.f / 3.f;
-        const float half_hfov_4_3 = angles::degrees_to_radians(field_of_view) / 2.f;
-        const float vfov_deg = angles::radians_to_degrees(
-                2.f * std::atan(std::tan(half_hfov_4_3) / k_source_reference_aspect));
-
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return mat_perspective_left_handed<
-                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    vfov_deg, aspect_ratio, near, far);
-        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return mat_perspective_left_handed<
-                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-                    vfov_deg, aspect_ratio, near, far);
-        std::unreachable();
-    }
-} // namespace omath::source_engine

source/engines/source_engine/traits/camera_trait.cpp

@@ -1,28 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/source_engine/traits/camera_trait.hpp"
-#include "omath/engines/source_engine/formulas.hpp"
-namespace omath::source_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-
-        return {PitchAngle::from_radians(-std::asin(direction.z)),
-                YawAngle::from_radians(std::atan2(direction.y, direction.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, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::source_engine

source/engines/unity_engine/formulas.cpp

@@ -1,49 +0,0 @@
-//
-// 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_z<float, MatStoreType::ROW_MAJOR>(angles.roll)
-               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
-               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
-    }
-    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return omath::mat_perspective_right_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    field_of_view, aspect_ratio, near, far);
-        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return omath::mat_perspective_right_handed<float, MatStoreType::ROW_MAJOR,
-                                                       NDCDepthRange::NEGATIVE_ONE_TO_ONE>(field_of_view, aspect_ratio,
-                                                                                           near, far);
-        std::unreachable();
-    }
-} // namespace omath::unity_engine

source/engines/unity_engine/traits/camera_trait.cpp

@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/unity_engine/traits/camera_trait.hpp"
-
-namespace omath::unity_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(-std::asin(direction.y)),
-                YawAngle::from_radians(std::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return unity_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, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::unity_engine

source/engines/unreal_engine/formulas.cpp

@@ -1,57 +0,0 @@
-//
-// Created by Vlad on 3/22/2025.
-//
-#include "omath/engines/unreal_engine/formulas.hpp"
-namespace omath::unreal_engine
-{
-    Vector3<double> 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<double> 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<double> 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<double>& cam_origin) noexcept
-    {
-        return mat_camera_view<double, MatStoreType::ROW_MAJOR>(forward_vector(angles), right_vector(angles),
-                                                               up_vector(angles), cam_origin);
-    }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        // UE FRotator is intrinsic Z-Y-X (Yaw → Pitch → Roll applied in local
-        // frame), which for column-vector composition is Rz·Ry·Rx.
-        // Pitch and roll axes in omath spin opposite to UE's convention, so
-        // both carry a sign flip.
-        return mat_rotation_axis_z<double, MatStoreType::ROW_MAJOR>(angles.yaw)
-               * mat_rotation_axis_y<double, MatStoreType::ROW_MAJOR>(-angles.pitch)
-               * mat_rotation_axis_x<double, MatStoreType::ROW_MAJOR>(-angles.roll);
-    }
-
-
-    Mat4X4 calc_perspective_projection_matrix(const double field_of_view, const double aspect_ratio, const double near,
-                                              const double far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        // UE stores horizontal FOV in FMinimalViewInfo — use the left-handed
-        // horizontal-FOV builder directly.
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return mat_perspective_left_handed_horizontal_fov<
-                    double, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    field_of_view, aspect_ratio, near, far);
-        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return mat_perspective_left_handed_horizontal_fov<
-                    double, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-                    field_of_view, aspect_ratio, near, far);
-        std::unreachable();
-    }
-} // namespace omath::unreal_engine

source/engines/unreal_engine/traits/camera_trait.cpp

@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/unreal_engine/traits/camera_trait.hpp"
-
-namespace omath::unreal_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<double>& cam_origin, const Vector3<double>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(std::asin(direction.z)),
-                YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept
-    {
-        return unreal_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const double near,
-                                               const double far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::unreal_engine