Update cmake-multi-platform.yml

switched to clang

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

fix

.clang-format

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

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

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

.idea/modules.xml

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

.idea/uml.iml

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

.idea/vcs.xml

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

CMakeLists.txt

@@ -11,15 +11,19 @@ option(OMATH_BUILD_AS_SHARED_LIBRARY "Build Omath as .so or .dll" OFF)
 option(OMATH_USE_AVX2 "Omath will use AVX2 to boost performance" ON)
 option(OMATH_IMGUI_INTEGRATION "Omath will define method to convert omath types to imgui types" OFF)
 option(OMATH_BUILD_EXAMPLES "Build example projects with you can learn & play" OFF)
-option(OMATH_STATIC_MSVC_RUNTIME_LIBRARY  "Force Omath to link static runtime" OFF)
+option(OMATH_STATIC_MSVC_RUNTIME_LIBRARY "Force Omath to link static runtime" OFF)
 option(OMATH_SUPRESS_SAFETY_CHECKS "Supress some safety checks in release build to improve general performance" ON)
 option(OMATH_USE_UNITY_BUILD "Will enable unity build to speed up compilation" ON)
 
+file(GLOB_RECURSE OMATH_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp")
+file(GLOB_RECURSE OMATH_HEADERS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp")
+
+
 if (OMATH_BUILD_AS_SHARED_LIBRARY)
-    add_library(omath SHARED source/matrix.cpp)
-else()
-    add_library(omath STATIC source/matrix.cpp)
-endif()
+    add_library(omath SHARED ${OMATH_SOURCES} ${OMATH_HEADERS})
+else ()
+    add_library(omath STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
+endif ()
 
 message(STATUS "Building on ${CMAKE_HOST_SYSTEM_NAME}")
 add_library(omath::omath ALIAS omath)
@@ -28,28 +32,28 @@ if (OMATH_IMGUI_INTEGRATION)
     target_compile_definitions(omath PUBLIC OMATH_IMGUI_INTEGRATION)
 
     # IMGUI is being linked as submodule
-    if(TARGET imgui)
+    if (TARGET imgui)
         target_link_libraries(omath PUBLIC imgui)
         install(TARGETS imgui
                 EXPORT omathTargets
                 ARCHIVE DESTINATION lib
                 LIBRARY DESTINATION lib
                 RUNTIME DESTINATION bin)
-    else()
+    else ()
         # Assume that IMGUI linked via VCPKG.
         find_package(imgui CONFIG REQUIRED)
         target_link_libraries(omath PUBLIC imgui::imgui)
-    endif()
+    endif ()
 
-endif()
+endif ()
 
 if (OMATH_USE_AVX2)
     target_compile_definitions(omath PUBLIC OMATH_USE_AVX2)
-endif()
+endif ()
 
 if (OMATH_SUPRESS_SAFETY_CHECKS)
     target_compile_definitions(omath PUBLIC OMATH_SUPRESS_SAFETY_CHECKS)
-endif()
+endif ()
 
 set_target_properties(omath PROPERTIES
         ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
@@ -61,37 +65,35 @@ if (OMATH_USE_UNITY_BUILD)
     set_target_properties(omath PROPERTIES
             UNITY_BUILD ON
             UNITY_BUILD_BATCH_SIZE 20)
-endif()
+endif ()
 
 if (OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
     set_target_properties(omath PROPERTIES
             MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
     )
-endif()
+endif ()
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     target_compile_options(omath PRIVATE -mavx2 -mfma)
-endif()
+endif ()
 
 target_compile_features(omath PUBLIC cxx_std_23)
 
 
-add_subdirectory(source)
-
-if(OMATH_BUILD_TESTS)
+if (OMATH_BUILD_TESTS)
     add_subdirectory(extlibs)
     add_subdirectory(tests)
-endif()
+endif ()
 
 if (OMATH_BUILD_EXAMPLES)
     add_subdirectory(examples)
-endif()
+endif ()
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND OMATH_THREAT_WARNING_AS_ERROR)
     target_compile_options(omath PRIVATE /W4 /WX)
-elseif(OMATH_THREAT_WARNING_AS_ERROR)
+elseif (OMATH_THREAT_WARNING_AS_ERROR)
     target_compile_options(omath PRIVATE -Wall -Wextra -Wpedantic -Werror)
-endif()
+endif ()
 
 target_include_directories(omath
         PUBLIC

CMakePresets.json

@@ -40,8 +40,8 @@
       "binaryDir": "${sourceDir}/cmake-build/build/${presetName}",
       "installDir": "${sourceDir}/cmake-build/install/${presetName}",
       "cacheVariables": {
-        "CMAKE_C_COMPILER": "gcc",
-        "CMAKE_CXX_COMPILER": "g++"
+        "CMAKE_C_COMPILER": "clang",
+        "CMAKE_CXX_COMPILER": "clang++"
       },
       "condition": {
         "type": "equals",

CREDITS.md

@@ -0,0 +1,11 @@
+# OMATH CREDITS
+
+Thanks to everyone who made this possible, including:
+
+- Saikari aka luadebug for VCPKG port.
+
+And a big hand to everyone else who has contributed over the past!
+
+THANKS! <3
+
+    -- Orange++ <orange-cpp@yandex.ru>

INSTALL.md

@@ -0,0 +1,54 @@
+# 📥Installation Guide
+
+## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> Using vcpkg
+**Note**: Support vcpkg for package management
+1. Install [vcpkg](https://github.com/microsoft/vcpkg)
+2. Run the following command to install the orange-math package:
+```
+vcpkg install orange-math
+```
+CMakeLists.txt
+```cmake
+find_package(omath CONFIG REQUIRED)
+target_link_libraries(main PRIVATE omath::omath)
+```
+For detailed commands on installing different versions and more information, please refer to Microsoft's [official instructions](https://learn.microsoft.com/en-us/vcpkg/get_started/overview).
+
+## <img width="28px" src="https://upload.wikimedia.org/wikipedia/commons/e/ef/CMake_logo.svg?" /> Build from source using CMake 
+1. **Preparation**
+   
+   Install needed tools: cmake, clang, git, msvc (windows only).
+   
+   1. **Linux:**
+       ```bash
+       sudo pacman -Sy cmake ninja clang git
+       ```
+   2. **MacOS:**
+       ```bash
+       brew install llvm git cmake ninja
+       ```
+   3. **Windows:**
+
+      Install Visual Studio from [here](https://visualstudio.microsoft.com/downloads/) and Git from [here](https://git-scm.com/downloads).
+      
+      Use x64 Native Tools shell to execute needed commands down below.
+2. **Clone the repository:**
+   ```bash
+   git clone https://github.com/orange-cpp/omath.git
+   ```
+3. **Navigate to the project directory:**
+   ```bash
+   cd omath
+   ```
+4. **Build the project using CMake:**
+   ```bash
+   cmake --preset windows-release -S .
+   cmake --build cmake-build/build/windows-release --target omath -j 6
+   ```
+   Use **\<platform\>-\<build configuration\>** preset to build siutable version for yourself. Like **windows-release** or **linux-release**.
+
+    | Platform Name | Build Config  |
+    |---------------|---------------|
+    | windows       | release/debug |
+    | linux         | release/debug |
+    | darwin        | release/debug |

README.md

@@ -37,40 +37,9 @@ Oranges's Math Library (omath) is a comprehensive, open-source library aimed at
 | Linux          | ✅YES    |
 | Darwin (MacOS) | ✅YES    |
 
-## ⏬ Getting Started
-### Prerequisites
-- C++ Compiler
-- CMake (for building the project)
+## ⏬ Installation
+Please read our [installation guide](https://github.com/orange-cpp/omath/blob/main/INSTALL.md). If this link doesn't work check out INSTALL.md file.
 
-### Installation
-### vcpkg
-**Note**: Support vcpkg for package management
-1. Install vcpkg (https://github.com/microsoft/vcpkg)
-2. Run the following command to install the orange-math package:
-```
-vcpkg install orange-math
-```
-CMakeLists.txt
-```cmake
-find_package(omath CONFIG REQUIRED)
-target_link_libraries(main PRIVATE omath::omath)
-```
-For detailed commands on installing different versions and more information, please refer to Microsoft's official instructions (https://learn.microsoft.com/en-us/vcpkg/get_started/overview)
-### Build from source
-1. Clone the repository:
-   ```
-   git clone https://github.com/orange-cpp/omath.git
-   ```
-2. Navigate to the project directory:
-   ```
-   cd omath
-   ```
-3. Build the project using CMake:
-   ```
-   cmake --preset windows-release -S .
-   cmake --build cmake-build/build/windows-release --target omath -j 6
-   ```
-   Use **\<platform\>-\<build configuration\>** preset to build siutable version for yourself. Like **windows-release** or **linux-release**.
 ## ❔ Usage
 Simple world to screen function
 ```c++

include/omath/3d_primitives/box.hpp

@@ -11,7 +11,7 @@
 namespace omath::primitives
 {
     [[nodiscard]]
-    std::array<Triangle<Vector3<float>>, 12> CreateBox(const Vector3<float>& top, const Vector3<float>& bottom,
-                                             const Vector3<float>& dirForward, const Vector3<float>& dirRight,
+    std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
+                                             const Vector3<float>& dir_forward, const Vector3<float>& dir_right,
                                              float ratio = 4.f);
 }

include/omath/angle.hpp

@@ -3,10 +3,9 @@
 //
 
 #pragma once
+#include "omath/angles.hpp"
 #include <algorithm>
 #include <utility>
-#include "omath/angles.hpp"
-
 
 namespace omath
 {
@@ -17,14 +16,14 @@ namespace omath
     };
 
     template<class Type = float, Type min = Type(0), Type max = Type(360), AngleFlags flags = AngleFlags::Normalized>
-        requires std::is_arithmetic_v<Type>
+    requires std::is_arithmetic_v<Type>
     class Angle
     {
         Type m_angle;
         constexpr explicit Angle(const Type& degrees)
         {
             if constexpr (flags == AngleFlags::Normalized)
-                m_angle = angles::WrapAngle(degrees, min, max);
+                m_angle = angles::wrap_angle(degrees, min, max);
 
             else if constexpr (flags == AngleFlags::Clamped)
                 m_angle = std::clamp(degrees, min, max);
@@ -37,17 +36,17 @@ namespace omath
 
     public:
         [[nodiscard]]
-        constexpr static Angle FromDegrees(const Type& degrees)
+        constexpr static Angle from_degrees(const Type& degrees)
         {
             return Angle{degrees};
         }
-        constexpr Angle() : m_angle(0)
+        constexpr Angle(): m_angle(0)
         {
         }
         [[nodiscard]]
-        constexpr static Angle FromRadians(const Type& degrees)
+        constexpr static Angle from_radians(const Type& degrees)
         {
-            return Angle{angles::RadiansToDegrees<Type>(degrees)};
+            return Angle{angles::radians_to_degrees<Type>(degrees)};
         }
 
         [[nodiscard]]
@@ -57,51 +56,51 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Type AsDegrees() const
+        constexpr Type as_degrees() const
         {
             return m_angle;
         }
 
         [[nodiscard]]
-        constexpr Type AsRadians() const
+        constexpr Type as_radians() const
         {
-            return angles::DegreesToRadians(m_angle);
+            return angles::degrees_to_radians(m_angle);
         }
 
         [[nodiscard]]
-        Type Sin() const
+        Type sin() const
         {
-            return std::sin(AsRadians());
+            return std::sin(as_radians());
         }
 
         [[nodiscard]]
-        Type Cos() const
+        Type cos() const
         {
-            return std::cos(AsRadians());
+            return std::cos(as_radians());
         }
 
         [[nodiscard]]
-        Type Tan() const
+        Type tan() const
         {
-            return std::tan(AsRadians());
+            return std::tan(as_radians());
         }
 
         [[nodiscard]]
-        Type Atan() const
+        Type atan() const
         {
-            return std::atan(AsRadians());
+            return std::atan(as_radians());
         }
 
         [[nodiscard]]
-        Type Cot() const
+        Type cot() const
         {
-            return Cos() / Sin();
+            return cos() / sin();
         }
 
         constexpr Angle& operator+=(const Angle& other)
         {
             if constexpr (flags == AngleFlags::Normalized)
-                m_angle = angles::WrapAngle(m_angle + other.m_angle, min, max);
+                m_angle = angles::wrap_angle(m_angle + other.m_angle, min, max);
 
             else if constexpr (flags == AngleFlags::Clamped)
                 m_angle = std::clamp(m_angle + other.m_angle, min, max);
@@ -115,7 +114,8 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr std::partial_ordering operator<=>(const Angle& other) const = default;
+        constexpr std::partial_ordering operator<=>(const Angle& other) const
+                = default;
 
         constexpr Angle& operator-=(const Angle& other)
         {
@@ -126,7 +126,7 @@ namespace omath
         constexpr Angle& operator+(const Angle& other)
         {
             if constexpr (flags == AngleFlags::Normalized)
-                return {angles::WrapAngle(m_angle + other.m_angle, min, max)};
+                return {angles::wrap_angle(m_angle + other.m_angle, min, max)};
 
             else if constexpr (flags == AngleFlags::Clamped)
                 return {std::clamp(m_angle + other.m_angle, min, max)};

include/omath/angles.hpp

@@ -10,54 +10,55 @@ namespace omath::angles
 {
     template<class Type>
     requires std::is_floating_point_v<Type>
-    [[nodiscard]] constexpr Type RadiansToDegrees(const Type& radians)
+    [[nodiscard]] constexpr Type radians_to_degrees(const Type& radians)
     {
-        return radians * (Type(180) / std::numbers::pi_v<Type>);
+        return radians * (static_cast<Type>(180) / std::numbers::pi_v<Type>);
     }
 
     template<class Type>
     requires std::is_floating_point_v<Type>
-    [[nodiscard]] constexpr Type DegreesToRadians(const Type& degrees)
+    [[nodiscard]] constexpr Type degrees_to_radians(const Type& degrees)
     {
-        return degrees * (std::numbers::pi_v<Type> / Type(180));
-    }
-
-    template<class type>
-    requires std::is_floating_point_v<type>
-    [[nodiscard]] type HorizontalFovToVertical(const type& horFov, const type& aspect)
-    {
-        const auto fovRad = DegreesToRadians(horFov);
-
-        const auto vertFov = type(2) * std::atan(std::tan(fovRad / type(2)) / aspect);
-
-        return RadiansToDegrees(vertFov);
+        return degrees * (std::numbers::pi_v<Type> / static_cast<Type>(180));
     }
 
     template<class Type>
     requires std::is_floating_point_v<Type>
-    [[nodiscard]] Type VerticalFovToHorizontal(const Type& vertFov, const Type& aspect)
+    [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect)
     {
-        const auto fovRad = DegreesToRadians(vertFov);
+        const auto fov_rad = degrees_to_radians(horizontal_fov);
 
-        const auto horFov = Type(2) * std::atan(std::tan(fovRad / Type(2)) * aspect);
+        const auto vert_fov = static_cast<Type>(2) * std::atan(std::tan(fov_rad / static_cast<Type>(2)) / aspect);
 
-        return RadiansToDegrees(horFov);
+        return radians_to_degrees(vert_fov);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect)
+    {
+        const auto fov_as_radians = degrees_to_radians(vertical_fov);
+
+        const auto horizontal_fov
+                = static_cast<Type>(2) * std::atan(std::tan(fov_as_radians / static_cast<Type>(2)) * aspect);
+
+        return radians_to_degrees(horizontal_fov);
     }
 
     template<class Type>
     requires std::is_arithmetic_v<Type>
-    [[nodiscard]] Type WrapAngle(const Type& angle, const Type& min, const Type& max)
+    [[nodiscard]] Type wrap_angle(const Type& angle, const Type& min, const Type& max)
     {
         if (angle <= max && angle >= min)
             return angle;
 
         const Type range = max - min;
 
-        Type wrappedAngle = std::fmod(angle - min, range);
+        Type wrapped_angle = std::fmod(angle - min, range);
 
-        if (wrappedAngle < 0)
-            wrappedAngle += range;
+        if (wrapped_angle < 0)
+            wrapped_angle += range;
 
-        return wrappedAngle + min;
+        return wrapped_angle + min;
     }
-}
+} // namespace omath::angles

include/omath/collision/line_tracer.hpp

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

include/omath/color.hpp

@@ -4,95 +4,93 @@
 
 #pragma once
 
-#include <cstdint>
 #include "omath/vector3.hpp"
 #include "omath/vector4.hpp"
+#include <cstdint>
 
 #ifdef max
 #undef max
 #endif
 
-
 #ifdef min
 #undef min
 #endif
 
 namespace omath
 {
-    struct HSV
+    struct Hsv
     {
         float hue{};
         float saturation{};
         float value{};
     };
 
-
     class Color final : public Vector4<float>
     {
     public:
-        constexpr Color(const float r, const float g, const float b, const float a) : Vector4(r, g, b, a)
+        constexpr Color(const float r, const float g, const float b, const float a): Vector4(r, g, b, a)
         {
-            Clamp(0.f, 1.f);
+            clamp(0.f, 1.f);
         }
 
         constexpr explicit Color() = default;
         [[nodiscard]]
-        constexpr static Color FromRGBA(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a)
+        constexpr static Color from_rgba(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a)
         {
             return Color{Vector4(r, g, b, a) / 255.f};
         }
 
         [[nodiscard]]
-        constexpr static Color FromHSV(float hue, const float saturation, const float value)
+        constexpr static Color from_hsv(float hue, const float saturation, const float value)
         {
             float r{}, g{}, b{};
 
             hue = std::clamp(hue, 0.f, 1.f);
 
             const int i = static_cast<int>(hue * 6.f);
-            const float f = hue * 6 - i;
+            const float f = hue * 6.f - static_cast<float>(i);
             const float p = value * (1 - saturation);
             const float q = value * (1 - f * saturation);
             const float t = value * (1 - (1 - f) * saturation);
 
             switch (i % 6)
             {
-                case 0:
-                    r = value, g = t, b = p;
-                    break;
-                case 1:
-                    r = q, g = value, b = p;
-                    break;
-                case 2:
-                    r = p, g = value, b = t;
-                    break;
-                case 3:
-                    r = p, g = q, b = value;
-                    break;
-                case 4:
-                    r = t, g = p, b = value;
-                    break;
-                case 5:
-                    r = value, g = p, b = q;
-                    break;
+            case 0:
+                r = value, g = t, b = p;
+                break;
+            case 1:
+                r = q, g = value, b = p;
+                break;
+            case 2:
+                r = p, g = value, b = t;
+                break;
+            case 3:
+                r = p, g = q, b = value;
+                break;
+            case 4:
+                r = t, g = p, b = value;
+                break;
+            case 5:
+                r = value, g = p, b = q;
+                break;
 
-                default:
-                    return {0.f, 0.f, 0.f, 0.f};
+            default:
+                return {0.f, 0.f, 0.f, 0.f};
             }
 
             return {r, g, b, 1.f};
         }
 
         [[nodiscard]]
-        constexpr static Color FromHSV(const HSV& hsv)
+        constexpr static Color from_hsv(const Hsv& hsv)
         {
-            return FromHSV(hsv.hue, hsv.saturation, hsv.value);
+            return from_hsv(hsv.hue, hsv.saturation, hsv.value);
         }
 
         [[nodiscard]]
-        constexpr HSV ToHSV() const
+        constexpr Hsv to_hsv() const
         {
-            HSV hsvData;
+            Hsv hsv_data;
 
             const float& red = x;
             const float& green = y;
@@ -102,70 +100,69 @@ namespace omath
             const float min = std::min({red, green, blue});
             const float delta = max - min;
 
-
             if (delta == 0.f)
-                hsvData.hue = 0.f;
+                hsv_data.hue = 0.f;
 
             else if (max == red)
-                hsvData.hue = 60.f * (std::fmodf(((green - blue) / delta), 6.f));
+                hsv_data.hue = 60.f * (std::fmodf(((green - blue) / delta), 6.f));
             else if (max == green)
-                hsvData.hue = 60.f * (((blue - red) / delta) + 2.f);
+                hsv_data.hue = 60.f * (((blue - red) / delta) + 2.f);
             else if (max == blue)
-                hsvData.hue = 60.f * (((red - green) / delta) + 4.f);
+                hsv_data.hue = 60.f * (((red - green) / delta) + 4.f);
 
-            if (hsvData.hue < 0.f)
-                hsvData.hue += 360.f;
+            if (hsv_data.hue < 0.f)
+                hsv_data.hue += 360.f;
 
-            hsvData.hue /= 360.f;
-            hsvData.saturation = max == 0.f ? 0.f : delta / max;
-            hsvData.value = max;
+            hsv_data.hue /= 360.f;
+            hsv_data.saturation = max == 0.f ? 0.f : delta / max;
+            hsv_data.value = max;
 
-            return hsvData;
+            return hsv_data;
         }
 
-        constexpr explicit Color(const Vector4& vec) : Vector4(vec)
+        constexpr explicit Color(const Vector4& vec): Vector4(vec)
         {
-            Clamp(0.f, 1.f);
+            clamp(0.f, 1.f);
         }
-        constexpr void SetHue(const float hue)
+        constexpr void set_hue(const float hue)
         {
-            auto hsv = ToHSV();
+            auto hsv = to_hsv();
             hsv.hue = hue;
 
-            *this = FromHSV(hsv);
+            *this = from_hsv(hsv);
         }
 
-        constexpr void SetSaturation(const float saturation)
+        constexpr void set_saturation(const float saturation)
         {
-            auto hsv = ToHSV();
+            auto hsv = to_hsv();
             hsv.saturation = saturation;
 
-            *this = FromHSV(hsv);
+            *this = from_hsv(hsv);
         }
 
-        constexpr void SetValue(const float value)
+        constexpr void set_value(const float value)
         {
-            auto hsv = ToHSV();
+            auto hsv = to_hsv();
             hsv.value = value;
 
-            *this = FromHSV(hsv);
+            *this = from_hsv(hsv);
         }
         [[nodiscard]]
-        constexpr Color Blend(const Color& other, float ratio) const
+        constexpr Color blend(const Color& other, float ratio) const
         {
             ratio = std::clamp(ratio, 0.f, 1.f);
             return Color(*this * (1.f - ratio) + other * ratio);
         }
 
-        [[nodiscard]] static constexpr Color Red()
+        [[nodiscard]] static constexpr Color red()
         {
             return {1.f, 0.f, 0.f, 1.f};
         }
-        [[nodiscard]] static constexpr Color Green()
+        [[nodiscard]] static constexpr Color green()
         {
             return {0.f, 1.f, 0.f, 1.f};
         }
-        [[nodiscard]] static constexpr Color Blue()
+        [[nodiscard]] static constexpr Color blue()
         {
             return {0.f, 0.f, 1.f, 1.f};
         }

include/omath/engines/iw_engine/camera.hpp

@@ -8,14 +8,15 @@
 
 namespace omath::iw_engine
 {
-    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
+    class Camera final : public projection::Camera<Mat4X4, ViewAngles>
     {
     public:
-        Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+        Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
                const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
-        void LookAt(const Vector3<float>& target) override;
+        void look_at(const Vector3<float>& target) override;
+
     protected:
-        [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
-        [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
+        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
     };
-}
+} // namespace omath::iw_engine

include/omath/engines/iw_engine/constants.hpp

@@ -3,23 +3,23 @@
 //
 
 #pragma once
-#include <omath/vector3.hpp>
-#include <omath/mat.hpp>
 #include <omath/angle.hpp>
+#include <omath/mat.hpp>
+#include <omath/vector3.hpp>
 #include <omath/view_angles.hpp>
 
 namespace omath::iw_engine
 {
-    constexpr Vector3<float> kAbsUp = {0, 0, 1};
-    constexpr Vector3<float> kAbsRight = {0, -1, 0};
-    constexpr Vector3<float> kAbsForward = {1, 0, 0};
+    constexpr Vector3<float> k_abs_up = {0, 0, 1};
+    constexpr Vector3<float> k_abs_right = {0, -1, 0};
+    constexpr Vector3<float> k_abs_forward = {1, 0, 0};
 
-    using Mat4x4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
-    using Mat3x3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
-    using Mat1x3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
+    using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3X3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat1X3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
     using PitchAngle = Angle<float, -89.f, 89.f, AngleFlags::Clamped>;
     using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
     using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
 
     using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
-}
+} // namespace omath::iw_engine

include/omath/engines/iw_engine/formulas.hpp

@@ -8,19 +8,19 @@
 namespace omath::iw_engine
 {
     [[nodiscard]]
-    Vector3<float> ForwardVector(const ViewAngles& angles);
+    Vector3<float> forward_vector(const ViewAngles& angles);
 
     [[nodiscard]]
-    Vector3<float> RightVector(const ViewAngles& angles);
+    Vector3<float> right_vector(const ViewAngles& angles);
 
     [[nodiscard]]
-    Vector3<float> UpVector(const ViewAngles& angles);
+    Vector3<float> up_vector(const ViewAngles& angles);
 
     [[nodiscard]]
-    Mat4x4 RotationMatrix(const ViewAngles& angles);
+    Mat4X4 rotation_matrix(const ViewAngles& angles);
 
-    [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
 
     [[nodiscard]]
-    Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
 } // namespace omath::iw_engine

include/omath/engines/opengl_engine/camera.hpp

@@ -7,13 +7,13 @@
 
 namespace omath::opengl_engine
 {
-    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
+    class Camera final : public projection::Camera<Mat4X4, ViewAngles>
     {
     public:
-        Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+        Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
                const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
-        void LookAt(const Vector3<float>& target) override;
-        [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
-        [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
+        void look_at(const Vector3<float>& target) override;
+        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
     };
-}
+} // namespace omath::opengl_engine

include/omath/engines/opengl_engine/constants.hpp

@@ -10,17 +10,16 @@
 
 namespace omath::opengl_engine
 {
-    constexpr Vector3<float> kAbsUp = {0, 1, 0};
-    constexpr Vector3<float> kAbsRight = {1, 0, 0};
-    constexpr Vector3<float> kAbsForward = {0, 0, -1};
+    constexpr Vector3<float> k_abs_up = {0, 1, 0};
+    constexpr Vector3<float> k_abs_right = {1, 0, 0};
+    constexpr Vector3<float> k_abs_forward = {0, 0, -1};
 
-    using Mat4x4 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
-    using Mat3x3 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
-    using Mat1x3 = Mat<1, 3, float, MatStoreType::COLUMN_MAJOR>;
+    using Mat4X4 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
+    using Mat3X3 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
+    using Mat1X3 = Mat<1, 3, float, MatStoreType::COLUMN_MAJOR>;
     using PitchAngle = Angle<float, -90.f, 90.f, AngleFlags::Clamped>;
     using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
     using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
 
-
     using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
-}
+} // namespace omath::opengl_engine

include/omath/engines/opengl_engine/formulas.hpp

@@ -8,19 +8,19 @@
 namespace omath::opengl_engine
 {
     [[nodiscard]]
-    Vector3<float> ForwardVector(const ViewAngles& angles);
+    Vector3<float> forward_vector(const ViewAngles& angles);
 
     [[nodiscard]]
-    Vector3<float> RightVector(const ViewAngles& angles);
+    Vector3<float> right_vector(const ViewAngles& angles);
 
     [[nodiscard]]
-    Vector3<float> UpVector(const ViewAngles& angles);
+    Vector3<float> up_vector(const ViewAngles& angles);
 
-    [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
 
     [[nodiscard]]
-    Mat4x4 RotationMatrix(const ViewAngles& angles);
+    Mat4X4 rotation_matrix(const ViewAngles& angles);
 
     [[nodiscard]]
-    Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
 } // namespace omath::opengl_engine

include/omath/engines/source_engine/camera.hpp

@@ -7,14 +7,15 @@
 
 namespace omath::source_engine
 {
-    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
+    class Camera final : public projection::Camera<Mat4X4, ViewAngles>
     {
     public:
-        Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+        Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
                const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
-        void LookAt(const Vector3<float>& target) override;
+        void look_at(const Vector3<float>& target) override;
+
     protected:
-        [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
-        [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
+        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
     };
-}
+} // namespace omath::source_engine

include/omath/engines/source_engine/constants.hpp

@@ -3,23 +3,23 @@
 //
 #pragma once
 
-#include <omath/vector3.hpp>
-#include <omath/mat.hpp>
 #include <omath/angle.hpp>
+#include <omath/mat.hpp>
+#include <omath/vector3.hpp>
 #include <omath/view_angles.hpp>
 
 namespace omath::source_engine
 {
-    constexpr Vector3<float> kAbsUp = {0, 0, 1};
-    constexpr Vector3<float> kAbsRight = {0, -1, 0};
-    constexpr Vector3<float> kAbsForward = {1, 0, 0};
+    constexpr Vector3<float> k_abs_up = {0, 0, 1};
+    constexpr Vector3<float> k_abs_right = {0, -1, 0};
+    constexpr Vector3<float> k_abs_forward = {1, 0, 0};
 
-    using Mat4x4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
-    using Mat3x3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
-    using Mat1x3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
+    using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3X3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat1X3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
     using PitchAngle = Angle<float, -89.f, 89.f, AngleFlags::Clamped>;
     using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
     using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
 
     using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
-} // namespace omath::source
+} // namespace omath::source_engine

include/omath/engines/source_engine/formulas.hpp

@@ -7,19 +7,19 @@
 namespace omath::source_engine
 {
     [[nodiscard]]
-    Vector3<float> ForwardVector(const ViewAngles& angles);
+    Vector3<float> forward_vector(const ViewAngles& angles);
 
     [[nodiscard]]
-    Mat4x4 RotationMatrix(const ViewAngles& angles);
+    Mat4X4 rotation_matrix(const ViewAngles& angles);
 
     [[nodiscard]]
-    Vector3<float> RightVector(const ViewAngles& angles);
+    Vector3<float> right_vector(const ViewAngles& angles);
 
     [[nodiscard]]
-    Vector3<float> UpVector(const ViewAngles& angles);
+    Vector3<float> up_vector(const ViewAngles& angles);
 
-    [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
 
     [[nodiscard]]
-    Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
-} // namespace omath::source
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
+} // namespace omath::source_engine

include/omath/engines/unity_engine/camera.hpp

@@ -8,14 +8,15 @@
 
 namespace omath::unity_engine
 {
-    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
+    class Camera final : public projection::Camera<Mat4X4, ViewAngles>
     {
     public:
-        Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+        Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
                const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
-        void LookAt(const Vector3<float>& target) override;
+        void look_at(const Vector3<float>& target) override;
+
     protected:
-        [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
-        [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
+        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
     };
-}
+} // namespace omath::unity_engine

include/omath/engines/unity_engine/constants.hpp

@@ -4,23 +4,23 @@
 
 #pragma once
 
-#include <omath/vector3.hpp>
-#include <omath/mat.hpp>
 #include <omath/angle.hpp>
+#include <omath/mat.hpp>
+#include <omath/vector3.hpp>
 #include <omath/view_angles.hpp>
 
 namespace omath::unity_engine
 {
-    constexpr Vector3<float> kAbsUp = {0, 1, 0};
-    constexpr Vector3<float> kAbsRight = {1, 0, 0};
-    constexpr Vector3<float> kAbsForward = {0, 0, 1};
+    constexpr Vector3<float> k_abs_up = {0, 1, 0};
+    constexpr Vector3<float> k_abs_right = {1, 0, 0};
+    constexpr Vector3<float> k_abs_forward = {0, 0, 1};
 
-    using Mat4x4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
-    using Mat3x3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
-    using Mat1x3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
+    using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3X3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat1X3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
     using PitchAngle = Angle<float, -90.f, 90.f, AngleFlags::Clamped>;
     using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
     using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
 
     using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
-} // namespace omath::source
+} // namespace omath::unity_engine

include/omath/engines/unity_engine/formulas.hpp

@@ -8,19 +8,19 @@
 namespace omath::unity_engine
 {
     [[nodiscard]]
-    Vector3<float> ForwardVector(const ViewAngles& angles);
+    Vector3<float> forward_vector(const ViewAngles& angles);
 
     [[nodiscard]]
-    Vector3<float> RightVector(const ViewAngles& angles);
+    Vector3<float> right_vector(const ViewAngles& angles);
 
     [[nodiscard]]
-    Vector3<float> UpVector(const ViewAngles& angles);
+    Vector3<float> up_vector(const ViewAngles& angles);
 
-    [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
 
     [[nodiscard]]
-    Mat4x4 RotationMatrix(const ViewAngles& angles);
+    Mat4X4 rotation_matrix(const ViewAngles& angles);
 
     [[nodiscard]]
-    Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
-} // namespace omath::source
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
+} // namespace omath::unity_engine

include/omath/mat.hpp

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

include/omath/matrix.hpp

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

include/omath/pathfinding/a_star.hpp

@@ -3,9 +3,9 @@
 //
 
 #pragma once
-#include <vector>
 #include "omath/pathfinding/navigation_mesh.hpp"
 #include "omath/vector3.hpp"
+#include <vector>
 
 namespace omath::pathfinding
 {
@@ -14,17 +14,17 @@ namespace omath::pathfinding
     {
     public:
         [[nodiscard]]
-        static std::vector<Vector3<float>> FindPath(const Vector3<float>& start, const Vector3<float>& end,
-                                                    const NavigationMesh& navMesh);
+        static std::vector<Vector3<float>> find_path(const Vector3<float>& start, const Vector3<float>& end,
+                                                     const NavigationMesh& nav_mesh);
 
     private:
         [[nodiscard]]
         static std::vector<Vector3<float>>
-        ReconstructFinalPath(const std::unordered_map<Vector3<float>, PathNode>& closedList,
-                             const Vector3<float>& current);
+        reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
+                               const Vector3<float>& current);
 
         [[nodiscard]]
-        static auto GetPerfectNode(const std::unordered_map<Vector3<float>, PathNode>& openList,
-                                   const Vector3<float>& endVertex);
+        static auto get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
+                                     const Vector3<float>& end_vertex);
     };
 } // namespace omath::pathfinding

include/omath/pathfinding/navigation_mesh.hpp

@@ -4,10 +4,10 @@
 
 #pragma once
 
+#include "omath/vector3.hpp"
 #include <expected>
 #include <string>
 #include <vector>
-#include "omath/vector3.hpp"
 
 namespace omath::pathfinding
 {
@@ -21,18 +21,18 @@ namespace omath::pathfinding
     {
     public:
         [[nodiscard]]
-        std::expected<Vector3<float>, std::string> GetClosestVertex(const Vector3<float>& point) const;
+        std::expected<Vector3<float>, std::string> get_closest_vertex(const Vector3<float>& point) const;
 
         [[nodiscard]]
-        const std::vector<Vector3<float>>& GetNeighbors(const Vector3<float>& vertex) const;
+        const std::vector<Vector3<float>>& get_neighbors(const Vector3<float>& vertex) const;
 
         [[nodiscard]]
-        bool Empty() const;
+        bool empty() const;
 
-        [[nodiscard]] std::vector<uint8_t> Serialize() const;
+        [[nodiscard]] std::vector<uint8_t> serialize() const;
 
-        void Deserialize(const std::vector<uint8_t>& raw);
+        void deserialize(const std::vector<uint8_t>& raw);
 
-        std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_verTextMap;
+        std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_vertex_map;
     };
 } // namespace omath::pathfinding

include/omath/projectile_prediction/proj_pred_engine.hpp

@@ -6,15 +6,14 @@
 #include "omath/projectile_prediction/target.hpp"
 #include "omath/vector3.hpp"
 
-
 namespace omath::projectile_prediction
 {
     class ProjPredEngine
     {
     public:
         [[nodiscard]]
-        virtual std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
-                                                              const Target& target) const = 0;
+        virtual std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
+                                                                        const Target& target) const = 0;
         virtual ~ProjPredEngine() = default;
     };
 } // namespace omath::projectile_prediction

include/omath/projectile_prediction/proj_pred_engine_avx2.hpp

@@ -6,21 +6,23 @@
 
 namespace omath::projectile_prediction
 {
-    class ProjPredEngineAVX2 final : public ProjPredEngine
+    class ProjPredEngineAvx2 final : public ProjPredEngine
     {
     public:
-        [[nodiscard]] std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
-                                                                    const Target& target) const override;
+        [[nodiscard]] std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
+                                                                              const Target& target) const override;
 
-
-        ProjPredEngineAVX2(float gravityConstant, float simulationTimeStep, float maximumSimulationTime);
-        ~ProjPredEngineAVX2() override = default;
+        ProjPredEngineAvx2(float gravity_constant, float simulation_time_step, float maximum_simulation_time);
+        ~ProjPredEngineAvx2() override = default;
 
     private:
-        [[nodiscard]] static std::optional<float> CalculatePitch(const Vector3<float>& projOrigin, const Vector3<float>& targetPos,
-                                                                 float bulletGravity, float v0, float time);
-        const float m_gravityConstant;
-        const float m_simulationTimeStep;
-        const float m_maximumSimulationTime;
+        [[nodiscard]] static std::optional<float> calculate_pitch(const Vector3<float>& proj_origin,
+                                                                  const Vector3<float>& target_pos,
+                                                                  float bullet_gravity, float v0, float time);
+
+        // We use [[maybe_unused]] here since AVX2 is not available for ARM and ARM64 CPU
+        [[maybe_unused]] const float m_gravity_constant;
+        [[maybe_unused]] const float m_simulation_time_step;
+        [[maybe_unused]] const float m_maximum_simulation_time;
     };
 } // namespace omath::projectile_prediction

include/omath/projectile_prediction/proj_pred_engine_legacy.hpp

@@ -4,38 +4,36 @@
 
 #pragma once
 
-#include <optional>
 #include "omath/projectile_prediction/proj_pred_engine.hpp"
 #include "omath/projectile_prediction/projectile.hpp"
 #include "omath/projectile_prediction/target.hpp"
 #include "omath/vector3.hpp"
-
+#include <optional>
 
 namespace omath::projectile_prediction
 {
     class ProjPredEngineLegacy final : public ProjPredEngine
     {
     public:
-        explicit ProjPredEngineLegacy(float gravityConstant, float simulationTimeStep, float maximumSimulationTime,
-                                      float distanceTolerance);
+        explicit ProjPredEngineLegacy(float gravity_constant, float simulation_time_step, float maximum_simulation_time,
+                                      float distance_tolerance);
 
         [[nodiscard]]
-        std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
-                                                      const Target& target) const override;
+        std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
+                                                                const Target& target) const override;
 
     private:
-        const float m_gravityConstant;
-        const float m_simulationTimeStep;
-        const float m_maximumSimulationTime;
-        const float m_distanceTolerance;
+        const float m_gravity_constant;
+        const float m_simulation_time_step;
+        const float m_maximum_simulation_time;
+        const float m_distance_tolerance;
 
         [[nodiscard]]
-        std::optional<float> MaybeCalculateProjectileLaunchPitchAngle(const Projectile& projectile,
-                                                                      const Vector3<float>& targetPosition) const;
-
+        std::optional<float> maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
+                                                                           const Vector3<float>& target_position) const;
 
         [[nodiscard]]
-        bool IsProjectileReachedTarget(const Vector3<float>& targetPosition, const Projectile& projectile, float pitch,
-                                       float time) const;
+        bool is_projectile_reached_target(const Vector3<float>& target_position, const Projectile& projectile,
+                                          float pitch, float time) const;
     };
 } // namespace omath::projectile_prediction

include/omath/projectile_prediction/projectile.hpp

@@ -10,12 +10,11 @@ namespace omath::projectile_prediction
     class Projectile final
     {
     public:
-
         [[nodiscard]]
-        Vector3<float> PredictPosition(float pitch, float yaw, float time, float gravity) const;
+        Vector3<float> predict_position(float pitch, float yaw, float time, float gravity) const;
 
         Vector3<float> m_origin;
-        float m_launchSpeed{};
-        float m_gravityScale{};
+        float m_launch_speed{};
+        float m_gravity_scale{};
     };
-}
+} // namespace omath::projectile_prediction

include/omath/projectile_prediction/target.hpp

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

include/omath/projection/camera.hpp

@@ -4,12 +4,12 @@
 
 #pragma once
 
+#include "omath/projection/error_codes.hpp"
 #include <expected>
 #include <omath/angle.hpp>
 #include <omath/mat.hpp>
 #include <omath/vector3.hpp>
 #include <type_traits>
-#include "omath/projection/error_codes.hpp"
 
 namespace omath::projection
 {
@@ -19,157 +19,156 @@ namespace omath::projection
         float m_width;
         float m_height;
 
-        [[nodiscard]] constexpr float AspectRatio() const
+        [[nodiscard]] constexpr float aspect_ratio() const
         {
             return m_width / m_height;
         }
     };
     using FieldOfView = Angle<float, 0.f, 180.f, AngleFlags::Clamped>;
 
-    template<class Mat4x4Type, class ViewAnglesType>
+    template<class Mat4X4Type, class ViewAnglesType>
     class Camera
     {
     public:
         virtual ~Camera() = default;
-        Camera(const Vector3<float>& position, const ViewAnglesType& viewAngles, const ViewPort& viewPort,
-               const FieldOfView& fov, const float near, const float far) :
-            m_viewPort(viewPort), m_fieldOfView(fov), m_farPlaneDistance(far), m_nearPlaneDistance(near),
-            m_viewAngles(viewAngles), m_origin(position)
+        Camera(const Vector3<float>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
+               const FieldOfView& fov, const float near, const float far)
+            : m_view_port(view_port), m_field_of_view(fov), m_far_plane_distance(far), m_near_plane_distance(near),
+              m_view_angles(view_angles), m_origin(position)
         {
         }
 
     protected:
-        virtual void LookAt(const Vector3<float>& target) = 0;
+        virtual void look_at(const Vector3<float>& target) = 0;
 
-        [[nodiscard]] virtual Mat4x4Type CalcViewMatrix() const = 0;
+        [[nodiscard]] virtual Mat4X4Type calc_view_matrix() const = 0;
 
-        [[nodiscard]] virtual Mat4x4Type CalcProjectionMatrix() const = 0;
+        [[nodiscard]] virtual Mat4X4Type calc_projection_matrix() const = 0;
 
-        [[nodiscard]] Mat4x4Type CalcViewProjectionMatrix() const
+        [[nodiscard]] Mat4X4Type calc_view_projection_matrix() const
         {
-            return CalcProjectionMatrix() * CalcViewMatrix();
+            return calc_projection_matrix() * calc_view_matrix();
         }
 
     public:
-        [[nodiscard]] const Mat4x4Type& GetViewProjectionMatrix() const
+        [[nodiscard]] const Mat4X4Type& get_view_projection_matrix() const
         {
-            if (!m_viewProjectionMatrix.has_value())
-                m_viewProjectionMatrix = CalcViewProjectionMatrix();
+            if (!m_view_projection_matrix.has_value())
+                m_view_projection_matrix = calc_view_projection_matrix();
 
-            return m_viewProjectionMatrix.value();
+            return m_view_projection_matrix.value();
         }
 
-        void SetFieldOfView(const FieldOfView& fov)
+        void set_field_of_view(const FieldOfView& fov)
         {
-            m_fieldOfView = fov;
+            m_field_of_view = fov;
+            m_view_projection_matrix = std::nullopt;
         }
 
-        void SetNearPlane(const float near)
+        void set_near_plane(const float near)
         {
-            m_nearPlaneDistance = near;
+            m_near_plane_distance = near;
+            m_view_projection_matrix = std::nullopt;
         }
 
-        void SetFarPlane(const float far)
+        void set_far_plane(const float far)
         {
-            m_farPlaneDistance = far;
+            m_far_plane_distance = far;
+            m_view_projection_matrix = std::nullopt;
         }
 
-        void SetViewAngles(const ViewAnglesType& viewAngles)
+        void set_view_angles(const ViewAnglesType& view_angles)
         {
-            m_viewAngles = viewAngles;
+            m_view_angles = view_angles;
+            m_view_projection_matrix = std::nullopt;
         }
 
-        void SetOrigin(const Vector3<float>& origin)
+        void set_origin(const Vector3<float>& origin)
         {
             m_origin = origin;
+            m_view_projection_matrix = std::nullopt;
         }
 
-        void SetViewPort(const ViewPort& viewPort)
+        void set_view_port(const ViewPort& view_port)
         {
-            m_viewPort = viewPort;
+            m_view_port = view_port;
+            m_view_projection_matrix = std::nullopt;
         }
 
-        [[nodiscard]] const FieldOfView& GetFieldOfView() const
+        [[nodiscard]] const FieldOfView& get_field_of_view() const
         {
-            return m_fieldOfView;
+            return m_field_of_view;
         }
 
-        [[nodiscard]] const float& GetNearPlane() const
+        [[nodiscard]] const float& get_near_plane() const
         {
-            return m_nearPlaneDistance;
+            return m_near_plane_distance;
         }
 
-        [[nodiscard]] const float& GetFarPlane() const
+        [[nodiscard]] const float& get_far_plane() const
         {
-            return m_farPlaneDistance;
+            return m_far_plane_distance;
         }
 
-        [[nodiscard]] const ViewAnglesType& GetViewAngles() const
+        [[nodiscard]] const ViewAnglesType& get_view_angles() const
         {
-            return m_viewAngles;
+            return m_view_angles;
         }
 
-        [[nodiscard]] const Vector3<float>& GetOrigin() const
+        [[nodiscard]] const Vector3<float>& get_origin() const
         {
             return m_origin;
         }
 
-        [[nodiscard]] std::expected<Vector3<float>, Error> WorldToScreen(const Vector3<float>& worldPosition) const
+        [[nodiscard]] std::expected<Vector3<float>, Error> world_to_screen(const Vector3<float>& world_position) const
         {
-            auto normalizedCords = WorldToViewPort(worldPosition);
+            auto normalized_cords = world_to_view_port(world_position);
 
-            if (!normalizedCords.has_value())
-                return std::unexpected{normalizedCords.error()};
+            if (!normalized_cords.has_value())
+                return std::unexpected{normalized_cords.error()};
 
-
-            return NdcToScreenPosition(*normalizedCords);
+            return ndc_to_screen_position(*normalized_cords);
         }
 
-        [[nodiscard]] std::expected<Vector3<float>, Error> WorldToViewPort(const Vector3<float>& worldPosition) const
+        [[nodiscard]] std::expected<Vector3<float>, Error>
+        world_to_view_port(const Vector3<float>& world_position) const
         {
-            auto projected = GetViewProjectionMatrix() *
-                                   MatColumnFromVector<float, Mat4x4Type::GetStoreOrdering()>(worldPosition);
+            auto projected = get_view_projection_matrix()
+                             * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(world_position);
 
-            if (projected.At(3, 0) == 0.0f)
+            if (projected.at(3, 0) == 0.0f)
                 return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
-            projected /= projected.At(3, 0);
+            projected /= projected.at(3, 0);
 
-            if (IsNdcOutOfBounds(projected))
+            if (is_ndc_out_of_bounds(projected))
                 return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
-            return Vector3<float>{projected.At(0, 0), projected.At(1, 0), projected.At(2, 0)};
+            return Vector3<float>{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)};
         }
 
     protected:
-        ViewPort m_viewPort{};
-        Angle<float, 0.f, 180.f, AngleFlags::Clamped> m_fieldOfView;
+        ViewPort m_view_port{};
+        Angle<float, 0.f, 180.f, AngleFlags::Clamped> m_field_of_view;
 
-        mutable std::optional<Mat4x4Type> m_viewProjectionMatrix;
+        mutable std::optional<Mat4X4Type> m_view_projection_matrix;
 
-        float m_farPlaneDistance;
-        float m_nearPlaneDistance;
+        float m_far_plane_distance;
+        float m_near_plane_distance;
 
-
-        ViewAnglesType m_viewAngles;
+        ViewAnglesType m_view_angles;
         Vector3<float> m_origin;
 
     private:
-        template<class Type>
-        [[nodiscard]]
-        constexpr static bool IsNdcOutOfBounds(const Type& ndc)
+        template<class Type> [[nodiscard]]
+        constexpr static bool is_ndc_out_of_bounds(const Type& ndc)
         {
-            return std::ranges::any_of(ndc.RawArray(), [](const auto& val) { return val < -1 || val > 1; });
+            return std::ranges::any_of(ndc.raw_array(), [](const auto& val) { return val < -1 || val > 1; });
         }
 
-        [[nodiscard]] Vector3<float> NdcToScreenPosition(const Vector3<float>& ndc) const
+        [[nodiscard]] Vector3<float> ndc_to_screen_position(const Vector3<float>& ndc) const
         {
-            return
-            {
-                (ndc.x + 1.f) / 2.f * m_viewPort.m_width,
-                (1.f - ndc.y) / 2.f * m_viewPort.m_height,
-                ndc.z
-            };
+            return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (1.f - ndc.y) / 2.f * m_view_port.m_height, ndc.z};
         }
     };
 } // namespace omath::projection

include/omath/projection/error_codes.hpp

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

include/omath/triangle.hpp

@@ -6,15 +6,14 @@
 
 namespace omath
 {
-        /*
-        |\
-        | \
-      a |  \ hypot
-        |   \
-        -----
-          b
-        */
-
+    /*
+    |\
+    | \
+  a |  \ hypot
+    |   \
+    -----
+      b
+    */
 
     template<class Vector>
     class Triangle final
@@ -31,52 +30,53 @@ namespace omath
         Vector3<float> m_vertex3;
 
         [[nodiscard]]
-        constexpr Vector3<float> CalculateNormal() const
+        constexpr Vector3<float> calculate_normal() const
         {
-            const auto b = SideBVector();
-            const auto a = SideAVector();
-            return b.Cross(a).Normalized();
+            const auto b = side_b_vector();
+            const auto a = side_a_vector();
+
+            return b.cross(a).normalized();
         }
 
         [[nodiscard]]
-        float SideALength() const
+        float side_a_length() const
         {
-            return m_vertex1.DistTo(m_vertex2);
+            return m_vertex1.distance_to(m_vertex2);
         }
 
         [[nodiscard]]
-        float SideBLength() const
+        float side_b_length() const
         {
-            return m_vertex3.DistTo(m_vertex2);
+            return m_vertex3.distance_to(m_vertex2);
         }
 
         [[nodiscard]]
-        constexpr Vector3<float> SideAVector() const
+        constexpr Vector3<float> side_a_vector() const
         {
             return m_vertex1 - m_vertex2;
         }
 
         [[nodiscard]]
-        constexpr float Hypot() const
+        constexpr float hypot() const
         {
-            return m_vertex1.DistTo(m_vertex3);
+            return m_vertex1.distance_to(m_vertex3);
         }
         [[nodiscard]]
-        constexpr bool IsRectangular() const
+        constexpr bool is_rectangular() const
         {
-            const auto sideA = SideALength();
-            const auto sideB = SideBLength();
-            const auto hypot = Hypot();
+            const auto side_a = side_a_length();
+            const auto side_b = side_b_length();
+            const auto hypot_value = hypot();
 
-            return std::abs(sideA*sideA + sideB*sideB - hypot*hypot) <= 0.0001f;
+            return std::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f;
         }
         [[nodiscard]]
-        constexpr Vector3<float> SideBVector() const
+        constexpr Vector3<float> side_b_vector() const
         {
             return m_vertex3 - m_vertex2;
         }
         [[nodiscard]]
-        constexpr Vector3<float> MidPoint() const
+        constexpr Vector3<float> mid_point() const
         {
             return (m_vertex1 + m_vertex2 + m_vertex3) / 3;
         }

include/omath/vector2.hpp

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

include/omath/vector3.hpp

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

include/omath/vector4.hpp

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

include/omath/view_angles.hpp

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

source/3d_primitives/CMakeLists.txt

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

source/3d_primitives/box.cpp

@@ -3,27 +3,25 @@
 //
 #include "omath/3d_primitives/box.hpp"
 
-
 namespace omath::primitives
 {
-    std::array<Triangle<Vector3<float>>, 12> CreateBox(const Vector3<float>& top, const Vector3<float>& bottom,
-                                                       const Vector3<float>& dirForward,
-                                                       const Vector3<float>& dirRight,
-                                                       const float ratio)
+    std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
+                                                        const Vector3<float>& dir_forward,
+                                                        const Vector3<float>& dir_right, const float ratio)
     {
-        const auto height = top.DistTo(bottom);
-        const auto sideSize = height / ratio;
+        const auto height = top.distance_to(bottom);
+        const auto side_size = height / ratio;
 
         // corner layout (0‑3 bottom, 4‑7 top)
         std::array<Vector3<float>, 8> p;
-        p[0] = bottom + (dirForward + dirRight) * sideSize; // front‑right‑bottom
-        p[1] = bottom + (dirForward - dirRight) * sideSize; // front‑left‑bottom
-        p[2] = bottom + (-dirForward + dirRight) * sideSize; // back‑right‑bottom
-        p[3] = bottom + (-dirForward - dirRight) * sideSize; // back‑left‑bottom
-        p[4] = top + (dirForward + dirRight) * sideSize; // front‑right‑top
-        p[5] = top + (dirForward - dirRight) * sideSize; // front‑left‑top
-        p[6] = top + (-dirForward + dirRight) * sideSize; // back‑right‑top
-        p[7] = top + (-dirForward - dirRight) * sideSize; // back‑left‑top
+        p[0] = bottom + (dir_forward + dir_right) * side_size; // front‑right‑bottom
+        p[1] = bottom + (dir_forward - dir_right) * side_size; // front‑left‑bottom
+        p[2] = bottom + (-dir_forward + dir_right) * side_size; // back‑right‑bottom
+        p[3] = bottom + (-dir_forward - dir_right) * side_size; // back‑left‑bottom
+        p[4] = top + (dir_forward + dir_right) * side_size; // front‑right‑top
+        p[5] = top + (dir_forward - dir_right) * side_size; // front‑left‑top
+        p[6] = top + (-dir_forward + dir_right) * side_size; // back‑right‑top
+        p[7] = top + (-dir_forward - dir_right) * side_size; // back‑left‑top
 
         std::array<Triangle<Vector3<float>>, 12> poly;
 
@@ -53,4 +51,4 @@ namespace omath::primitives
 
         return poly;
     }
-}
+} // namespace omath::primitives

source/CMakeLists.txt

@@ -1,11 +0,0 @@
-target_sources(omath PRIVATE
-        matrix.cpp
-        color.cpp
-)
-
-add_subdirectory(projectile_prediction)
-add_subdirectory(pathfinding)
-add_subdirectory(projection)
-add_subdirectory(collision)
-add_subdirectory(engines)
-add_subdirectory(3d_primitives)

source/collision/CMakeLists.txt

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

source/collision/line_tracer.cpp

@@ -5,63 +5,59 @@
 
 namespace omath::collision
 {
-    bool LineTracer::CanTraceLine(const Ray& ray, const Triangle<Vector3<float>>& triangle)
+    bool LineTracer::can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle)
     {
-        return GetRayHitPoint(ray, triangle) == ray.end;
+        return get_ray_hit_point(ray, triangle) == ray.end;
     }
-    Vector3<float> Ray::DirectionVector() const
+    Vector3<float> Ray::direction_vector() const
     {
         return end - start;
     }
 
-    Vector3<float> Ray::DirectionVectorNormalized() const
+    Vector3<float> Ray::direction_vector_normalized() const
     {
-        return DirectionVector().Normalized();
+        return direction_vector().normalized();
     }
 
-    Vector3<float> LineTracer::GetRayHitPoint(const Ray& ray, const Triangle<Vector3<float>>& triangle)
+    Vector3<float> LineTracer::get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle)
     {
-        constexpr float kEpsilon = std::numeric_limits<float>::epsilon();
+        constexpr float k_epsilon = std::numeric_limits<float>::epsilon();
 
-        const auto sideA = triangle.SideAVector();
-        const auto sideB = triangle.SideBVector();
+        const auto side_a = triangle.side_a_vector();
+        const auto side_b = triangle.side_b_vector();
 
+        const auto ray_dir = ray.direction_vector();
 
-        const auto rayDir = ray.DirectionVector();
+        const auto p = ray_dir.cross(side_b);
+        const auto det = side_a.dot(p);
 
-        const auto p = rayDir.Cross(sideB);
-        const auto det = sideA.Dot(p);
-
-
-        if (std::abs(det) < kEpsilon)
+        if (std::abs(det) < k_epsilon)
             return ray.end;
 
-        const auto invDet = 1.0f / det;
+        const auto inv_det = 1.0f / det;
         const auto t = ray.start - triangle.m_vertex2;
-        const auto u = t.Dot(p) * invDet;
+        const auto u = t.dot(p) * inv_det;
 
-
-        if ((u < 0 && std::abs(u) > kEpsilon) || (u > 1 && std::abs(u - 1) > kEpsilon))
+        if ((u < 0 && std::abs(u) > k_epsilon) || (u > 1 && std::abs(u - 1) > k_epsilon))
             return ray.end;
 
-        const auto q = t.Cross(sideA);
-        const auto v = rayDir.Dot(q) * invDet;
+        const auto q = t.cross(side_a);
+        // ReSharper disable once CppTooWideScopeInitStatement
+        const auto v = ray_dir.dot(q) * inv_det;
 
-
-        if ((v < 0 && std::abs(v) > kEpsilon) || (u + v > 1 && std::abs(u + v - 1) > kEpsilon))
+        if ((v < 0 && std::abs(v) > k_epsilon) || (u + v > 1 && std::abs(u + v - 1) > k_epsilon))
             return ray.end;
 
-        const auto tHit = sideB.Dot(q) * invDet;
-
+        const auto t_hit = side_b.dot(q) * inv_det;
 
         if (ray.infinite_length)
         {
-            if (tHit <= kEpsilon)
+            if (t_hit <= k_epsilon)
                 return ray.end;
         }
-        else if (tHit <= kEpsilon || tHit > 1.0f - kEpsilon)
+        else if (t_hit <= k_epsilon || t_hit > 1.0f - k_epsilon)
             return ray.end;
 
-        return ray.start + rayDir * tHit;
+        return ray.start + ray_dir * t_hit;
     }
 } // namespace omath::collision

source/color.cpp

@@ -6,7 +6,6 @@
 #include <algorithm>
 #include <cmath>
 
-
 namespace omath
 {
 

source/engines/CMakeLists.txt

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

source/engines/iw_engine/CMakeLists.txt

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

source/engines/iw_engine/camera.cpp

@@ -7,28 +7,27 @@
 namespace omath::iw_engine
 {
 
-    Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
-                   const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far) :
-        projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
+    Camera::Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
+                   const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far)
+        : projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
     {
     }
-    void Camera::LookAt([[maybe_unused]] const Vector3<float>& target)
+    void Camera::look_at([[maybe_unused]] const Vector3<float>& target)
     {
-        const float distance = m_origin.DistTo(target);
+        const float distance = m_origin.distance_to(target);
         const auto delta = target - m_origin;
 
-
-        m_viewAngles.pitch = PitchAngle::FromRadians(std::asin(delta.z / distance));
-        m_viewAngles.yaw = -YawAngle::FromRadians(std::atan2(delta.y, delta.x));
-        m_viewAngles.roll = RollAngle::FromRadians(0.f);
+        m_view_angles.pitch = PitchAngle::from_radians(std::asin(delta.z / distance));
+        m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
+        m_view_angles.roll = RollAngle::from_radians(0.f);
     }
-    Mat4x4 Camera::CalcViewMatrix() const
+    Mat4X4 Camera::calc_view_matrix() const
     {
-        return iw_engine::CalcViewMatrix(m_viewAngles, m_origin);
+        return iw_engine::calc_view_matrix(m_view_angles, m_origin);
     }
-    Mat4x4 Camera::CalcProjectionMatrix() const
+    Mat4X4 Camera::calc_projection_matrix() const
     {
-        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
-                                               m_farPlaneDistance);
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
+                                                  m_near_plane_distance, m_far_plane_distance);
     }
-} // namespace omath::openg
+} // namespace omath::iw_engine

source/engines/iw_engine/formulas.cpp

@@ -3,50 +3,49 @@
 //
 #include "omath/engines/iw_engine/formulas.hpp"
 
-
 namespace omath::iw_engine
 {
 
-    Vector3<float> ForwardVector(const ViewAngles& angles)
+    Vector3<float> forward_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsForward);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
 
-    Vector3<float> RightVector(const ViewAngles& angles)
+    Vector3<float> right_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsRight);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Vector3<float> UpVector(const ViewAngles& angles)
+    Vector3<float> up_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsUp);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Mat4x4 RotationMatrix(const ViewAngles& angles)
+    Mat4X4 rotation_matrix(const ViewAngles& angles)
     {
-        return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
+        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
     }
 
-    Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
     {
-        return MatCameraView(ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
+        return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
     }
 
-    Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
-                                           const float far)
+    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
+                                              const float far)
     {
         // NOTE: Need magic number to fix fov calculation, since IW engine inherit Quake proj matrix calculation
-        constexpr auto kMultiplyFactor = 0.75f;
+        constexpr auto k_multiply_factor = 0.75f;
 
-        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f) * kMultiplyFactor;
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
 
         return {
-                {1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
-                {0, 1.f / (fovHalfTan), 0, 0},
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
                 {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
                 {0, 0, 1, 0},
         };

source/engines/opengl_engine/CMakeLists.txt

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

source/engines/opengl_engine/camera.cpp

@@ -4,32 +4,30 @@
 #include "omath/engines/opengl_engine/camera.hpp"
 #include "omath/engines/opengl_engine/formulas.hpp"
 
-
 namespace omath::opengl_engine
 {
 
-    Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
-                   const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far) :
-        projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
+    Camera::Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
+                   const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far)
+        : projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
     {
     }
-    void Camera::LookAt([[maybe_unused]] const Vector3<float>& target)
+    void Camera::look_at([[maybe_unused]] const Vector3<float>& target)
     {
-        const float distance = m_origin.DistTo(target);
+        const float distance = m_origin.distance_to(target);
         const auto delta = target - m_origin;
 
-
-        m_viewAngles.pitch = PitchAngle::FromRadians(std::asin(delta.z / distance));
-        m_viewAngles.yaw = -YawAngle::FromRadians(std::atan2(delta.y, delta.x));
-        m_viewAngles.roll = RollAngle::FromRadians(0.f);
+        m_view_angles.pitch = PitchAngle::from_radians(std::asin(delta.z / distance));
+        m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
+        m_view_angles.roll = RollAngle::from_radians(0.f);
     }
-    Mat4x4 Camera::CalcViewMatrix() const
+    Mat4X4 Camera::calc_view_matrix() const
     {
-        return opengl_engine::CalcViewMatrix(m_viewAngles, m_origin);
+        return opengl_engine::calc_view_matrix(m_view_angles, m_origin);
     }
-    Mat4x4 Camera::CalcProjectionMatrix() const
+    Mat4X4 Camera::calc_projection_matrix() const
     {
-        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
-                                               m_farPlaneDistance);
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
+                                                  m_near_plane_distance, m_far_plane_distance);
     }
-} // namespace omath::opengl
+} // namespace omath::opengl_engine

source/engines/opengl_engine/formulas.cpp

@@ -3,47 +3,48 @@
 //
 #include "omath/engines/opengl_engine/formulas.hpp"
 
-
 namespace omath::opengl_engine
 {
 
-    Vector3<float> ForwardVector(const ViewAngles& angles)
+    Vector3<float> forward_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector<float, MatStoreType::COLUMN_MAJOR>(kAbsForward);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Vector3<float> RightVector(const ViewAngles& angles)
+    Vector3<float> right_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector<float, MatStoreType::COLUMN_MAJOR>(kAbsRight);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Vector3<float> UpVector(const ViewAngles& angles)
+    Vector3<float> up_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector<float, MatStoreType::COLUMN_MAJOR>(kAbsUp);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
     {
-        return MatCameraView<float, MatStoreType::COLUMN_MAJOR>(-ForwardVector(angles), RightVector(angles),
-                                                                UpVector(angles), cam_origin);
+        return mat_camera_view<float, MatStoreType::COLUMN_MAJOR>(-forward_vector(angles), right_vector(angles),
+                                                                  up_vector(angles), cam_origin);
     }
-    Mat4x4 RotationMatrix(const ViewAngles& angles)
+    Mat4X4 rotation_matrix(const ViewAngles& angles)
     {
-        return MatRotationAxisZ<float, MatStoreType::COLUMN_MAJOR>(angles.roll) *
-               MatRotationAxisY<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw) *
-               MatRotationAxisX<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch);
+        return mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch)
+               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw)
+               * mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
     }
-    Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
-                                           const float far)
+    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
+                                              const float far)
     {
-        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
 
         return {
-                {1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
-                {0, 1.f / (fovHalfTan), 0, 0},
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
                 {0, 0, -(far + near) / (far - near), -(2.f * far * near) / (far - near)},
                 {0, 0, -1, 0},
         };

source/engines/source_engine/CMakeLists.txt

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

source/engines/source_engine/camera.cpp

@@ -4,34 +4,32 @@
 #include "omath/engines/source_engine/camera.hpp"
 #include "omath/engines/source_engine/formulas.hpp"
 
-
 namespace omath::source_engine
 {
 
-    Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
-                   const projection::FieldOfView& fov, const float near, const float far) :
-        projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
+    Camera::Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
+                   const projection::FieldOfView& fov, const float near, const float far)
+        : projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
     {
     }
-    void Camera::LookAt(const Vector3<float>& target)
+    void Camera::look_at(const Vector3<float>& target)
     {
-        const float distance = m_origin.DistTo(target);
+        const float distance = m_origin.distance_to(target);
         const auto delta = target - m_origin;
 
-
-        m_viewAngles.pitch = PitchAngle::FromRadians(std::asin(delta.z / distance));
-        m_viewAngles.yaw = -YawAngle::FromRadians(std::atan2(delta.y, delta.x));
-        m_viewAngles.roll = RollAngle::FromRadians(0.f);
+        m_view_angles.pitch = PitchAngle::from_radians(std::asin(delta.z / distance));
+        m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
+        m_view_angles.roll = RollAngle::from_radians(0.f);
     }
 
-    Mat4x4 Camera::CalcViewMatrix() const
+    Mat4X4 Camera::calc_view_matrix() const
     {
-        return source_engine::CalcViewMatrix(m_viewAngles, m_origin);
+        return source_engine::calc_view_matrix(m_view_angles, m_origin);
     }
 
-    Mat4x4 Camera::CalcProjectionMatrix() const
+    Mat4X4 Camera::calc_projection_matrix() const
     {
-        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
-                                               m_farPlaneDistance);
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
+                                                  m_near_plane_distance, m_far_plane_distance);
     }
-} // namespace omath::source
+} // namespace omath::source_engine

source/engines/source_engine/formulas.cpp

@@ -3,50 +3,49 @@
 //
 #include <omath/engines/source_engine/formulas.hpp>
 
-
 namespace omath::source_engine
 {
-    Vector3<float> ForwardVector(const ViewAngles& angles)
+    Vector3<float> forward_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsForward);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
 
-    Mat4x4 RotationMatrix(const ViewAngles& angles)
+    Mat4X4 rotation_matrix(const ViewAngles& angles)
     {
-        return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
+        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
     }
 
-    Vector3<float> RightVector(const ViewAngles& angles)
+    Vector3<float> right_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsRight);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Vector3<float> UpVector(const ViewAngles& angles)
+    Vector3<float> up_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsUp);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
 
-    Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
     {
-        return MatCameraView(ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
+        return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
     }
 
-    Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
-                                           const float far)
+    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
+                                              const float far)
     {
         // NOTE: Need magic number to fix fov calculation, since source inherit Quake proj matrix calculation
-        constexpr auto kMultiplyFactor = 0.75f;
+        constexpr auto k_multiply_factor = 0.75f;
 
-        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f) * kMultiplyFactor;
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
 
         return {
-                {1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
-                {0, 1.f / (fovHalfTan), 0, 0},
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
                 {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
                 {0, 0, 1, 0},
         };

source/engines/unity_engine/CMakeLists.txt

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

source/engines/unity_engine/camera.cpp

@@ -4,25 +4,24 @@
 #include <omath/engines/unity_engine/camera.hpp>
 #include <omath/engines/unity_engine/formulas.hpp>
 
-
 namespace omath::unity_engine
 {
-    Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
-                   const projection::FieldOfView& fov, const float near, const float far) :
-        projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
+    Camera::Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
+                   const projection::FieldOfView& fov, const float near, const float far)
+        : projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
     {
     }
-    void Camera::LookAt([[maybe_unused]] const Vector3<float>& target)
+    void Camera::look_at([[maybe_unused]] const Vector3<float>& target)
     {
         throw std::runtime_error("Not implemented");
     }
-    Mat4x4 Camera::CalcViewMatrix() const
+    Mat4X4 Camera::calc_view_matrix() const
     {
-        return unity_engine::CalcViewMatrix(m_viewAngles, m_origin);
+        return unity_engine::calc_view_matrix(m_view_angles, m_origin);
     }
-    Mat4x4 Camera::CalcProjectionMatrix() const
+    Mat4X4 Camera::calc_projection_matrix() const
     {
-        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
-                                               m_farPlaneDistance);
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
+                                                  m_near_plane_distance, m_far_plane_distance);
     }
 } // namespace omath::unity_engine

source/engines/unity_engine/formulas.cpp

@@ -3,47 +3,45 @@
 //
 #include "omath/engines/unity_engine/formulas.hpp"
 
-
-
 namespace omath::unity_engine
 {
-    Vector3<float> ForwardVector(const ViewAngles& angles)
+    Vector3<float> forward_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsForward);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Vector3<float> RightVector(const ViewAngles& angles)
+    Vector3<float> right_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsRight);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Vector3<float> UpVector(const ViewAngles& angles)
+    Vector3<float> up_vector(const ViewAngles& angles)
     {
-        const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsUp);
+        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)};
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
     {
-        return MatCameraView<float, MatStoreType::ROW_MAJOR>(ForwardVector(angles), -RightVector(angles),
-                                                             UpVector(angles), cam_origin);
+        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), -right_vector(angles),
+                                                               up_vector(angles), cam_origin);
     }
-    Mat4x4 RotationMatrix(const ViewAngles& angles)
+    Mat4X4 rotation_matrix(const ViewAngles& angles)
     {
-        return MatRotationAxisZ(angles.roll) *
-               MatRotationAxisY(angles.yaw) *
-               MatRotationAxisX(angles.pitch);
+        return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll);
     }
-    Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
-                                           const float far)
+    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
+                                              const float far)
     {
-        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
 
         return {
-                {1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
-                {0, 1.f / (fovHalfTan), 0, 0},
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
                 {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
                 {0, 0, -1.f, 0},
         };

source/matrix.cpp

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

source/pathfinding/CMakeLists.txt

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

source/pathfinding/a_star.cpp

@@ -2,96 +2,95 @@
 // Created by Vlad on 28.07.2024.
 //
 #include "omath/pathfinding/a_star.hpp"
-
 #include <algorithm>
 #include <optional>
 #include <unordered_map>
 #include <unordered_set>
 
-
 namespace omath::pathfinding
 {
     struct PathNode final
     {
-        std::optional<Vector3<float>> cameFrom;
-        float gCost = 0.f;
+        std::optional<Vector3<float>> came_from;
+        float g_cost = 0.f;
     };
 
-
-    std::vector<Vector3<float>> Astar::ReconstructFinalPath(const std::unordered_map<Vector3<float>, PathNode>& closedList,
-                                                     const Vector3<float>& current)
+    std::vector<Vector3<float>>
+    Astar::reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
+                                  const Vector3<float>& current)
     {
         std::vector<Vector3<float>> path;
-        std::optional currentOpt = current;
+        std::optional current_opt = current;
 
-        while (currentOpt)
+        while (current_opt)
         {
-            path.push_back(*currentOpt);
+            path.push_back(*current_opt);
 
-            auto it = closedList.find(*currentOpt);
+            auto it = closed_list.find(*current_opt);
 
-            if (it == closedList.end())
+            if (it == closed_list.end())
                 break;
 
-            currentOpt = it->second.cameFrom;
+            current_opt = it->second.came_from;
         }
 
         std::ranges::reverse(path);
         return path;
     }
-    auto Astar::GetPerfectNode(const std::unordered_map<Vector3<float>, PathNode>& openList, const Vector3<float>& endVertex)
+    auto Astar::get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
+                                 const Vector3<float>& end_vertex)
     {
-        return std::ranges::min_element(openList,
-                                        [&endVertex](const auto& a, const auto& b)
+        return std::ranges::min_element(open_list,
+                                        [&end_vertex](const auto& a, const auto& b)
                                         {
-                                            const float fA = a.second.gCost + a.first.DistTo(endVertex);
-                                            const float fB = b.second.gCost + b.first.DistTo(endVertex);
-                                            return fA < fB;
+                                            const float fa = a.second.g_cost + a.first.distance_to(end_vertex);
+                                            const float fb = b.second.g_cost + b.first.distance_to(end_vertex);
+                                            return fa < fb;
                                         });
     }
 
-    std::vector<Vector3<float>> Astar::FindPath(const Vector3<float>& start, const Vector3<float>& end, const NavigationMesh& navMesh)
+    std::vector<Vector3<float>> Astar::find_path(const Vector3<float>& start, const Vector3<float>& end,
+                                                 const NavigationMesh& nav_mesh)
     {
-        std::unordered_map<Vector3<float>, PathNode> closedList;
-        std::unordered_map<Vector3<float>, PathNode> openList;
+        std::unordered_map<Vector3<float>, PathNode> closed_list;
+        std::unordered_map<Vector3<float>, PathNode> open_list;
 
-        auto maybeStartVertex = navMesh.GetClosestVertex(start);
-        auto maybeEndVertex = navMesh.GetClosestVertex(end);
+        auto maybe_start_vertex = nav_mesh.get_closest_vertex(start);
+        auto maybe_end_vertex = nav_mesh.get_closest_vertex(end);
 
-        if (!maybeStartVertex || !maybeEndVertex)
+        if (!maybe_start_vertex || !maybe_end_vertex)
             return {};
 
-        const auto startVertex = maybeStartVertex.value();
-        const auto endVertex = maybeEndVertex.value();
+        const auto start_vertex = maybe_start_vertex.value();
+        const auto end_vertex = maybe_end_vertex.value();
 
+        open_list.emplace(start_vertex, PathNode{std::nullopt, 0.f});
 
-        openList.emplace(startVertex, PathNode{std::nullopt, 0.f});
-
-        while (!openList.empty())
+        while (!open_list.empty())
         {
-            auto currentIt = GetPerfectNode(openList, endVertex);
+            auto current_it = get_perfect_node(open_list, end_vertex);
 
-            const auto current = currentIt->first;
-            const auto currentNode = currentIt->second;
+            const auto current = current_it->first;
+            const auto current_node = current_it->second;
 
-            if (current == endVertex)
-                return ReconstructFinalPath(closedList, current);
+            if (current == end_vertex)
+                return reconstruct_final_path(closed_list, current);
 
+            closed_list.emplace(current, current_node);
+            open_list.erase(current_it);
 
-            closedList.emplace(current, currentNode);
-            openList.erase(currentIt);
-
-            for (const auto& neighbor: navMesh.GetNeighbors(current))
+            for (const auto& neighbor: nav_mesh.get_neighbors(current))
             {
-                if (closedList.contains(neighbor))
+                if (closed_list.contains(neighbor))
                     continue;
 
-                const float tentativeGCost = currentNode.gCost + neighbor.DistTo(current);
+                const float tentative_g_cost = current_node.g_cost + neighbor.distance_to(current);
 
-                const auto openIt = openList.find(neighbor);
+                // ReSharper disable once CppTooWideScopeInitStatement
+                const auto open_it = open_list.find(neighbor);
 
-                if (openIt == openList.end() || tentativeGCost < openIt->second.gCost)
-                    openList[neighbor] = PathNode{current, tentativeGCost};
+                if (open_it == open_list.end() || tentative_g_cost < open_it->second.g_cost)
+                    open_list[neighbor] = PathNode{current, tentative_g_cost};
             }
         }
 

source/pathfinding/navigation_mesh.cpp

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

source/projectile_prediction/CMakeLists.txt

@@ -1 +0,0 @@
-target_sources(omath PRIVATE proj_pred_engine_legacy.cpp projectile.cpp target.cpp proj_pred_engine_avx2.cpp proj_pred_engine.cpp)

source/projectile_prediction/proj_pred_engine.cpp

@@ -3,7 +3,6 @@
 //
 #include "omath/projectile_prediction/proj_pred_engine.hpp"
 
-
 namespace omath::projectile_prediction
 {
 

source/projectile_prediction/proj_pred_engine_avx2.cpp

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

source/projectile_prediction/proj_pred_engine_legacy.cpp

@@ -4,65 +4,67 @@
 
 namespace omath::projectile_prediction
 {
-    ProjPredEngineLegacy::ProjPredEngineLegacy(const float gravityConstant, const float simulationTimeStep,
-                                               const float maximumSimulationTime, const float distanceTolerance) :
-        m_gravityConstant(gravityConstant), m_simulationTimeStep(simulationTimeStep),
-        m_maximumSimulationTime(maximumSimulationTime), m_distanceTolerance(distanceTolerance)
+    ProjPredEngineLegacy::ProjPredEngineLegacy(const float gravity_constant, const float simulation_time_step,
+                                               const float maximum_simulation_time, const float distance_tolerance)
+        : m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),
+          m_maximum_simulation_time(maximum_simulation_time), m_distance_tolerance(distance_tolerance)
     {
     }
 
-    std::optional<Vector3<float>> ProjPredEngineLegacy::MaybeCalculateAimPoint(const Projectile& projectile,
-                                                                        const Target& target) const
+    std::optional<Vector3<float>> ProjPredEngineLegacy::maybe_calculate_aim_point(const Projectile& projectile,
+                                                                                  const Target& target) const
     {
-        for (float time = 0.f; time < m_maximumSimulationTime; time += m_simulationTimeStep)
+        for (float time = 0.f; time < m_maximum_simulation_time; time += m_simulation_time_step)
         {
-            const auto predictedTargetPosition = target.PredictPosition(time, m_gravityConstant);
+            const auto predicted_target_position = target.predict_position(time, m_gravity_constant);
 
-            const auto projectilePitch = MaybeCalculateProjectileLaunchPitchAngle(projectile, predictedTargetPosition);
+            const auto projectile_pitch
+                    = maybe_calculate_projectile_launch_pitch_angle(projectile, predicted_target_position);
 
-            if (!projectilePitch.has_value()) [[unlikely]]
+            if (!projectile_pitch.has_value()) [[unlikely]]
                 continue;
 
-            if (!IsProjectileReachedTarget(predictedTargetPosition, projectile, projectilePitch.value(), time))
+            if (!is_projectile_reached_target(predicted_target_position, projectile, projectile_pitch.value(), time))
                 continue;
 
-            const auto delta2d = (predictedTargetPosition - projectile.m_origin).Length2D();
-            const auto height = delta2d * std::tan(angles::DegreesToRadians(projectilePitch.value()));
+            const auto delta2d = (predicted_target_position - projectile.m_origin).length_2d();
+            const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
 
-            return Vector3(predictedTargetPosition.x, predictedTargetPosition.y, projectile.m_origin.z + height);
+            return Vector3(predicted_target_position.x, predicted_target_position.y, projectile.m_origin.z + height);
         }
         return std::nullopt;
     }
 
     std::optional<float>
-    ProjPredEngineLegacy::MaybeCalculateProjectileLaunchPitchAngle(const Projectile& projectile,
-                                                                   const Vector3<float>& targetPosition) const
+    ProjPredEngineLegacy::maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
+                                                                        const Vector3<float>& target_position) const
     {
-        const auto bulletGravity = m_gravityConstant * projectile.m_gravityScale;
-        const auto delta = targetPosition - projectile.m_origin;
+        const auto bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
+        const auto delta = target_position - projectile.m_origin;
 
-        const auto distance2d = delta.Length2D();
-        const auto distance2dSqr = distance2d * distance2d;
-        const auto launchSpeedSqr = projectile.m_launchSpeed * projectile.m_launchSpeed;
+        const auto distance2d = delta.length_2d();
+        const auto distance2d_sqr = distance2d * distance2d;
+        const auto launch_speed_sqr = projectile.m_launch_speed * projectile.m_launch_speed;
 
-        float root = launchSpeedSqr * launchSpeedSqr -
-                     bulletGravity * (bulletGravity * distance2dSqr + 2.0f * delta.z * launchSpeedSqr);
+        float root = launch_speed_sqr * launch_speed_sqr
+                     - bullet_gravity * (bullet_gravity * distance2d_sqr + 2.0f * delta.z * launch_speed_sqr);
 
         if (root < 0.0f) [[unlikely]]
             return std::nullopt;
 
         root = std::sqrt(root);
-        const float angle = std::atan((launchSpeedSqr - root) / (bulletGravity * distance2d));
+        const float angle = std::atan((launch_speed_sqr - root) / (bullet_gravity * distance2d));
 
-        return angles::RadiansToDegrees(angle);
+        return angles::radians_to_degrees(angle);
     }
 
-    bool ProjPredEngineLegacy::IsProjectileReachedTarget(const Vector3<float>& targetPosition, const Projectile& projectile,
-                                                         const float pitch, const float time) const
+    bool ProjPredEngineLegacy::is_projectile_reached_target(const Vector3<float>& target_position,
+                                                            const Projectile& projectile, const float pitch,
+                                                            const float time) const
     {
-        const auto yaw = projectile.m_origin.ViewAngleTo(targetPosition).y;
-        const auto projectilePosition = projectile.PredictPosition(pitch, yaw, time, m_gravityConstant);
+        const auto yaw = projectile.m_origin.view_angle_to(target_position).y;
+        const auto projectile_position = projectile.predict_position(pitch, yaw, time, m_gravity_constant);
 
-        return projectilePosition.DistTo(targetPosition) <= m_distanceTolerance;
+        return projectile_position.distance_to(target_position) <= m_distance_tolerance;
     }
 } // namespace omath::projectile_prediction

source/projectile_prediction/projectile.cpp

@@ -3,19 +3,20 @@
 //
 
 #include "omath/projectile_prediction/projectile.hpp"
-
 #include <omath/engines/source_engine/formulas.hpp>
 
 namespace omath::projectile_prediction
 {
-    Vector3<float> Projectile::PredictPosition(const float pitch, const float yaw, const float time, const float gravity) const
+    Vector3<float> Projectile::predict_position(const float pitch, const float yaw, const float time,
+                                                const float gravity) const
     {
-        auto currentPos = m_origin + source_engine::ForwardVector({source_engine::PitchAngle::FromDegrees(-pitch),
-                                                            source_engine::YawAngle::FromDegrees(yaw),
-                                                            source_engine::RollAngle::FromDegrees(0)}) *
-                                             m_launchSpeed * time;
-        currentPos.z -= (gravity * m_gravityScale) * (time * time) * 0.5f;
+        auto current_pos = m_origin
+                           + source_engine::forward_vector({source_engine::PitchAngle::from_degrees(-pitch),
+                                                            source_engine::YawAngle::from_degrees(yaw),
+                                                            source_engine::RollAngle::from_degrees(0)})
+                                     * m_launch_speed * time;
+        current_pos.z -= (gravity * m_gravity_scale) * (time * time) * 0.5f;
 
-        return currentPos;
+        return current_pos;
     }
-} // namespace omath::prediction
+} // namespace omath::projectile_prediction

source/projectile_prediction/target.cpp

@@ -4,7 +4,6 @@
 
 #include "omath/projectile_prediction/projectile.hpp"
 
-
 namespace omath::prediction
 {
 

source/projection/CMakeLists.txt

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

source/projection/camera.cpp

@@ -3,7 +3,6 @@
 //
 #include "omath/projection/camera.hpp"
 
-
 namespace omath::projection
 {
 }

tests/CMakeLists.txt

@@ -1,41 +1,22 @@
 enable_testing()
 
-project(unit-tests)
+project(unit_tests)
 
 include(GoogleTest)
-add_executable(unit-tests
-        general/unit_test_prediction.cpp
-        general/unit_test_matrix.cpp
-        general/unit_test_mat.cpp
-        general/unit_test_a_star.cpp
-        general/unit_test_projection.cpp
-        general/unit_test_vector3.cpp
-        general/unit_test_vector2.cpp
-        general/unit_test_color.cpp
-        general/unit_test_vector4.cpp
-        general/unit_test_line_trace.cpp
-        general/unit_test_angles.cpp
-        general/unit_test_view_angles.cpp
-        general/unit_test_angle.cpp
-        general/unit_test_triangle.cpp
-        general/unit_test_box_primitive.cpp
 
-        engines/unit_test_open_gl.cpp
-        engines/unit_test_unity_engine.cpp
-        engines/unit_test_source_engine.cpp
-        engines/unit_test_iw_engine.cpp
+file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
+add_executable(unit_tests ${UNIT_TESTS_SOURCES})
 
-)
-
-set_target_properties(unit-tests PROPERTIES
+set_target_properties(unit_tests PROPERTIES
         ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
         UNITY_BUILD ON
         UNITY_BUILD_BATCH_SIZE 20
         CXX_STANDARD 23
         CXX_STANDARD_REQUIRED ON)
 
 
-target_link_libraries(unit-tests PRIVATE gtest gtest_main omath::omath)
+target_link_libraries(unit_tests PRIVATE gtest gtest_main omath::omath)
 
-gtest_discover_tests(unit-tests)
+gtest_discover_tests(unit_tests)

tests/engines/unit_test_iw_engine.cpp

@@ -9,69 +9,69 @@
 
 TEST(UnitTestIwEngine, ForwardVector)
 {
-    const auto forward = omath::iw_engine::ForwardVector({});
+    const auto forward = omath::iw_engine::forward_vector({});
 
-    EXPECT_EQ(forward, omath::iw_engine::kAbsForward);
+    EXPECT_EQ(forward, omath::iw_engine::k_abs_forward);
 }
 
 TEST(UnitTestIwEngine, RightVector)
 {
-    const auto right = omath::iw_engine::RightVector({});
+    const auto right = omath::iw_engine::right_vector({});
 
-    EXPECT_EQ(right, omath::iw_engine::kAbsRight);
+    EXPECT_EQ(right, omath::iw_engine::k_abs_right);
 }
 
 TEST(UnitTestIwEngine, UpVector)
 {
-    const auto up = omath::iw_engine::UpVector({});
-    EXPECT_EQ(up, omath::iw_engine::kAbsUp);
+    const auto up = omath::iw_engine::up_vector({});
+    EXPECT_EQ(up, omath::iw_engine::k_abs_up);
 }
 
 TEST(UnitTestIwEngine, ForwardVectorRotationYaw)
 {
     omath::iw_engine::ViewAngles angles;
 
-    angles.yaw = omath::iw_engine::YawAngle::FromDegrees(-90.f);
+    angles.yaw = omath::iw_engine::YawAngle::from_degrees(-90.f);
 
-    const auto forward = omath::iw_engine::ForwardVector(angles);
-    EXPECT_NEAR(forward.x, omath::iw_engine::kAbsRight.x, 0.00001f);
-    EXPECT_NEAR(forward.y, omath::iw_engine::kAbsRight.y, 0.00001f);
-    EXPECT_NEAR(forward.z, omath::iw_engine::kAbsRight.z, 0.00001f);
+    const auto forward = omath::iw_engine::forward_vector(angles);
+    EXPECT_NEAR(forward.x, omath::iw_engine::k_abs_right.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::iw_engine::k_abs_right.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_right.z, 0.00001f);
 }
 
 TEST(UnitTestIwEngine, ForwardVectorRotationPitch)
 {
     omath::iw_engine::ViewAngles angles;
 
-    angles.pitch = omath::iw_engine::PitchAngle::FromDegrees(-89.f);
+    angles.pitch = omath::iw_engine::PitchAngle::from_degrees(-89.f);
 
-    const auto forward = omath::iw_engine::ForwardVector(angles);
-    EXPECT_NEAR(forward.x, omath::iw_engine::kAbsUp.x, 0.02f);
-    EXPECT_NEAR(forward.y, omath::iw_engine::kAbsUp.y, 0.01f);
-    EXPECT_NEAR(forward.z, omath::iw_engine::kAbsUp.z, 0.01f);
+    const auto forward = omath::iw_engine::forward_vector(angles);
+    EXPECT_NEAR(forward.x, omath::iw_engine::k_abs_up.x, 0.02f);
+    EXPECT_NEAR(forward.y, omath::iw_engine::k_abs_up.y, 0.01f);
+    EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_up.z, 0.01f);
 }
 
 TEST(UnitTestIwEngine, ForwardVectorRotationRoll)
 {
     omath::iw_engine::ViewAngles angles;
 
-    angles.roll = omath::iw_engine::RollAngle::FromDegrees(90.f);
+    angles.roll = omath::iw_engine::RollAngle::from_degrees(90.f);
 
-    const auto forward = omath::iw_engine::UpVector(angles);
-    EXPECT_NEAR(forward.x, omath::iw_engine::kAbsRight.x, 0.00001f);
-    EXPECT_NEAR(forward.y, omath::iw_engine::kAbsRight.y, 0.00001f);
-    EXPECT_NEAR(forward.z, omath::iw_engine::kAbsRight.z, 0.00001f);
+    const auto forward = omath::iw_engine::up_vector(angles);
+    EXPECT_NEAR(forward.x, omath::iw_engine::k_abs_right.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::iw_engine::k_abs_right.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_right.z, 0.00001f);
 }
 
 TEST(UnitTestIwEngine, ProjectTargetMovedFromCamera)
 {
-    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     const auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
 
     for (float distance = 0.02f; distance < 1000.f; distance += 0.01f)
     {
-        const auto projected = cam.WorldToScreen({distance, 0, 0});
+        const auto projected = cam.world_to_screen({distance, 0, 0});
 
         EXPECT_TRUE(projected.has_value());
 
@@ -85,21 +85,21 @@ TEST(UnitTestIwEngine, ProjectTargetMovedFromCamera)
 
 TEST(UnitTestIwEngine, CameraSetAndGetFov)
 {
-    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
-    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
+    cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }
 
 TEST(UnitTestIwEngine, CameraSetAndGetOrigin)
 {
     auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 
-    EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
-    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+    EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
+    cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }

tests/engines/unit_test_open_gl.cpp

@@ -9,32 +9,32 @@
 
 TEST(UnitTestOpenGL, ForwardVector)
 {
-    const auto forward = omath::opengl_engine::ForwardVector({});
-    EXPECT_EQ(forward, omath::opengl_engine::kAbsForward);
+    const auto forward = omath::opengl_engine::forward_vector({});
+    EXPECT_EQ(forward, omath::opengl_engine::k_abs_forward);
 }
 
 TEST(UnitTestOpenGL, RightVector)
 {
-    const auto right = omath::opengl_engine::RightVector({});
-    EXPECT_EQ(right, omath::opengl_engine::kAbsRight);
+    const auto right = omath::opengl_engine::right_vector({});
+    EXPECT_EQ(right, omath::opengl_engine::k_abs_right);
 }
 
 TEST(UnitTestOpenGL, UpVector)
 {
-    const auto up = omath::opengl_engine::UpVector({});
-    EXPECT_EQ(up, omath::opengl_engine::kAbsUp);
+    const auto up = omath::opengl_engine::up_vector({});
+    EXPECT_EQ(up, omath::opengl_engine::k_abs_up);
 }
 
 TEST(UnitTestOpenGL, ForwardVectorRotationYaw)
 {
     omath::opengl_engine::ViewAngles angles;
 
-    angles.yaw = omath::opengl_engine::YawAngle::FromDegrees(90.f);
+    angles.yaw = omath::opengl_engine::YawAngle::from_degrees(90.f);
 
-    const auto forward = omath::opengl_engine::ForwardVector(angles);
-    EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsRight.x, 0.00001f);
-    EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsRight.y, 0.00001f);
-    EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsRight.z, 0.00001f);
+    const auto forward = omath::opengl_engine::forward_vector(angles);
+    EXPECT_NEAR(forward.x, omath::opengl_engine::k_abs_right.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::opengl_engine::k_abs_right.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_right.z, 0.00001f);
 }
 
 
@@ -43,35 +43,35 @@ TEST(UnitTestOpenGL, ForwardVectorRotationPitch)
 {
     omath::opengl_engine::ViewAngles angles;
 
-    angles.pitch = omath::opengl_engine::PitchAngle::FromDegrees(-90.f);
+    angles.pitch = omath::opengl_engine::PitchAngle::from_degrees(-90.f);
 
-    const auto forward = omath::opengl_engine::ForwardVector(angles);
-    EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsUp.x, 0.00001f);
-    EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsUp.y, 0.00001f);
-    EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsUp.z, 0.00001f);
+    const auto forward = omath::opengl_engine::forward_vector(angles);
+    EXPECT_NEAR(forward.x, omath::opengl_engine::k_abs_up.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::opengl_engine::k_abs_up.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_up.z, 0.00001f);
 }
 
 TEST(UnitTestOpenGL, ForwardVectorRotationRoll)
 {
     omath::opengl_engine::ViewAngles angles;
 
-    angles.roll = omath::opengl_engine::RollAngle::FromDegrees(-90.f);
+    angles.roll = omath::opengl_engine::RollAngle::from_degrees(-90.f);
 
-    const auto forward = omath::opengl_engine::UpVector(angles);
-    EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsRight.x, 0.00001f);
-    EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsRight.y, 0.00001f);
-    EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsRight.z, 0.00001f);
+    const auto forward = omath::opengl_engine::up_vector(angles);
+    EXPECT_NEAR(forward.x, omath::opengl_engine::k_abs_right.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::opengl_engine::k_abs_right.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_right.z, 0.00001f);
 }
 
 TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
 {
-    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     const auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
 
     for (float distance = -10.f; distance > -1000.f; distance -= 0.01f)
     {
-        const auto projected = cam.WorldToScreen({0, 0, distance});
+        const auto projected = cam.world_to_screen({0, 0, distance});
 
         EXPECT_TRUE(projected.has_value());
 
@@ -85,21 +85,21 @@ TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
 
 TEST(UnitTestOpenGL, CameraSetAndGetFov)
 {
-    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
-    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
+    cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }
 
 TEST(UnitTestOpenGL, CameraSetAndGetOrigin)
 {
     auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 
-    EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
-    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+    EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
+    cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }

tests/engines/unit_test_source_engine.cpp

@@ -9,69 +9,69 @@
 
 TEST(UnitTestSourceEngine, ForwardVector)
 {
-    const auto forward = omath::source_engine::ForwardVector({});
+    const auto forward = omath::source_engine::forward_vector({});
 
-    EXPECT_EQ(forward, omath::source_engine::kAbsForward);
+    EXPECT_EQ(forward, omath::source_engine::k_abs_forward);
 }
 
 TEST(UnitTestSourceEngine, RightVector)
 {
-    const auto right = omath::source_engine::RightVector({});
+    const auto right = omath::source_engine::right_vector({});
 
-    EXPECT_EQ(right, omath::source_engine::kAbsRight);
+    EXPECT_EQ(right, omath::source_engine::k_abs_right);
 }
 
 TEST(UnitTestSourceEngine, UpVector)
 {
-    const auto up = omath::source_engine::UpVector({});
-    EXPECT_EQ(up, omath::source_engine::kAbsUp);
+    const auto up = omath::source_engine::up_vector({});
+    EXPECT_EQ(up, omath::source_engine::k_abs_up);
 }
 
 TEST(UnitTestSourceEngine, ForwardVectorRotationYaw)
 {
     omath::source_engine::ViewAngles angles;
 
-    angles.yaw = omath::source_engine::YawAngle::FromDegrees(-90.f);
+    angles.yaw = omath::source_engine::YawAngle::from_degrees(-90.f);
 
-    const auto forward = omath::source_engine::ForwardVector(angles);
-    EXPECT_NEAR(forward.x, omath::source_engine::kAbsRight.x, 0.00001f);
-    EXPECT_NEAR(forward.y, omath::source_engine::kAbsRight.y, 0.00001f);
-    EXPECT_NEAR(forward.z, omath::source_engine::kAbsRight.z, 0.00001f);
+    const auto forward = omath::source_engine::forward_vector(angles);
+    EXPECT_NEAR(forward.x, omath::source_engine::k_abs_right.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::source_engine::k_abs_right.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::source_engine::k_abs_right.z, 0.00001f);
 }
 
 TEST(UnitTestSourceEngine, ForwardVectorRotationPitch)
 {
     omath::source_engine::ViewAngles angles;
 
-    angles.pitch = omath::source_engine::PitchAngle::FromDegrees(-89.f);
+    angles.pitch = omath::source_engine::PitchAngle::from_degrees(-89.f);
 
-    const auto forward = omath::source_engine::ForwardVector(angles);
-    EXPECT_NEAR(forward.x, omath::source_engine::kAbsUp.x, 0.02f);
-    EXPECT_NEAR(forward.y, omath::source_engine::kAbsUp.y, 0.01f);
-    EXPECT_NEAR(forward.z, omath::source_engine::kAbsUp.z, 0.01f);
+    const auto forward = omath::source_engine::forward_vector(angles);
+    EXPECT_NEAR(forward.x, omath::source_engine::k_abs_up.x, 0.02f);
+    EXPECT_NEAR(forward.y, omath::source_engine::k_abs_up.y, 0.01f);
+    EXPECT_NEAR(forward.z, omath::source_engine::k_abs_up.z, 0.01f);
 }
 
 TEST(UnitTestSourceEngine, ForwardVectorRotationRoll)
 {
     omath::source_engine::ViewAngles angles;
 
-    angles.roll = omath::source_engine::RollAngle::FromDegrees(90.f);
+    angles.roll = omath::source_engine::RollAngle::from_degrees(90.f);
 
-    const auto forward = omath::source_engine::UpVector(angles);
-    EXPECT_NEAR(forward.x, omath::source_engine::kAbsRight.x, 0.00001f);
-    EXPECT_NEAR(forward.y, omath::source_engine::kAbsRight.y, 0.00001f);
-    EXPECT_NEAR(forward.z, omath::source_engine::kAbsRight.z, 0.00001f);
+    const auto forward = omath::source_engine::up_vector(angles);
+    EXPECT_NEAR(forward.x, omath::source_engine::k_abs_right.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::source_engine::k_abs_right.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::source_engine::k_abs_right.z, 0.00001f);
 }
 
 TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
 {
-    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
 
     for (float distance = 0.02f; distance < 1000.f; distance += 0.01f)
     {
-        const auto projected = cam.WorldToScreen({distance, 0, 0});
+        const auto projected = cam.world_to_screen({distance, 0, 0});
 
         EXPECT_TRUE(projected.has_value());
 
@@ -85,13 +85,13 @@ TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
 
 TEST(UnitTestSourceEngine, ProjectTargetMovedUp)
 {
-    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     auto prev = 1080.f;
     for (float distance = 0.0f; distance < 10.f; distance += 1.f)
     {
-        const auto projected = cam.WorldToScreen({100.f, 0, distance});
+        const auto projected = cam.world_to_screen({100.f, 0, distance});
         EXPECT_TRUE(projected.has_value());
 
         if (!projected.has_value())
@@ -105,21 +105,21 @@ TEST(UnitTestSourceEngine, ProjectTargetMovedUp)
 
 TEST(UnitTestSourceEngine, CameraSetAndGetFov)
 {
-    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
-    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
+    cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }
 
 TEST(UnitTestSourceEngine, CameraSetAndGetOrigin)
 {
     auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 
-    EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
-    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+    EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
+    cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }

tests/engines/unit_test_unity_engine.cpp

@@ -5,73 +5,73 @@
 #include <omath/engines/unity_engine/camera.hpp>
 #include <omath/engines/unity_engine/constants.hpp>
 #include <omath/engines/unity_engine/formulas.hpp>
-
+#include <print>
 
 TEST(UnitTestUnityEngine, ForwardVector)
 {
-    const auto forward = omath::unity_engine::ForwardVector({});
+    const auto forward = omath::unity_engine::forward_vector({});
 
-    EXPECT_EQ(forward, omath::unity_engine::kAbsForward);
+    EXPECT_EQ(forward, omath::unity_engine::k_abs_forward);
 }
 
 TEST(UnitTestUnityEngine, ForwardVectorRotationYaw)
 {
     omath::unity_engine::ViewAngles angles;
 
-    angles.yaw = omath::unity_engine::YawAngle::FromDegrees(90.f);
+    angles.yaw = omath::unity_engine::YawAngle::from_degrees(90.f);
 
-    const auto forward = omath::unity_engine::ForwardVector(angles);
-    EXPECT_NEAR(forward.x, omath::unity_engine::kAbsRight.x, 0.00001f);
-    EXPECT_NEAR(forward.y, omath::unity_engine::kAbsRight.y, 0.00001f);
-    EXPECT_NEAR(forward.z, omath::unity_engine::kAbsRight.z, 0.00001f);
+    const auto forward = omath::unity_engine::forward_vector(angles);
+    EXPECT_NEAR(forward.x, omath::unity_engine::k_abs_right.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::unity_engine::k_abs_right.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_right.z, 0.00001f);
 }
 
 TEST(UnitTestUnityEngine, ForwardVectorRotationPitch)
 {
     omath::unity_engine::ViewAngles angles;
 
-    angles.pitch = omath::unity_engine::PitchAngle::FromDegrees(-90.f);
+    angles.pitch = omath::unity_engine::PitchAngle::from_degrees(-90.f);
 
-    const auto forward = omath::unity_engine::ForwardVector(angles);
-    EXPECT_NEAR(forward.x, omath::unity_engine::kAbsUp.x, 0.00001f);
-    EXPECT_NEAR(forward.y, omath::unity_engine::kAbsUp.y, 0.00001f);
-    EXPECT_NEAR(forward.z, omath::unity_engine::kAbsUp.z, 0.00001f);
+    const auto forward = omath::unity_engine::forward_vector(angles);
+    EXPECT_NEAR(forward.x, omath::unity_engine::k_abs_up.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::unity_engine::k_abs_up.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_up.z, 0.00001f);
 }
 
 TEST(UnitTestUnityEngine, ForwardVectorRotationRoll)
 {
     omath::unity_engine::ViewAngles angles;
 
-    angles.roll = omath::unity_engine::RollAngle::FromDegrees(-90.f);
+    angles.roll = omath::unity_engine::RollAngle::from_degrees(-90.f);
 
-    const auto forward = omath::unity_engine::UpVector(angles);
-    EXPECT_NEAR(forward.x, omath::unity_engine::kAbsRight.x, 0.00001f);
-    EXPECT_NEAR(forward.y, omath::unity_engine::kAbsRight.y, 0.00001f);
-    EXPECT_NEAR(forward.z, omath::unity_engine::kAbsRight.z, 0.00001f);
+    const auto forward = omath::unity_engine::up_vector(angles);
+    EXPECT_NEAR(forward.x, omath::unity_engine::k_abs_right.x, 0.00001f);
+    EXPECT_NEAR(forward.y, omath::unity_engine::k_abs_right.y, 0.00001f);
+    EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_right.z, 0.00001f);
 }
 
 TEST(UnitTestUnityEngine, RightVector)
 {
-    const auto right = omath::unity_engine::RightVector({});
+    const auto right = omath::unity_engine::right_vector({});
 
-    EXPECT_EQ(right, omath::unity_engine::kAbsRight);
+    EXPECT_EQ(right, omath::unity_engine::k_abs_right);
 }
 
 TEST(UnitTestUnityEngine, UpVector)
 {
-    const auto up = omath::unity_engine::UpVector({});
-    EXPECT_EQ(up, omath::unity_engine::kAbsUp);
+    const auto up = omath::unity_engine::up_vector({});
+    EXPECT_EQ(up, omath::unity_engine::k_abs_up);
 }
 
 TEST(UnitTestUnityEngine, ProjectTargetMovedFromCamera)
 {
-    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(60.f);
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
     const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.01f, 1000.f);
 
 
     for (float distance = 0.02f; distance < 100.f; distance += 0.01f)
     {
-        const auto projected = cam.WorldToScreen({0, 0, distance});
+        const auto projected = cam.world_to_screen({0, 0, distance});
 
         EXPECT_TRUE(projected.has_value());
 
@@ -84,30 +84,30 @@ TEST(UnitTestUnityEngine, ProjectTargetMovedFromCamera)
 }
 TEST(UnitTestUnityEngine, Project)
 {
-    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(60.f);
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
 
     const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
-    const auto proj = cam.WorldToScreen({5.f, 3, 10.f});
+    const auto proj = cam.world_to_screen({5.f, 3, 10.f});
     std::println("{} {}", proj->x, proj->y);
 }
 
 TEST(UnitTestUnityEngine, CameraSetAndGetFov)
 {
-    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
-    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
+    cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }
 
 TEST(UnitTestUnityEngine, CameraSetAndGetOrigin)
 {
     auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 
-    EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
-    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+    EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
+    cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
-    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }

tests/general/unit_test_a_star.cpp

@@ -4,14 +4,13 @@
 #include <gtest/gtest.h>
 #include <omath/pathfinding/a_star.hpp>
 
-
-TEST(UnitTestAstar, FindingRightPath)
+TEST(unit_test_a_star, finding_right_path)
 {
     omath::pathfinding::NavigationMesh mesh;
 
-    mesh.m_verTextMap[{0.f, 0.f, 0.f}] = {{0.f, 1.f, 0.f}};
-    mesh.m_verTextMap[{0.f, 1.f, 0.f}] = {{0.f, 2.f, 0.f}};
-    mesh.m_verTextMap[{0.f, 2.f, 0.f}] = {{0.f, 3.f, 0.f}};
-    mesh.m_verTextMap[{0.f, 3.f, 0.f}] = {};
-    std::ignore = omath::pathfinding::Astar::FindPath({}, {0.f, 3.f, 0.f}, mesh);
+    mesh.m_vertex_map[{0.f, 0.f, 0.f}] = {{0.f, 1.f, 0.f}};
+    mesh.m_vertex_map[{0.f, 1.f, 0.f}] = {{0.f, 2.f, 0.f}};
+    mesh.m_vertex_map[{0.f, 2.f, 0.f}] = {{0.f, 3.f, 0.f}};
+    mesh.m_vertex_map[{0.f, 3.f, 0.f}] = {};
+    std::ignore = omath::pathfinding::Astar::find_path({}, {0.f, 3.f, 0.f}, mesh);
 }

tests/general/unit_test_angles.cpp

@@ -4,46 +4,46 @@
 #include <gtest/gtest.h>
 #include <omath/angles.hpp>
 
-TEST(UnitTestAngles, RadiansToDeg)
+TEST(unit_test_angles, radians_to_deg)
 {
     constexpr float rad = 67;
 
-    EXPECT_NEAR(omath::angles::RadiansToDegrees(rad), 3838.82f, 0.01f);
+    EXPECT_NEAR(omath::angles::radians_to_degrees(rad), 3838.82f, 0.01f);
 }
 
-TEST(UnitTestAngles, DegreesToRadians)
+TEST(unit_test_angles, degrees_to_radians)
 {
     constexpr float degree = 90;
 
-    EXPECT_NEAR(omath::angles::DegreesToRadians(degree), 1.5708f, 0.01f);
+    EXPECT_NEAR(omath::angles::degrees_to_radians(degree), 1.5708f, 0.01f);
 }
 
-TEST(UnitTestAngles, HorizontalFovToVerical)
+TEST(unit_test_angles, horizontal_fov_to_verical)
 {
     constexpr float hFov = 90;
     constexpr float aspectRation = 16.0f / 9.0f;
-    const auto verticalFov = omath::angles::HorizontalFovToVertical(hFov, aspectRation);
+    const auto verticalFov = omath::angles::horizontal_fov_to_vertical(hFov, aspectRation);
 
     EXPECT_NEAR(verticalFov, 58.71f, 0.01f);
 }
 
-TEST(UnitTestAngles, VerticalToHorizontal)
+TEST(unit_test_angles, vertical_to_horizontal)
 {
     constexpr float vFov = 58.71;
     constexpr float aspectRation = 16.0f / 9.0f;
-    const auto horizontalFov = omath::angles::VerticalFovToHorizontal(vFov, aspectRation);
+    const auto horizontalFov = omath::angles::vertical_fov_to_horizontal(vFov, aspectRation);
 
     EXPECT_NEAR(horizontalFov, 89.99f, 0.01f);
 }
-TEST(UnitTestAngles, WrapAngle)
+TEST(unit_test_angles, wrap_angle)
 {
-    const float wrapped = omath::angles::WrapAngle(361.f, 0.f, 360.f);
+    const float wrapped = omath::angles::wrap_angle(361.f, 0.f, 360.f);
 
     EXPECT_NEAR(wrapped, 1.f, 0.01f);
 }
-TEST(UnitTestAngles, WrapAngleNegativeRange)
+TEST(unit_test_angles, wrap_angle_negative_range)
 {
-    const float wrapped = omath::angles::WrapAngle(-90.f, 0.f, 360.f);
+    const float wrapped = omath::angles::wrap_angle(-90.f, 0.f, 360.f);
 
     EXPECT_NEAR(wrapped, 270.f, 0.01f);
 }

tests/general/unit_test_color.cpp

@@ -15,8 +15,8 @@ protected:
 
     void SetUp() override
     {
-        color1 = Color::Red();
-        color2 = Color::Green();
+        color1 = Color::red();
+        color2 = Color::green();
     }
 };
 
@@ -43,7 +43,7 @@ TEST_F(UnitTestColor, Constructor_Vector4)
 // Test static methods for color creation
 TEST_F(UnitTestColor, FromRGBA)
 {
-    constexpr Color color = Color::FromRGBA(128, 64, 32, 255);
+    constexpr Color color = Color::from_rgba(128, 64, 32, 255);
     EXPECT_FLOAT_EQ(color.x, 128.0f / 255.0f);
     EXPECT_FLOAT_EQ(color.y, 64.0f / 255.0f);
     EXPECT_FLOAT_EQ(color.z, 32.0f / 255.0f);
@@ -52,7 +52,7 @@ TEST_F(UnitTestColor, FromRGBA)
 
 TEST_F(UnitTestColor, FromHSV)
 {
-    constexpr Color color = Color::FromHSV(0.0f, 1.0f, 1.0f); // Red in HSV
+    constexpr Color color = Color::from_hsv(0.0f, 1.0f, 1.0f); // Red in HSV
     EXPECT_FLOAT_EQ(color.x, 1.0f);
     EXPECT_FLOAT_EQ(color.y, 0.0f);
     EXPECT_FLOAT_EQ(color.z, 0.0f);
@@ -62,7 +62,7 @@ TEST_F(UnitTestColor, FromHSV)
 // Test HSV conversion
 TEST_F(UnitTestColor, ToHSV)
 {
-    HSV hsv = color1.ToHSV(); // Red color
+    Hsv hsv = color1.to_hsv(); // Red color
     EXPECT_FLOAT_EQ(hsv.hue, 0.0f);
     EXPECT_FLOAT_EQ(hsv.saturation, 1.0f);
     EXPECT_FLOAT_EQ(hsv.value, 1.0f);
@@ -71,7 +71,7 @@ TEST_F(UnitTestColor, ToHSV)
 // Test color blending
 TEST_F(UnitTestColor, Blend)
 {
-    Color blended = color1.Blend(color2, 0.5f);
+    Color blended = color1.blend(color2, 0.5f);
     EXPECT_FLOAT_EQ(blended.x, 0.5f);
     EXPECT_FLOAT_EQ(blended.y, 0.5f);
     EXPECT_FLOAT_EQ(blended.z, 0.0f);
@@ -81,9 +81,9 @@ TEST_F(UnitTestColor, Blend)
 // Test predefined colors
 TEST_F(UnitTestColor, PredefinedColors)
 {
-    constexpr Color red = Color::Red();
-    constexpr Color green = Color::Green();
-    constexpr Color blue = Color::Blue();
+    constexpr Color red = Color::red();
+    constexpr Color green = Color::green();
+    constexpr Color blue = Color::blue();
 
     EXPECT_FLOAT_EQ(red.x, 1.0f);
     EXPECT_FLOAT_EQ(red.y, 0.0f);
@@ -106,7 +106,7 @@ TEST_F(UnitTestColor, BlendVector3)
 {
     constexpr Color v1(1.0f, 0.0f, 0.0f, 1.f); // Red
     constexpr Color v2(0.0f, 1.0f, 0.0f, 1.f); // Green
-    constexpr Color blended = v1.Blend(v2, 0.5f);
+    constexpr Color blended = v1.blend(v2, 0.5f);
     EXPECT_FLOAT_EQ(blended.x, 0.5f);
     EXPECT_FLOAT_EQ(blended.y, 0.5f);
     EXPECT_FLOAT_EQ(blended.z, 0.0f);

tests/general/unit_test_line_trace.cpp

@@ -59,7 +59,7 @@ namespace
     TEST_P(CanTraceLineParam, VariousRays)
     {
         const auto& p = GetParam();
-        EXPECT_EQ(LineTracer::CanTraceLine(p.ray, triangle), p.expected_clear);
+        EXPECT_EQ(LineTracer::can_trace_line(p.ray, triangle), p.expected_clear);
     }
 
     INSTANTIATE_TEST_SUITE_P(
@@ -84,7 +84,7 @@ namespace
         constexpr Ray ray{{0.3f, 0.3f, -1.f}, {0.3f, 0.3f, 1.f}};
         constexpr Vec3 expected{0.3f, 0.3f, 0.f};
 
-        const Vec3 hit = LineTracer::GetRayHitPoint(ray, triangle);
+        const Vec3 hit = LineTracer::get_ray_hit_point(ray, triangle);
         ASSERT_FALSE(VecEqual(hit, ray.end));
         EXPECT_TRUE(VecEqual(hit, expected));
     }
@@ -99,7 +99,7 @@ namespace
                                          {1001.f, 1000.f, 1000.f},
                                          {1000.f, 1001.f, 1000.f}};
 
-        EXPECT_TRUE(LineTracer::CanTraceLine(short_ray, distant));
+        EXPECT_TRUE(LineTracer::can_trace_line(short_ray, distant));
     }
 
     TEST(LineTracerTraceRayEdge, CantHit)
@@ -108,14 +108,13 @@ namespace
 
         constexpr Ray ray{{}, {1.0, 0, 0}, false};
 
-        EXPECT_TRUE(omath::collision::LineTracer::CanTraceLine(ray, triangle));
+        EXPECT_TRUE(omath::collision::LineTracer::can_trace_line(ray, triangle));
     }
     TEST(LineTracerTraceRayEdge, CanHit)
     {
         constexpr omath::Triangle<Vector3<float>> triangle{{2, 0, 0}, {2, 2, 0}, {2, 2, 2}};
 
         constexpr Ray ray{{}, {2.1, 0, 0}, false};
-        auto endPoint = omath::collision::LineTracer::GetRayHitPoint(ray, triangle);
-        EXPECT_FALSE(omath::collision::LineTracer::CanTraceLine(ray, triangle));
+        EXPECT_FALSE(omath::collision::LineTracer::can_trace_line(ray, triangle));
     }
 } // namespace

tests/general/unit_test_mat.cpp

@@ -22,22 +22,22 @@ protected:
 TEST_F(UnitTestMat, Constructor_Default)
 {
     Mat<3, 3> m;
-    EXPECT_EQ(m.RowCount(), 3);
-    EXPECT_EQ(m.ColumnsCount(), 3);
+    EXPECT_EQ(m.row_count(), 3);
+    EXPECT_EQ(m.columns_count(), 3);
     for (size_t i = 0; i < 3; ++i)
         for (size_t j = 0; j < 3; ++j)
-            EXPECT_FLOAT_EQ(m.At(i, j), 0.0f);
+            EXPECT_FLOAT_EQ(m.at(i, j), 0.0f);
 }
 
 TEST_F(UnitTestMat, Constructor_InitializerList)
 {
     constexpr Mat<2, 2> m{{1.0f, 2.0f}, {3.0f, 4.0f}};
-    EXPECT_EQ(m.RowCount(), 2);
-    EXPECT_EQ(m.ColumnsCount(), 2);
-    EXPECT_FLOAT_EQ(m.At(0, 0), 1.0f);
-    EXPECT_FLOAT_EQ(m.At(0, 1), 2.0f);
-    EXPECT_FLOAT_EQ(m.At(1, 0), 3.0f);
-    EXPECT_FLOAT_EQ(m.At(1, 1), 4.0f);
+    EXPECT_EQ(m.row_count(), 2);
+    EXPECT_EQ(m.columns_count(), 2);
+    EXPECT_FLOAT_EQ(m.at(0, 0), 1.0f);
+    EXPECT_FLOAT_EQ(m.at(0, 1), 2.0f);
+    EXPECT_FLOAT_EQ(m.at(1, 0), 3.0f);
+    EXPECT_FLOAT_EQ(m.at(1, 1), 4.0f);
 }
 
 TEST_F(UnitTestMat, Operator_SquareBrackets)
@@ -51,19 +51,19 @@ TEST_F(UnitTestMat, Operator_SquareBrackets)
 TEST_F(UnitTestMat, Constructor_Copy)
 {
     Mat<2, 2> m3 = m2;
-    EXPECT_EQ(m3.RowCount(), m2.RowCount());
-    EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
-    EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
-    EXPECT_FLOAT_EQ(m3.At(1, 1), m2.At(1, 1));
+    EXPECT_EQ(m3.row_count(), m2.row_count());
+    EXPECT_EQ(m3.columns_count(), m2.columns_count());
+    EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
+    EXPECT_FLOAT_EQ(m3.at(1, 1), m2.at(1, 1));
 }
 
 TEST_F(UnitTestMat, Constructor_Move)
 {
     Mat<2, 2> m3 = std::move(m2);
-    EXPECT_EQ(m3.RowCount(), 2);
-    EXPECT_EQ(m3.ColumnsCount(), 2);
-    EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
-    EXPECT_FLOAT_EQ(m3.At(1, 1), 4.0f);
+    EXPECT_EQ(m3.row_count(), 2);
+    EXPECT_EQ(m3.columns_count(), 2);
+    EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
+    EXPECT_FLOAT_EQ(m3.at(1, 1), 4.0f);
     // m2 is in a valid but unspecified state after move
 }
 
@@ -71,61 +71,61 @@ TEST_F(UnitTestMat, Constructor_Move)
 TEST_F(UnitTestMat, Operator_Multiplication_Matrix)
 {
     Mat<2, 2> m3 = m2 * m2;
-    EXPECT_EQ(m3.RowCount(), 2);
-    EXPECT_EQ(m3.ColumnsCount(), 2);
-    EXPECT_FLOAT_EQ(m3.At(0, 0), 7.0f);
-    EXPECT_FLOAT_EQ(m3.At(0, 1), 10.0f);
-    EXPECT_FLOAT_EQ(m3.At(1, 0), 15.0f);
-    EXPECT_FLOAT_EQ(m3.At(1, 1), 22.0f);
+    EXPECT_EQ(m3.row_count(), 2);
+    EXPECT_EQ(m3.columns_count(), 2);
+    EXPECT_FLOAT_EQ(m3.at(0, 0), 7.0f);
+    EXPECT_FLOAT_EQ(m3.at(0, 1), 10.0f);
+    EXPECT_FLOAT_EQ(m3.at(1, 0), 15.0f);
+    EXPECT_FLOAT_EQ(m3.at(1, 1), 22.0f);
 }
 
 TEST_F(UnitTestMat, Operator_Multiplication_Scalar)
 {
     Mat<2, 2> m3 = m2 * 2.0f;
-    EXPECT_FLOAT_EQ(m3.At(0, 0), 2.0f);
-    EXPECT_FLOAT_EQ(m3.At(1, 1), 8.0f);
+    EXPECT_FLOAT_EQ(m3.at(0, 0), 2.0f);
+    EXPECT_FLOAT_EQ(m3.at(1, 1), 8.0f);
 }
 
 TEST_F(UnitTestMat, Operator_Division_Scalar)
 {
     Mat<2, 2> m3 = m2 / 2.0f;
-    EXPECT_FLOAT_EQ(m3.At(0, 0), 0.5f);
-    EXPECT_FLOAT_EQ(m3.At(1, 1), 2.0f);
+    EXPECT_FLOAT_EQ(m3.at(0, 0), 0.5f);
+    EXPECT_FLOAT_EQ(m3.at(1, 1), 2.0f);
 }
 
 // Test matrix functions
 TEST_F(UnitTestMat, Transpose)
 {
-    Mat<2, 2> m3 = m2.Transposed();
-    EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
-    EXPECT_FLOAT_EQ(m3.At(0, 1), m2.At(1, 0));
-    EXPECT_FLOAT_EQ(m3.At(1, 0), m2.At(0, 1));
-    EXPECT_FLOAT_EQ(m3.At(1, 1), m2.At(1, 1));
+    Mat<2, 2> m3 = m2.transposed();
+    EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
+    EXPECT_FLOAT_EQ(m3.at(0, 1), m2.at(1, 0));
+    EXPECT_FLOAT_EQ(m3.at(1, 0), m2.at(0, 1));
+    EXPECT_FLOAT_EQ(m3.at(1, 1), m2.at(1, 1));
 }
 
 TEST_F(UnitTestMat, Determinant)
 {
-    const float det = m2.Determinant();
+    const float det = m2.determinant();
     EXPECT_FLOAT_EQ(det, -2.0f);
 }
 
 TEST_F(UnitTestMat, Sum)
 {
-    const float sum = m2.Sum();
+    const float sum = m2.sum();
     EXPECT_FLOAT_EQ(sum, 10.0f);
 }
 
 TEST_F(UnitTestMat, Clear)
 {
-    m2.Clear();
-    for (size_t i = 0; i < m2.RowCount(); ++i)
-        for (size_t j = 0; j < m2.ColumnsCount(); ++j)
-            EXPECT_FLOAT_EQ(m2.At(i, j), 0.0f);
+    m2.clear();
+    for (size_t i = 0; i < m2.row_count(); ++i)
+        for (size_t j = 0; j < m2.columns_count(); ++j)
+            EXPECT_FLOAT_EQ(m2.at(i, j), 0.0f);
 }
 
 TEST_F(UnitTestMat, ToString)
 {
-    const std::string str = m2.ToString();
+    const std::string str = m2.to_string();
     EXPECT_FALSE(str.empty());
     EXPECT_EQ(str, "[[    1.000,     2.000]\n [    3.000,     4.000]]");
 }
@@ -135,31 +135,31 @@ TEST_F(UnitTestMat, AssignmentOperator_Copy)
 {
     Mat<2, 2> m3;
     m3 = m2;
-    EXPECT_EQ(m3.RowCount(), m2.RowCount());
-    EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
-    EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
+    EXPECT_EQ(m3.row_count(), m2.row_count());
+    EXPECT_EQ(m3.columns_count(), m2.columns_count());
+    EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
 }
 
 TEST_F(UnitTestMat, AssignmentOperator_Move)
 {
     Mat<2, 2> m3;
     m3 = std::move(m2);
-    EXPECT_EQ(m3.RowCount(), 2);
-    EXPECT_EQ(m3.ColumnsCount(), 2);
-    EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
-    EXPECT_FLOAT_EQ(m3.At(1, 1), 4.0f);
+    EXPECT_EQ(m3.row_count(), 2);
+    EXPECT_EQ(m3.columns_count(), 2);
+    EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
+    EXPECT_FLOAT_EQ(m3.at(1, 1), 4.0f);
     // m2 is in a valid but unspecified state after move
 }
 
 // Test static methods
 TEST_F(UnitTestMat, StaticMethod_ToScreenMat)
 {
-    Mat<4, 4> screenMat = Mat<4, 4>::ToScreenMat(800.0f, 600.0f);
-    EXPECT_FLOAT_EQ(screenMat.At(0, 0), 400.0f);
-    EXPECT_FLOAT_EQ(screenMat.At(1, 1), -300.0f);
-    EXPECT_FLOAT_EQ(screenMat.At(3, 0), 400.0f);
-    EXPECT_FLOAT_EQ(screenMat.At(3, 1), 300.0f);
-    EXPECT_FLOAT_EQ(screenMat.At(3, 3), 1.0f);
+    Mat<4, 4> screenMat = Mat<4, 4>::to_screen_mat(800.0f, 600.0f);
+    EXPECT_FLOAT_EQ(screenMat.at(0, 0), 400.0f);
+    EXPECT_FLOAT_EQ(screenMat.at(1, 1), -300.0f);
+    EXPECT_FLOAT_EQ(screenMat.at(3, 0), 400.0f);
+    EXPECT_FLOAT_EQ(screenMat.at(3, 1), 300.0f);
+    EXPECT_FLOAT_EQ(screenMat.at(3, 3), 1.0f);
 }
 
 
@@ -175,34 +175,42 @@ TEST_F(UnitTestMat, Method_At_OutOfRange)
 // Test Determinant for 3x3 matrix
 TEST(UnitTestMatStandalone, Determinant_3x3)
 {
-    constexpr auto det = Mat<3, 3>{{6, 1, 1}, {4, -2, 5}, {2, 8, 7}}.Determinant();
+    constexpr auto det = Mat<3, 3>{{6, 1, 1}, {4, -2, 5}, {2, 8, 7}}.determinant();
     EXPECT_FLOAT_EQ(det, -306.0f);
 }
 
 // Test Minor for 3x3 matrix
-TEST(UnitTestMatStandalone, Minor_3x3)
+TEST(UnitTestMatStandalone, Strip_3x3)
 {
     constexpr Mat<3, 3> m{{3, 0, 2}, {2, 0, -2}, {0, 1, 1}};
-    auto minor = m.Minor(0, 0);
-    EXPECT_EQ(minor.RowCount(), 2);
-    EXPECT_EQ(minor.ColumnsCount(), 2);
-    EXPECT_FLOAT_EQ(minor.At(0, 0), 0.0f);
-    EXPECT_FLOAT_EQ(minor.At(0, 1), -2.0f);
-    EXPECT_FLOAT_EQ(minor.At(1, 0), 1.0f);
-    EXPECT_FLOAT_EQ(minor.At(1, 1), 1.0f);
+    auto minor = m.strip(0, 0);
+    EXPECT_EQ(minor.row_count(), 2);
+    EXPECT_EQ(minor.columns_count(), 2);
+    EXPECT_FLOAT_EQ(minor.at(0, 0), 0.0f);
+    EXPECT_FLOAT_EQ(minor.at(0, 1), -2.0f);
+    EXPECT_FLOAT_EQ(minor.at(1, 0), 1.0f);
+    EXPECT_FLOAT_EQ(minor.at(1, 1), 1.0f);
 }
 
 // Test Transpose for non-square matrix
 TEST(UnitTestMatStandalone, Transpose_NonSquare)
 {
     constexpr Mat<2, 3> m{{1.0f, 2.0f, 3.0f}, {4.0f, 5.0f, 6.0f}};
-    auto transposed = m.Transposed();
-    EXPECT_EQ(transposed.RowCount(), 3);
-    EXPECT_EQ(transposed.ColumnsCount(), 2);
-    EXPECT_FLOAT_EQ(transposed.At(0, 0), 1.0f);
-    EXPECT_FLOAT_EQ(transposed.At(1, 0), 2.0f);
-    EXPECT_FLOAT_EQ(transposed.At(2, 0), 3.0f);
-    EXPECT_FLOAT_EQ(transposed.At(0, 1), 4.0f);
-    EXPECT_FLOAT_EQ(transposed.At(1, 1), 5.0f);
-    EXPECT_FLOAT_EQ(transposed.At(2, 1), 6.0f);
+    auto transposed = m.transposed();
+    EXPECT_EQ(transposed.row_count(), 3);
+    EXPECT_EQ(transposed.columns_count(), 2);
+    EXPECT_FLOAT_EQ(transposed.at(0, 0), 1.0f);
+    EXPECT_FLOAT_EQ(transposed.at(1, 0), 2.0f);
+    EXPECT_FLOAT_EQ(transposed.at(2, 0), 3.0f);
+    EXPECT_FLOAT_EQ(transposed.at(0, 1), 4.0f);
+    EXPECT_FLOAT_EQ(transposed.at(1, 1), 5.0f);
+    EXPECT_FLOAT_EQ(transposed.at(2, 1), 6.0f);
+}
+
+TEST(UnitTestMatStandalone, Enverse)
+{
+    constexpr Mat<2, 2> m{{1.0f, 3.0f}, {2.0f, 5.0f}};
+    constexpr Mat<2,2> mv{{-5.0f, 3.0f}, {2.0f, -1.0f}};
+
+    EXPECT_EQ(mv, m.inverted());
 }

tests/general/unit_test_matrix.cpp

@@ -25,8 +25,8 @@ protected:
 TEST_F(UnitTestMatrix, Constructor_Size)
 {
     const Matrix m(3, 3);
-    EXPECT_EQ(m.RowCount(), 3);
-    EXPECT_EQ(m.ColumnsCount(), 3);
+    EXPECT_EQ(m.row_count(), 3);
+    EXPECT_EQ(m.columns_count(), 3);
 }
 
 TEST_F(UnitTestMatrix, Operator_SquareBrackets)
@@ -41,120 +41,120 @@ TEST_F(UnitTestMatrix, Operator_SquareBrackets)
 TEST_F(UnitTestMatrix, Constructor_InitializerList)
 {
     Matrix m{{1.0f, 2.0f}, {3.0f, 4.0f}};
-    EXPECT_EQ(m.RowCount(), 2);
-    EXPECT_EQ(m.ColumnsCount(), 2);
-    EXPECT_FLOAT_EQ(m.At(0, 0), 1.0f);
-    EXPECT_FLOAT_EQ(m.At(1, 1), 4.0f);
+    EXPECT_EQ(m.row_count(), 2);
+    EXPECT_EQ(m.columns_count(), 2);
+    EXPECT_FLOAT_EQ(m.at(0, 0), 1.0f);
+    EXPECT_FLOAT_EQ(m.at(1, 1), 4.0f);
 }
 
 TEST_F(UnitTestMatrix, Constructor_Copy)
 {
     Matrix m3 = m2;
-    EXPECT_EQ(m3.RowCount(), m2.RowCount());
-    EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
-    EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
+    EXPECT_EQ(m3.row_count(), m2.row_count());
+    EXPECT_EQ(m3.columns_count(), m2.columns_count());
+    EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
 }
 
 TEST_F(UnitTestMatrix, Constructor_Move)
 {
     Matrix m3 = std::move(m2);
-    EXPECT_EQ(m3.RowCount(), 2);
-    EXPECT_EQ(m3.ColumnsCount(), 2);
-    EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
-    EXPECT_EQ(m2.RowCount(), 0);  // m2 should be empty after the move
-    EXPECT_EQ(m2.ColumnsCount(), 0);
+    EXPECT_EQ(m3.row_count(), 2);
+    EXPECT_EQ(m3.columns_count(), 2);
+    EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
+    EXPECT_EQ(m2.row_count(), 0);  // m2 should be empty after the move
+    EXPECT_EQ(m2.columns_count(), 0);
 }
 
 // Test matrix operations
 TEST_F(UnitTestMatrix, Operator_Multiplication_Matrix)
 {
     Matrix m3 = m2 * m2;
-    EXPECT_EQ(m3.RowCount(), 2);
-    EXPECT_EQ(m3.ColumnsCount(), 2);
-    EXPECT_FLOAT_EQ(m3.At(0, 0), 7.0f);
-    EXPECT_FLOAT_EQ(m3.At(1, 1), 22.0f);
+    EXPECT_EQ(m3.row_count(), 2);
+    EXPECT_EQ(m3.columns_count(), 2);
+    EXPECT_FLOAT_EQ(m3.at(0, 0), 7.0f);
+    EXPECT_FLOAT_EQ(m3.at(1, 1), 22.0f);
 }
 
 TEST_F(UnitTestMatrix, Operator_Multiplication_Scalar)
 {
     Matrix m3 = m2 * 2.0f;
-    EXPECT_FLOAT_EQ(m3.At(0, 0), 2.0f);
-    EXPECT_FLOAT_EQ(m3.At(1, 1), 8.0f);
+    EXPECT_FLOAT_EQ(m3.at(0, 0), 2.0f);
+    EXPECT_FLOAT_EQ(m3.at(1, 1), 8.0f);
 }
 
 TEST_F(UnitTestMatrix, Operator_Division_Scalar)
 {
     Matrix m3 = m2 / 2.0f;
-    EXPECT_FLOAT_EQ(m3.At(0, 0), 0.5f);
-    EXPECT_FLOAT_EQ(m3.At(1, 1), 2.0f);
+    EXPECT_FLOAT_EQ(m3.at(0, 0), 0.5f);
+    EXPECT_FLOAT_EQ(m3.at(1, 1), 2.0f);
 }
 
 // Test matrix functions
 TEST_F(UnitTestMatrix, Transpose)
 {
-    Matrix m3 = m2.Transpose();
-    EXPECT_FLOAT_EQ(m3.At(0, 1), 3.0f);
-    EXPECT_FLOAT_EQ(m3.At(1, 0), 2.0f);
+    Matrix m3 = m2.transpose();
+    EXPECT_FLOAT_EQ(m3.at(0, 1), 3.0f);
+    EXPECT_FLOAT_EQ(m3.at(1, 0), 2.0f);
 }
 
 TEST_F(UnitTestMatrix, Determinant)
 {
-    const float det = m2.Determinant();
+    const float det = m2.determinant();
     EXPECT_FLOAT_EQ(det, -2.0f);
 }
 
 TEST_F(UnitTestMatrix, Minor)
 {
-    const float minor = m2.Minor(0, 0);
+    const float minor = m2.minor(0, 0);
     EXPECT_FLOAT_EQ(minor, 4.0f);
 }
 
 TEST_F(UnitTestMatrix, AlgComplement)
 {
-    const float algComp = m2.AlgComplement(0, 0);
+    const float algComp = m2.alg_complement(0, 0);
     EXPECT_FLOAT_EQ(algComp, 4.0f);
 }
 
 TEST_F(UnitTestMatrix, Strip)
 {
-    Matrix m3 = m2.Strip(0, 0);
-    EXPECT_EQ(m3.RowCount(), 1);
-    EXPECT_EQ(m3.ColumnsCount(), 1);
-    EXPECT_FLOAT_EQ(m3.At(0, 0), 4.0f);
+    Matrix m3 = m2.strip(0, 0);
+    EXPECT_EQ(m3.row_count(), 1);
+    EXPECT_EQ(m3.columns_count(), 1);
+    EXPECT_FLOAT_EQ(m3.at(0, 0), 4.0f);
 }
 
 TEST_F(UnitTestMatrix, ProjectionMatrix)
 {
-    const Matrix proj = Matrix::ProjectionMatrix(45.0f, 1.33f, 0.1f, 100.0f);
-    EXPECT_EQ(proj.RowCount(), 4);
-    EXPECT_EQ(proj.ColumnsCount(), 4);
+    const Matrix proj = Matrix::projection_matrix(45.0f, 1.33f, 0.1f, 100.0f);
+    EXPECT_EQ(proj.row_count(), 4);
+    EXPECT_EQ(proj.columns_count(), 4);
     // Further checks on projection matrix elements could be added
 }
 
 // Test other member functions
 TEST_F(UnitTestMatrix, Set)
 {
-    m1.Set(3.0f);
-    EXPECT_FLOAT_EQ(m1.At(0, 0), 3.0f);
-    EXPECT_FLOAT_EQ(m1.At(1, 1), 3.0f);
+    m1.set(3.0f);
+    EXPECT_FLOAT_EQ(m1.at(0, 0), 3.0f);
+    EXPECT_FLOAT_EQ(m1.at(1, 1), 3.0f);
 }
 
 TEST_F(UnitTestMatrix, Sum)
 {
-    const float sum = m2.Sum();
+    const float sum = m2.sum();
     EXPECT_FLOAT_EQ(sum, 10.0f);
 }
 
 TEST_F(UnitTestMatrix, Clear)
 {
-    m2.Clear();
-    EXPECT_FLOAT_EQ(m2.At(0, 0), 0.0f);
-    EXPECT_FLOAT_EQ(m2.At(1, 1), 0.0f);
+    m2.clear();
+    EXPECT_FLOAT_EQ(m2.at(0, 0), 0.0f);
+    EXPECT_FLOAT_EQ(m2.at(1, 1), 0.0f);
 }
 
 TEST_F(UnitTestMatrix, ToString)
 {
-    const std::string str = m2.ToString();
+    const std::string str = m2.to_string();
     EXPECT_FALSE(str.empty());
 }
 
@@ -163,18 +163,18 @@ TEST_F(UnitTestMatrix, AssignmentOperator_Copy)
 {
     Matrix m3(2, 2);
     m3 = m2;
-    EXPECT_EQ(m3.RowCount(), m2.RowCount());
-    EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
-    EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
+    EXPECT_EQ(m3.row_count(), m2.row_count());
+    EXPECT_EQ(m3.columns_count(), m2.columns_count());
+    EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
 }
 
 TEST_F(UnitTestMatrix, AssignmentOperator_Move)
 {
     Matrix m3(2, 2);
     m3 = std::move(m2);
-    EXPECT_EQ(m3.RowCount(), 2);
-    EXPECT_EQ(m3.ColumnsCount(), 2);
-    EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
-    EXPECT_EQ(m2.RowCount(), 0);  // m2 should be empty after the move
-    EXPECT_EQ(m2.ColumnsCount(), 0);
+    EXPECT_EQ(m3.row_count(), 2);
+    EXPECT_EQ(m3.columns_count(), 2);
+    EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
+    EXPECT_EQ(m2.row_count(), 0);  // m2 should be empty after the move
+    EXPECT_EQ(m2.columns_count(), 0);
 }

tests/general/unit_test_prediction.cpp

@@ -4,13 +4,13 @@
 TEST(UnitTestPrediction, PredictionTest)
 {
     constexpr omath::projectile_prediction::Target target{
-            .m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_isAirborne = false};
+            .m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
     constexpr omath::projectile_prediction::Projectile proj = {
-            .m_origin = {3, 2, 1}, .m_launchSpeed = 5000, .m_gravityScale = 0.4};
+            .m_origin = {3, 2, 1}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
     const auto viewPoint =
-            omath::projectile_prediction::ProjPredEngineLegacy(400, 1.f / 1000.f, 50, 5.f).MaybeCalculateAimPoint(proj, target);
+            omath::projectile_prediction::ProjPredEngineLegacy(400, 1.f / 1000.f, 50, 5.f).maybe_calculate_aim_point(proj, target);
 
-    const auto [pitch, yaw, _] = proj.m_origin.ViewAngleTo(viewPoint.value()).AsTuple();
+    const auto [pitch, yaw, _] = proj.m_origin.view_angle_to(viewPoint.value()).as_tuple();
 
     EXPECT_NEAR(42.547142, pitch, 0.01f);
     EXPECT_NEAR(-1.181189, yaw, 0.01f);

tests/general/unit_test_projection.cpp

@@ -9,9 +9,9 @@
 
 TEST(UnitTestProjection, Projection)
 {
-    const auto x = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::FromDegrees(90.f);
+    const auto x = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::from_degrees(90.f);
     auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, x, 0.01f, 1000.f);
 
-    const auto projected = cam.WorldToScreen({1000, 0, 50});
+    const auto projected = cam.world_to_screen({1000, 0, 50});
     std::print("{} {} {}", projected->x, projected->y, projected->z);
 }

tests/general/unit_test_triangle.cpp

@@ -68,14 +68,14 @@ TEST_F(UnitTestTriangle, Constructor)
 TEST_F(UnitTestTriangle, CalculateNormal)
 {
     // For t1, the normal should point in the +Z direction (0, 0, 1) or (0, 0, -1)
-    const Vector3 normal_t1 = t1.CalculateNormal();
+    const Vector3 normal_t1 = t1.calculate_normal();
     // Check if it's normalized and pointed along Z (sign can differ, so use absolute check)
     EXPECT_NEAR(std::fabs(normal_t1.z), 1.0f, 1e-5f);
-    EXPECT_NEAR(normal_t1.Length(), 1.0f, 1e-5f);
+    EXPECT_NEAR(normal_t1.length(), 1.0f, 1e-5f);
 
 
     // For t3, we expect the normal to be along +Z as well
-    const Vector3 normal_t3 = t3.CalculateNormal();
+    const Vector3 normal_t3 = t3.calculate_normal();
     EXPECT_NEAR(std::fabs(normal_t3.z), 1.0f, 1e-5f);
 }
 
@@ -83,29 +83,29 @@ TEST_F(UnitTestTriangle, CalculateNormal)
 TEST_F(UnitTestTriangle, SideLengths)
 {
     // For t1 side lengths
-    EXPECT_FLOAT_EQ(t1.SideALength(), std::sqrt(1.0f)); // distance between (0,0,0) and (1,0,0)
-    EXPECT_FLOAT_EQ(t1.SideBLength(), std::sqrt(1.0f + 1.0f)); // distance between (4,5,6) & (7,8,9)... but we are testing t1, so let's be accurate:
+    EXPECT_FLOAT_EQ(t1.side_a_length(), std::sqrt(1.0f)); // distance between (0,0,0) and (1,0,0)
+    EXPECT_FLOAT_EQ(t1.side_b_length(), std::sqrt(1.0f + 1.0f)); // distance between (4,5,6) & (7,8,9)... but we are testing t1, so let's be accurate:
     // Actually, for t1: vertex2=(1,0,0), vertex3=(0,1,0)
     // Dist between (0,1,0) and (1,0,0) = sqrt((1-0)^2 + (0-1)^2) = sqrt(1 + 1) = sqrt(2)
-    EXPECT_FLOAT_EQ(t1.SideBLength(), std::sqrt(2.0f));
+    EXPECT_FLOAT_EQ(t1.side_b_length(), std::sqrt(2.0f));
 
     // For t3, side a = distance between vertex1=(0,0,0) and vertex2=(2,0,0), which is 2
     // side b = distance between vertex3=(0,2,0) and vertex2=(2,0,0), which is sqrt(2^2 + (-2)^2)= sqrt(8)= 2.828...
     // We'll just check side a first:
-    EXPECT_FLOAT_EQ(t3.SideALength(), 2.0f);
+    EXPECT_FLOAT_EQ(t3.side_a_length(), 2.0f);
     // Then side b:
-    EXPECT_FLOAT_EQ(t3.SideBLength(), std::sqrt(8.0f));
+    EXPECT_FLOAT_EQ(t3.side_b_length(), std::sqrt(8.0f));
 }
 
 // Test side vectors
 TEST_F(UnitTestTriangle, SideVectors)
 {
-    const Vector3 sideA_t1 = t1.SideAVector(); // m_vertex1 - m_vertex2
+    const Vector3 sideA_t1 = t1.side_a_vector(); // m_vertex1 - m_vertex2
     EXPECT_FLOAT_EQ(sideA_t1.x, 0.0f - 1.0f);
     EXPECT_FLOAT_EQ(sideA_t1.y, 0.0f - 0.0f);
     EXPECT_FLOAT_EQ(sideA_t1.z, 0.0f - 0.0f);
 
-    const Vector3 sideB_t1 = t1.SideBVector(); // m_vertex3 - m_vertex2
+    const Vector3 sideB_t1 = t1.side_b_vector(); // m_vertex3 - m_vertex2
     EXPECT_FLOAT_EQ(sideB_t1.x, 0.0f - 1.0f);
     EXPECT_FLOAT_EQ(sideB_t1.y, 1.0f - 0.0f);
     EXPECT_FLOAT_EQ(sideB_t1.z, 0.0f - 0.0f);
@@ -113,19 +113,19 @@ TEST_F(UnitTestTriangle, SideVectors)
 
 TEST_F(UnitTestTriangle, IsRectangular)
 {
-    EXPECT_TRUE(Triangle<Vector3<float>>({2,0,0}, {}, {0,2,0}).IsRectangular());
+    EXPECT_TRUE(Triangle<Vector3<float>>({2,0,0}, {}, {0,2,0}).is_rectangular());
 }
 // Test midpoint
 TEST_F(UnitTestTriangle, MidPoint)
 {
     // For t1, midpoint of (0,0,0), (1,0,0), (0,1,0)
-    const Vector3 mid1 = t1.MidPoint();
+    const Vector3 mid1 = t1.mid_point();
     EXPECT_FLOAT_EQ(mid1.x, (0.0f + 1.0f + 0.0f) / 3.0f);
     EXPECT_FLOAT_EQ(mid1.y, (0.0f + 0.0f + 1.0f) / 3.0f);
     EXPECT_FLOAT_EQ(mid1.z, 0.0f);
 
     // For t2, midpoint of (1,2,3), (4,5,6), (7,8,9)
-    const Vector3 mid2 = t2.MidPoint();
+    const Vector3 mid2 = t2.mid_point();
     EXPECT_FLOAT_EQ(mid2.x, (1.0f + 4.0f + 7.0f) / 3.0f);
     EXPECT_FLOAT_EQ(mid2.y, (2.0f + 5.0f + 8.0f) / 3.0f);
     EXPECT_FLOAT_EQ(mid2.z, (3.0f + 6.0f + 9.0f) / 3.0f);

tests/general/unit_test_vector2.cpp

@@ -150,76 +150,76 @@ TEST_F(UnitTestVector2, SubtractionAssignmentOperator_Float)
 // Test other member functions
 TEST_F(UnitTestVector2, DistTo)
 {
-    const float dist = v1.DistTo(v2);
+    const float dist = v1.distance_to(v2);
     EXPECT_FLOAT_EQ(dist, std::sqrt(18.0f));
 }
 
 TEST_F(UnitTestVector2, DistTo_SamePoint)
 {
-    const float dist = v1.DistTo(v1);
+    const float dist = v1.distance_to(v1);
     EXPECT_FLOAT_EQ(dist, 0.0f);
 }
 
 TEST_F(UnitTestVector2, DistToSqr)
 {
-    constexpr float distSqr = Vector2(1.0f, 2.0f).DistToSqr(Vector2(4.0f, 5.0f));
+    constexpr float distSqr = Vector2(1.0f, 2.0f).distance_to_sqr(Vector2(4.0f, 5.0f));
     EXPECT_FLOAT_EQ(distSqr, 18.0f);
 }
 
 TEST_F(UnitTestVector2, DistToSqr_SamePoint)
 {
-    constexpr float distSqr = Vector2(1.0f, 2.0f).DistToSqr(Vector2(1.0f, 2.0f));
+    constexpr float distSqr = Vector2(1.0f, 2.0f).distance_to_sqr(Vector2(1.0f, 2.0f));
     EXPECT_FLOAT_EQ(distSqr, 0.0f);
 }
 
 TEST_F(UnitTestVector2, DotProduct)
 {
-    constexpr float dot = Vector2(1.0f, 2.0f).Dot(Vector2(4.0f, 5.0f));
+    constexpr float dot = Vector2(1.0f, 2.0f).dot(Vector2(4.0f, 5.0f));
     EXPECT_FLOAT_EQ(dot, 14.0f);
 }
 
 TEST_F(UnitTestVector2, DotProduct_PerpendicularVectors)
 {
-    constexpr float dot = Vector2(1.0f, 0.0f).Dot(Vector2(0.0f, 1.0f));
+    constexpr float dot = Vector2(1.0f, 0.0f).dot(Vector2(0.0f, 1.0f));
     EXPECT_FLOAT_EQ(dot, 0.0f);
 }
 
 TEST_F(UnitTestVector2, DotProduct_ParallelVectors)
 {
-    constexpr float dot = Vector2(1.0f, 1.0f).Dot(Vector2(2.0f, 2.0f));
+    constexpr float dot = Vector2(1.0f, 1.0f).dot(Vector2(2.0f, 2.0f));
     EXPECT_FLOAT_EQ(dot, 4.0f);
 }
 
 TEST_F(UnitTestVector2, Length)
 {
-    const float length = v1.Length();
+    const float length = v1.length();
     EXPECT_FLOAT_EQ(length, std::sqrt(5.0f));
 }
 
 TEST_F(UnitTestVector2, Length_ZeroVector)
 {
     constexpr Vector2 v_zero(0.0f, 0.0f);
-    const float length = v_zero.Length();
+    const float length = v_zero.length();
     EXPECT_FLOAT_EQ(length, 0.0f);
 }
 
 TEST_F(UnitTestVector2, Length_LargeValues)
 {
     constexpr Vector2 v_large(FLT_MAX, FLT_MAX);
-    const float length = v_large.Length();
+    const float length = v_large.length();
     EXPECT_TRUE(std::isinf(length));
 }
 
 TEST_F(UnitTestVector2, LengthSqr)
 {
-    constexpr float lengthSqr = Vector2(1.0f, 2.0f).LengthSqr();
+    constexpr float lengthSqr = Vector2(1.0f, 2.0f).length_sqr();
     EXPECT_FLOAT_EQ(lengthSqr, 5.0f);
 }
 
 TEST_F(UnitTestVector2, Abs)
 {
     Vector2 v3(-1.0f, -2.0f);
-    v3.Abs();
+    v3.abs();
     EXPECT_FLOAT_EQ(v3.x, 1.0f);
     EXPECT_FLOAT_EQ(v3.y, 2.0f);
 }
@@ -227,7 +227,7 @@ TEST_F(UnitTestVector2, Abs)
 TEST_F(UnitTestVector2, Abs_PositiveValues)
 {
     Vector2 v3(1.0f, 2.0f);
-    v3.Abs();
+    v3.abs();
     EXPECT_FLOAT_EQ(v3.x, 1.0f);
     EXPECT_FLOAT_EQ(v3.y, 2.0f);
 }
@@ -235,26 +235,26 @@ TEST_F(UnitTestVector2, Abs_PositiveValues)
 TEST_F(UnitTestVector2, Abs_ZeroValues)
 {
     Vector2 v3(0.0f, 0.0f);
-    v3.Abs();
+    v3.abs();
     EXPECT_FLOAT_EQ(v3.x, 0.0f);
     EXPECT_FLOAT_EQ(v3.y, 0.0f);
 }
 
 TEST_F(UnitTestVector2, Sum)
 {
-    constexpr float sum = Vector2(1.0f, 2.0f).Sum();
+    constexpr float sum = Vector2(1.0f, 2.0f).sum();
     EXPECT_FLOAT_EQ(sum, 3.0f);
 }
 
 TEST_F(UnitTestVector2, Sum_NegativeValues)
 {
-    constexpr float sum = Vector2(-1.0f, -2.0f).Sum();
+    constexpr float sum = Vector2(-1.0f, -2.0f).sum();
     EXPECT_FLOAT_EQ(sum, -3.0f);
 }
 
 TEST_F(UnitTestVector2, Normalized)
 {
-    const Vector2 v3 = v1.Normalized();
+    const Vector2 v3 = v1.normalized();
     EXPECT_NEAR(v3.x, 0.44721f, 0.0001f);
     EXPECT_NEAR(v3.y, 0.89443f, 0.0001f);
 }
@@ -262,7 +262,7 @@ TEST_F(UnitTestVector2, Normalized)
 TEST_F(UnitTestVector2, Normalized_ZeroVector)
 {
     constexpr Vector2 v_zero(0.0f, 0.0f);
-    const Vector2 v_norm = v_zero.Normalized();
+    const Vector2 v_norm = v_zero.normalized();
     EXPECT_FLOAT_EQ(v_norm.x, 0.0f);
     EXPECT_FLOAT_EQ(v_norm.y, 0.0f);
 }
@@ -270,7 +270,7 @@ TEST_F(UnitTestVector2, Normalized_ZeroVector)
 // Test AsTuple method
 TEST_F(UnitTestVector2, AsTuple)
 {
-    const auto tuple = v1.AsTuple();
+    const auto tuple = v1.as_tuple();
     EXPECT_FLOAT_EQ(std::get<0>(tuple), v1.x);
     EXPECT_FLOAT_EQ(std::get<1>(tuple), v1.y);
 }
@@ -347,7 +347,7 @@ TEST_F(UnitTestVector2, NegationOperator_ZeroVector)
 }
 
 // Static assertions (compile-time checks)
-static_assert(Vector2(1.0f, 2.0f).LengthSqr() == 5.0f, "LengthSqr should be 5");
-static_assert(Vector2(1.0f, 2.0f).Dot(Vector2(4.0f, 5.0f)) == 14.0f, "Dot product should be 14");
-static_assert(Vector2(4.0f, 5.0f).DistToSqr(Vector2(1.0f, 2.0f)) == 18.0f, "DistToSqr should be 18");
-static_assert(Vector2(-1.0f, -2.0f).Abs() == Vector2(1.0f, 2.0f), "Abs should convert negative values to positive");
+static_assert(Vector2(1.0f, 2.0f).length_sqr() == 5.0f, "LengthSqr should be 5");
+static_assert(Vector2(1.0f, 2.0f).dot(Vector2(4.0f, 5.0f)) == 14.0f, "Dot product should be 14");
+static_assert(Vector2(4.0f, 5.0f).distance_to_sqr(Vector2(1.0f, 2.0f)) == 18.0f, "DistToSqr should be 18");
+static_assert(Vector2(-1.0f, -2.0f).abs() == Vector2(1.0f, 2.0f), "Abs should convert negative values to positive");

tests/general/unit_test_vector3.cpp

@@ -164,26 +164,26 @@ TEST_F(UnitTestVector3, NegationOperator)
 // Test other member functions
 TEST_F(UnitTestVector3, DistToSqr)
 {
-    constexpr auto distSqr = Vector3(1.0f, 2.0f, 3.0f).DistToSqr(Vector3(4.0f, 5.0f, 6.0f));
+    constexpr auto distSqr = Vector3(1.0f, 2.0f, 3.0f).distance_to_sqr(Vector3(4.0f, 5.0f, 6.0f));
     EXPECT_FLOAT_EQ(distSqr, 27.0f);
 }
 
 TEST_F(UnitTestVector3, DotProduct)
 {
-    constexpr auto dot = Vector3(1.0f, 2.0f, 3.0f).Dot(Vector3(4.0f, 5.0f, 6.0f));
+    constexpr auto dot = Vector3(1.0f, 2.0f, 3.0f).dot(Vector3(4.0f, 5.0f, 6.0f));
     EXPECT_FLOAT_EQ(dot, 32.0f);
 }
 
 TEST_F(UnitTestVector3, LengthSqr)
 {
-    constexpr auto lengthSqr = Vector3(1.0f, 2.0f, 3.0f).LengthSqr();
+    constexpr auto lengthSqr = Vector3(1.0f, 2.0f, 3.0f).length_sqr();
     EXPECT_FLOAT_EQ(lengthSqr, 14.0f);
 }
 
 TEST_F(UnitTestVector3, Abs)
 {
     auto v3 = Vector3(-1.0f, -2.0f, -3.0f);
-    v3.Abs();
+    v3.abs();
     EXPECT_FLOAT_EQ(v3.x, 1.0f);
     EXPECT_FLOAT_EQ(v3.y, 2.0f);
     EXPECT_FLOAT_EQ(v3.z, 3.0f);
@@ -191,19 +191,19 @@ TEST_F(UnitTestVector3, Abs)
 
 TEST_F(UnitTestVector3, Sum)
 {
-    constexpr auto sum = Vector3(1.0f, 2.0f, 3.0f).Sum();
+    constexpr auto sum = Vector3(1.0f, 2.0f, 3.0f).sum();
     EXPECT_FLOAT_EQ(sum, 6.0f);
 }
 
 TEST_F(UnitTestVector3, Sum2D)
 {
-    constexpr auto sum2D = Vector3(1.0f, 2.0f, 3.0f).Sum2D();
+    constexpr auto sum2D = Vector3(1.0f, 2.0f, 3.0f).sum_2d();
     EXPECT_FLOAT_EQ(sum2D, 3.0f);
 }
 
 TEST_F(UnitTestVector3, CrossProduct)
 {
-    constexpr Vector3 v3 = Vector3(1.0f, 2.0f, 3.0f).Cross(Vector3(4.0f, 5.0f, 6.0f));
+    constexpr Vector3 v3 = Vector3(1.0f, 2.0f, 3.0f).cross(Vector3(4.0f, 5.0f, 6.0f));
     EXPECT_FLOAT_EQ(v3.x, -3.0f);
     EXPECT_FLOAT_EQ(v3.y, 6.0f);
     EXPECT_FLOAT_EQ(v3.z, -3.0f);
@@ -298,41 +298,41 @@ TEST_F(UnitTestVector3, Division_WithNaN)
 // Test Length, Length2D, and Normalized
 TEST_F(UnitTestVector3, Length)
 {
-    const float length = v1.Length();
+    const float length = v1.length();
     EXPECT_FLOAT_EQ(length, std::sqrt(14.0f));
 }
 
 TEST_F(UnitTestVector3, Length_ZeroVector)
 {
     constexpr Vector3 v_zero(0.0f, 0.0f, 0.0f);
-    const float length = v_zero.Length();
+    const float length = v_zero.length();
     EXPECT_FLOAT_EQ(length, 0.0f);
 }
 
 TEST_F(UnitTestVector3, Length_LargeValues)
 {
     constexpr Vector3 v_large(FLT_MAX, FLT_MAX, FLT_MAX);
-    const float length = v_large.Length();
+    const float length = v_large.length();
     EXPECT_TRUE(std::isinf(length));
 }
 
 TEST_F(UnitTestVector3, Length2D)
 {
-    const float length2D = v1.Length2D();
+    const float length2D = v1.length_2d();
     EXPECT_FLOAT_EQ(length2D, std::sqrt(5.0f));
 }
 
 TEST_F(UnitTestVector3, Normalized)
 {
-    const Vector3 v_norm = v1.Normalized();
-    const float length = v_norm.Length();
+    const Vector3 v_norm = v1.normalized();
+    const float length = v_norm.length();
     EXPECT_NEAR(length, 1.0f, 0.0001f);
 }
 
 TEST_F(UnitTestVector3, Normalized_ZeroVector)
 {
     constexpr Vector3 v_zero(0.0f, 0.0f, 0.0f);
-    const Vector3 v_norm = v_zero.Normalized();
+    const Vector3 v_norm = v_zero.normalized();
     EXPECT_FLOAT_EQ(v_norm.x, 0.0f);
     EXPECT_FLOAT_EQ(v_norm.y, 0.0f);
     EXPECT_FLOAT_EQ(v_norm.z, 0.0f);
@@ -343,7 +343,7 @@ TEST_F(UnitTestVector3, CrossProduct_ParallelVectors)
 {
     constexpr Vector3 v_a(1.0f, 2.0f, 3.0f);
     constexpr Vector3 v_b = v_a * 2.0f; // Parallel to v_a
-    constexpr Vector3 cross = v_a.Cross(v_b);
+    constexpr Vector3 cross = v_a.cross(v_b);
     EXPECT_FLOAT_EQ(cross.x, 0.0f);
     EXPECT_FLOAT_EQ(cross.y, 0.0f);
     EXPECT_FLOAT_EQ(cross.z, 0.0f);
@@ -353,7 +353,7 @@ TEST_F(UnitTestVector3, CrossProduct_OrthogonalVectors)
 {
     constexpr Vector3 v_a(1.0f, 0.0f, 0.0f);
     constexpr Vector3 v_b(0.0f, 1.0f, 0.0f);
-    constexpr Vector3 cross = v_a.Cross(v_b);
+    constexpr Vector3 cross = v_a.cross(v_b);
     EXPECT_FLOAT_EQ(cross.x, 0.0f);
     EXPECT_FLOAT_EQ(cross.y, 0.0f);
     EXPECT_FLOAT_EQ(cross.z, 1.0f);
@@ -381,7 +381,7 @@ TEST_F(UnitTestVector3, Subtraction_NegativeValues)
 // Test AsTuple method
 TEST_F(UnitTestVector3, AsTuple)
 {
-    const auto tuple = v1.AsTuple();
+    const auto tuple = v1.as_tuple();
     EXPECT_FLOAT_EQ(std::get<0>(tuple), v1.x);
     EXPECT_FLOAT_EQ(std::get<1>(tuple), v1.y);
     EXPECT_FLOAT_EQ(std::get<2>(tuple), v1.z);
@@ -390,20 +390,20 @@ TEST_F(UnitTestVector3, AsTuple)
 // Test AsTuple method
 TEST_F(UnitTestVector3, AngleBeatween)
 {
-    EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).AngleBetween({1, 0 ,0}).value().AsDegrees(), 90.0f);
-    EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).AngleBetween({0.0f, 0.0f, 1.0f}).value().AsDegrees(), 0.0f);
-    EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).AngleBetween({0.0f, 0.0f, 1.0f}).has_value());
+    EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).angle_between({1, 0 ,0}).value().as_degrees(), 90.0f);
+    EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).angle_between({0.0f, 0.0f, 1.0f}).value().as_degrees(), 0.0f);
+    EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).angle_between({0.0f, 0.0f, 1.0f}).has_value());
 }
 
 TEST_F(UnitTestVector3, IsPerpendicular)
 {
-    EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).IsPerpendicular({1, 0 ,0}), true);
-    EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).IsPerpendicular({0.0f, 0.0f, 1.0f}), false);
-    EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).IsPerpendicular({0.0f, 0.0f, 1.0f}));
+    EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({1, 0 ,0}), true);
+    EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({0.0f, 0.0f, 1.0f}), false);
+    EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).is_perpendicular({0.0f, 0.0f, 1.0f}));
 }
 
 // Static assertions (compile-time checks)
-static_assert(Vector3(1.0f, 2.0f, 3.0f).LengthSqr() == 14.0f, "LengthSqr should be 14");
-static_assert(Vector3(1.0f, 2.0f, 3.0f).Dot(Vector3(4.0f, 5.0f, 6.0f)) == 32.0f, "Dot product should be 32");
-static_assert(Vector3(4.0f, 5.0f, 6.0f).DistToSqr(Vector3(1.0f, 2.0f, 3.0f)) == 27.0f, "DistToSqr should be 27");
-static_assert(Vector3(-1.0f, -2.0f, -3.0f).Abs() == Vector3(1.0f, 2.0f, 3.0f), "Abs should convert negative values to positive");
+static_assert(Vector3(1.0f, 2.0f, 3.0f).length_sqr() == 14.0f, "LengthSqr should be 14");
+static_assert(Vector3(1.0f, 2.0f, 3.0f).dot(Vector3(4.0f, 5.0f, 6.0f)) == 32.0f, "Dot product should be 32");
+static_assert(Vector3(4.0f, 5.0f, 6.0f).distance_to_sqr(Vector3(1.0f, 2.0f, 3.0f)) == 27.0f, "DistToSqr should be 27");
+static_assert(Vector3(-1.0f, -2.0f, -3.0f).abs() == Vector3(1.0f, 2.0f, 3.0f), "Abs should convert negative values to positive");

tests/general/unit_test_vector4.cpp

@@ -180,20 +180,20 @@ TEST_F(UnitTestVector4, NegationOperator)
 // Test other member functions
 TEST_F(UnitTestVector4, LengthSqr)
 {
-    constexpr float lengthSqr = Vector4(1.0f, 2.0f, 3.0f, 4.0f).LengthSqr();
+    constexpr float lengthSqr = Vector4(1.0f, 2.0f, 3.0f, 4.0f).length_sqr();
     EXPECT_FLOAT_EQ(lengthSqr, 30.0f);
 }
 
 TEST_F(UnitTestVector4, DotProduct)
 {
-    constexpr float dot = Vector4(1.0f, 2.0f, 3.0f, 4.0f).Dot(Vector4(4.0f, 5.0f, 6.0f, 7.0f));
+    constexpr float dot = Vector4(1.0f, 2.0f, 3.0f, 4.0f).dot(Vector4(4.0f, 5.0f, 6.0f, 7.0f));
     EXPECT_FLOAT_EQ(dot, 60.0f);
 }
 
 TEST_F(UnitTestVector4, Abs)
 {
     Vector4 v3 = Vector4(-1.0f, -2.0f, -3.0f, -4.0f);
-    v3.Abs();
+    v3.abs();
     EXPECT_FLOAT_EQ(v3.x, 1.0f);
     EXPECT_FLOAT_EQ(v3.y, 2.0f);
     EXPECT_FLOAT_EQ(v3.z, 3.0f);
@@ -202,14 +202,14 @@ TEST_F(UnitTestVector4, Abs)
 
 TEST_F(UnitTestVector4, Sum)
 {
-    constexpr float sum = Vector4(1.0f, 2.0f, 3.0f, 4.0f).Sum();
+    constexpr float sum = Vector4(1.0f, 2.0f, 3.0f, 4.0f).sum();
     EXPECT_FLOAT_EQ(sum, 10.0f);
 }
 
 TEST_F(UnitTestVector4, Clamp)
 {
     Vector4 v3 = Vector4(1.0f, 2.0f, 3.0f, 4.0f);
-    v3.Clamp(1.5f, 2.5f);
+    v3.clamp(1.5f, 2.5f);
     EXPECT_FLOAT_EQ(v3.x, 1.5f);
     EXPECT_FLOAT_EQ(v3.y, 2.0f);
     EXPECT_FLOAT_EQ(v3.z, 2.5f);